# AppSignal vs Bugsnag: A Hands-On Error Tracking Comparison for 2026

The bug that sorted these two tools apart was the one that threw nothing at all. My test app has a promise that rejects with no `catch`, and BugSnag reported it on the first run while AppSignal never did. Two releases later, checkout got more than 2,000 times slower without a single exception, and only AppSignal could see it.

Most of what follows comes back to that pair of bugs. **BugSnag is SmartBear's error and stability monitor:** it tallies sessions for each version you ship, scores how many ran without a crash, and leaves request timing to OpenTelemetry.

AppSignal reaches much further. **AppSignal is application monitoring aimed at small teams,** bundling errors, tracing, query timing, logs, server metrics, uptime checks and cron heartbeats into a single product billed by request count. The Node.js package ships its own agent and is built on OpenTelemetry.

[ad-logs]

The coverage in my test wasn't equal, and the verdicts take that into account. AppSignal ran on the storefront and the API through all three releases. BugSnag ran on the API only, through the first two releases. Sections that only one tool reached are labeled, and their verdicts don't count against the other.

The sections run from setup and capture through debugging, grouping and releases, then browser errors, timing, logs, servers, alerting, AI and cost.

## AppSignal vs BugSnag: Results at a glance

These calls come from one Express API written as ES modules. On a CommonJS codebase, or with BugSnag's browser SDK in the mix, some of them might change.

| Area | Better in my test | Why |
|---|---|---|
| Setup | **BugSnag** | Two middlewares and sessions for free; AppSignal's wizard assumes CommonJS |
| Server error capture | **BugSnag** | Caught all six server bugs; AppSignal missed the unhandled rejection |
| Debugging an error | **BugSnag** | Native breadcrumbs and Correlated events; neither showed server code |
| Error grouping | Tie | Both gave every server bug its own row |
| Releases and regressions | **BugSnag** | Reopened with the reason logged, plus a stability score per version |
| Browser errors and source maps | AppSignal only | BugSnag's browser SDK wasn't part of my test |
| Performance | **AppSignal** | Per-deploy means found the slow query; BugSnag needs OpenTelemetry |
| Logs and metrics | AppSignal only | BugSnag stores neither |
| Hosts, uptime and cron | AppSignal only | Server metrics and a heartbeat check worked; BugSnag offers neither |
| Alerts | Not compared | I wired up no notification channel in either |
| AI-assisted debugging | Not compared | Each offers an MCP server for your own assistant; I ran neither |
| Price | **AppSignal** | A free plan with five times the data and published prices; BugSnag lists no paid figure |

## How I tested AppSignal and BugSnag

The test app is monitoring-lab, a small bookstore that fails on purpose. An Express API stores orders in SQLite, calls a price service that breaks on cue and runs a sales report every minute. A Vite storefront sits in front of it. Each tool plugs in through one server adapter and one browser adapter, so the app's own code never changes.

The failures I planted:

- **API crashes:** an unknown coupon code throws a `TypeError` at checkout, which I'll call the coupon bug, and a missing book throws another.
- **Handled API errors:** sold-out books at checkout and price lookups that return 503, both reported by the app's own code.
- **An unhandled promise rejection:** the recommendations call rejects with nothing to catch it.
- **Job failures:** some sales report runs fail.
- **Storefront failures:** a wishlist `TypeError`, an unhandled rejection in order tracking, and failed API calls.

Two shoppers, alice and bob, browse in headless Chromium, and a third, carol, calls the API directly.

### The releases

| Version | What it tests |
|---|---|
| 1.0.0 | Getting data in, what each error page shows, how bugs group |
| 1.1.0 | I close the coupon bug in both tools and ship it again, untouched |
| 1.2.0 | AppSignal only: a slow lookup at checkout and a payment error on one charge in five |

1.1.0 asks whether a tool notices a fix that didn't hold. 1.2.0 asks whether it can separate a slow release from a broken one.

### SDKs and test limitations

| Platform | AppSignal | BugSnag |
|---|---|---|
| Node.js server | `@appsignal/nodejs` 3.9.4 | `@bugsnag/js` with `@bugsnag/plugin-express` |
| Browser | `@appsignal/browser` 1.0.0-beta.9 | Not tested |
| Tracing | Built in, on OpenTelemetry | Not tested, needs OpenTelemetry |
| Plan | Trial | 14-day trial |

- **BugSnag only saw the API, for 1.0.0 and 1.1.0.** Its browser package, its OpenTelemetry-based performance product and the 1.2.0 release are untested here.
- **AppSignal's browser SDK is a beta,** listed under Labs.
- **AppSignal's host and cron monitoring** were tested on a Linux server afterwards.
- **Not tested in either:** alert delivery and AI features.

### Terms in each tool

| Idea | AppSignal | BugSnag |
|---|---|---|
| Grouped errors | Error incident | Error |
| One occurrence | Sample | Event |
| Fixed | Closed | Fixed, held until a newer version |
| Release | Revision, which creates a deploy | `appVersion` on the client |
| Release health | Performance per deploy | Session stability |

## Setup and onboarding

Both install from npm in a few lines. The difference was how well each wizard matched my app.

### AppSignal: A wizard written for CommonJS

AppSignal asks for your language and framework, then builds an `appsignal.cjs` config for you:

![AppSignal onboarding with the appsignal.cjs file](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/88971dd6-b46a-4dfd-e107-926cf8458e00/md1x =1512x802)

Its start command loads that file with `node --require`, which ES modules ignore. My adapter had to register OpenTelemetry's import hook itself before any Express route showed up in a trace. A placeholder key in my `.env` produced "Uh-oh! No data received" at first, and the page pointed me to the agent log and a diagnose command. Once the correct key was in, the first samples showed up in under a minute. The `revision` option doubles as deploy tracking, so I never made a deploy call, and storefront errors landed in the same app under a namespace of their own.

### BugSnag: Two middlewares and sessions for free

BugSnag's onboarding asks where your code runs, from mobile and browser to server and console, then narrows to a framework. For Express, it shows `Bugsnag.start` with the API key, a request handler to mount before your routes and an error handler after them.

The Express plugin records a session for every request without any code, which is what powers BugSnag's release scores. The overview opened on them:

![BugSnag overview with session stability for release 1.0.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ba5d0dbb-dcb4-4570-3667-04043b1a7800/md2x =1126x737)

Release 1.0.0 reads 83.103% stable across 290 sessions, marked "Critical stability". Two performance monitors already showed as Alerting, though the app hadn't sent any performance data.

> **Worth checking on day one:** in AppSignal on an ES modules app, open your first trace and confirm Express spans are there. In BugSnag, set `appVersion` from your build, since every release score depends on it.

### Setup comparison

| Step | AppSignal | BugSnag |
|---|---|---|
| Server install | ✔: npm, plus an ESM hook | ✔: npm and two middlewares |
| ESM in the wizard | ✘: `--require` only | ✔: no loader needed |
| Release data without extra calls | ✔: deploys from `revision` | ✔: sessions from `appVersion` |
| Browser in the same app | ✔: separate namespace | Not tested |
| First-data troubleshooting | ✔: log and CLI pointers | Not needed |

**Verdict: BugSnag.** Its server setup was shorter and gave me release health without asking. AppSignal's wizard needs an ESM workaround that it never mentions.

## Error capture

Both tools received the same six API failures. Only one reported all of them.

### BugSnag: Six bugs, six rows, crashes marked

After 1.0.0, BugSnag's inbox held exactly six errors:

![BugSnag inbox with six errors after release 1.0.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/41cb6591-5e64-46cd-5750-81874b813100/orig =1126x737)

The two TypeErrors that fail almost identically still got separate rows. Each row carries a handled or unhandled badge, and side views such as Introduced Today and For review narrow the list.

The recommendations rejection is in there too. It carries the unhandled badge and a single frame, `loadRecommendations`. Node.js hands over nothing more for a rejection nobody awaits.

### AppSignal: Both tiers in one list, one bug missing

AppSignal kept the browser and server errors together in a single list, each row with "In selection" and "Total" counts:

![AppSignal errors list after the first run](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/4011f775-169a-4f07-1df2-68fb25c66400/orig =1512x802)

The recommendations rejection never arrived as an error. It showed up only in AppSignal's logs, because my app writes a log line for it. Storefront `ApiError`s are grouped per route pattern, giving `/orders` failures and `/books/:id` failures a row each. The browser SDK also reports each failed fetch as an `HTTPError`, so one failed call can appear twice.

### Error capture comparison

| Test | AppSignal | BugSnag |
|---|---|---|
| Coupon and book TypeErrors | ✔: separate incidents | ✔: separate errors |
| Handled errors | ✔: captured | ✔: captured, badged handled |
| Unhandled promise rejection | ✘: missed, logs only | ✔: caught |
| Report job failures | ✔: captured | ✔: captured |
| Handled or unhandled on each row | ✘: not shown | ✔: badge |
| Browser and server in one list | ✔: by namespace | Not tested |

**Verdict: BugSnag.** It caught every server failure and labeled the crashes. AppSignal's single list is convenient, but test your rejection handling before you trust it.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/-26mmryojE4" title="Error tracking | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

AppSignal and BugSnag both received the coupon crash, and neither showed the code around it, as the next section covers. When the same API bugs went to Better Stack, its error page showed the code itself:

![Better Stack coupon error with the source line highlighted](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/7ca5550a-dddc-4a42-e1ff-3e3a0d688c00/lg2x =1126x737)

The broken line is highlighted between its neighbors, so you can read the bug without switching to your editor. The six bugs also stayed in six groups, which matches BugSnag's capture with a code view added.

**[See the failing line on every error](https://betterstack.com/error-tracking)**
[/summary]

## Debugging an error

Capture gets the bug into the tool. The error page then has to say whose request failed, what led up to it, and where in the code it broke.

### BugSnag: The rest of the visit, a tab away

A BugSnag event splits into tabs for the stack trace, breadcrumbs, request, user, device, your own metadata and Correlated events. The stack trace gave a file and line, `server.js:38:45`, followed by router frames and no code. The breadcrumbs carried more:

![BugSnag breadcrumbs timeline for the coupon error](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/13456096-d09f-4176-0a2b-02af9c17f900/md1x =1126x737)

Look for the app's own "book found" crumb with the book's ID, title and stock, plus a type filter and search above the timeline. The tab that sets BugSnag apart is Correlated events:

![BugSnag Correlated events tab for one shopper](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ca3c6329-5b8f-476b-6f1d-66f45743e700/orig =1126x737)

carol's coupon crash appears next to the out-of-stock errors from her same session, so one page shows how the whole visit went wrong. Handled errors kept my metadata, such as book ID and quantity, in a Details tab.

### AppSignal: Strong in the browser, thin on the server

AppSignal's browser SDK records breadcrumbs on its own: fetches with status and timing, clicks with the button's label and hash navigation:

![AppSignal browser breadcrumbs with click and error](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/9cba6d82-975f-4c93-0961-aeb751111200/md2x =1512x802)

`button "Add to wishlist"` sits directly before the crash. The server side was weaker. AppSignal couldn't parse the ESM `file://` frame on the coupon error, so it showed a warning where code would be, and the Node.js SDK has no breadcrumbs API, so my server crumbs went in as custom data and display as JSON.

What AppSignal offers instead is **Time Detective**, which takes you from an error to everything the app recorded in the surrounding minute, from slow requests to host load and log lines.

### Debugging comparison

| Capability | AppSignal | BugSnag |
|---|---|---|
| Server source lines | ✘: ESM frame not parsed | ✘: frames only |
| Server breadcrumbs | Custom data as JSON | ✔: native, with filter and search |
| Other events from the same session | ✘: not offered | ✔: Correlated events |
| Browser breadcrumbs | ✔: clicks with labels, fetch timing | Not tested |
| Snapshot around the error | ✔: Time Detective | ✘: not offered |
| Request body and user | ✔: as tags and payload | ✔: Request and User tabs |

**Verdict: BugSnag.** On the server, which is the only side both tools covered, its breadcrumbs and Correlated events gave more context per error. AppSignal's browser crumbs and Time Detective are strong, but they fill a different gap.

## Error grouping

Ideally, one bug means one row and one row means one bug. Merge too eagerly and separate bugs hide together; split too eagerly and one bug buries the list.

### BugSnag: Default grouping, with options

At 1.0.0, BugSnag gave the six server bugs six rows. Each error shows the rule that grouped it, "Default grouping", and project settings let you group by error class or by context:

![BugSnag project settings with grouping and integration options](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/8d275c28-b762-4073-fb80-f5d822cfdb00/lg2x =1126x737)

Integrations live on that page too, next to a "Mark errors as fixed after each release" switch that starts in the off position.

### AppSignal: Class plus route, held through a code change

AppSignal groups by error class and action, which is the route. Release 1.2.0 rewired the async path through checkout, and every old bug stayed in its row while the new payment error got exactly one:

![AppSignal errors list on 1.2.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/9affef5a-dae3-4e51-f940-4ae3b0a4ea00/lg2x =1512x802)

The only clue that the payment error is new is that "In selection" equals "Total". It has no badge and sits fourth in a list sorted by last seen. I had to correct one thing in my adapter: errors reported after the request had finished arrived without a route, and calling `setError` while the request was still open fixed that.

### Grouping comparison

| Test | AppSignal | BugSnag |
|---|---|---|
| Server bugs at 1.0.0 | ✔: one row each, rejection missed | ✔: six errors |
| Grouping rule | Class and route | Default, by class or by context |
| Old bugs after the 1.2.0 code change | ✔: same rows | Not tested |
| New error marked as new | ✘: counts only | ✔: Introduced Today view |

**Verdict: Tie.** Both grouped correctly on the releases they shared. AppSignal's clean 1.2.0 list is a point in its favor that BugSnag never got to answer.

## Releases and regressions

For 1.1.0, I told both tools the coupon bug was fixed, then deployed code that still contained it.

### BugSnag: Fixed until a newer version, and a score per release

In BugSnag, a fixed error stays fixed only until a later version reports it. The first 1.1.0 checkouts brought the coupon bug back, and the error's activity feed recorded the reason:

![BugSnag activity showing the error reopened in 1.1.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/5f0672ec-21d4-4845-a942-338f1cb6f000/lg2x =1126x737)

The top entry says it reopened because it occurred in 1.1.0, with my fix and its condition below. In the inbox, though, the reopened row looks like any other open error, with no regression badge. The releases page is where BugSnag earns this section:

![BugSnag releases page with stability for 1.0.0 and 1.1.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/7950f4f0-2e49-480d-d43e-9b33d86c6500/lg2x =1126x737)

Both versions carry a stability figure, 83.103% and then 83.893%, worked out from nothing more than the `appVersion` I set. The 1.1.0 page splits errors into "seen" and "introduced", and "introduced" was correctly empty, but it doesn't call out the bug that came back.

### AppSignal: Reopened by a notification rule, with no record

An AppSignal incident is Open, Work in progress or Closed, and a firing notification reopens a closed one. With the coupon error's alerting left at "First in deploy", the 1.1.0 revision woke it:

![AppSignal coupon error reopened on 1.1.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/65a09150-d48e-4061-9ebf-0313b52dde00/orig =1512x802)

The incident is Open again and holds a sample from 1.1.0, yet its header still dates it to 1.0.0. My close action is in the Logbook; the reopen isn't. The list's default "Most recent revisions" filter, which shows only errors seen in the newest release, works as a rough regression view, and the Deploys page counts errors per revision.

### Release comparison

| Capability | AppSignal | BugSnag |
|---|---|---|
| Fix tied to a version | ✘: not offered | ✔: until a newer version |
| Returning bug reopened | ✔: by notification rule | ✔: by version |
| Reason for the reopen recorded | ✘: not in the Logbook | ✔: in activity |
| Release health score | ✘: not offered | ✔: session stability |
| Errors introduced per release | Recent-revisions filter | ✔: release page |
| Regression label in the list | ✘: none | ✘: none |

**Verdict: BugSnag.** Version-aware fixes, a logged reason and a stability score per release answer "did this release make things worse" directly. AppSignal reopened the bug but didn't say why.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/E8JQPRVR20E" title="On-call overview | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

AppSignal and BugSnag both reopened the coupon bug, then listed it as one more open row. When I shipped 1.1.0 to Better Stack, the list itself flagged the comeback:

![Better Stack errors list with Reoccurred label](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ff9ed40b-81f9-4dea-bca1-9d2fdeccd200/lg1x =1512x744)

Only the coupon row switched to a red "Reoccurred". You notice a failed fix while scanning the list you already triage from, with no activity feed to open.

**[Catch fixes that didn't hold](https://betterstack.com/error-tracking)**
[/summary]

## Browser errors and source maps

This section is AppSignal only. BugSnag offers a browser SDK, but I didn't test it.

### AppSignal: Maps by API, mapped to the line

My storefront ran on localhost, so AppSignal couldn't fetch maps itself. Its API takes them with the push key you already have, tagged with the revision:

```command
curl -X POST \
  -F "name[]=http://localhost:5173/assets/index.js" \
  [highlight]-F "revision=1.2.0"[/highlight] \
  -F "file=@web/dist/assets/index.js.map" \
  "https://appsignal.com/api/sourcemaps?push_api_key=$APPSIGNAL_PUSH_API_KEY&app_name=monitoring-lab&environment=development"
```

After the upload, the wishlist crash pointed at the right file:

![AppSignal browser error with source code](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/e41047fa-4bc8-44bb-ed7c-ac1e47f33e00/lg1x =1512x802)

The top frame is now line 122 of `src/pages.js`, shown with its neighboring lines, and an "Application backtrace" switch folds away vendor code. The order-tracking rejection in the storefront was missed, like its server counterpart.

### AppSignal: Web Vitals as metrics

The browser SDK also sends CLS, FCP, INP, LCP and TTFB as metrics, tagged with `page_url` and `app_version`. There's no Web Vitals page, so you build a dashboard chart for each one.

| Capability | AppSignal | BugSnag |
|---|---|---|
| Browser errors | ✔: same app, own namespace | Not tested |
| Scripted source map upload | ✔: push key | Not tested |
| Automatic breadcrumbs | ✔: clicks, fetches, navigation | Not tested |
| Web Vitals | Metrics, chart them yourself | Needs OpenTelemetry, not tested |
| Browser error linked to its server trace | ✘: not joined | Not tested |

**Verdict: AppSignal only.** Its browser side worked from one beta package, with no vitals page. BugSnag's browser SDK needs its own test before you compare them.

## Performance monitoring

1.2.0 slowed checkout without throwing anything, so only a tool that times requests could notice. This is where the two differ most.

### AppSignal: The deploy that slowed checkout

The checkout action's page has a table called **Performance in the last deploys**:

![AppSignal performance per deploy for checkout](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ad71c436-657c-4494-63b8-dff9a771b400/lg2x =1512x802)

Mean checkout time sat at 2 ms for two revisions, then jumped to 4.59 s on 1.2.0. A successful checkout from that revision showed the cause:

![AppSignal slow checkout trace on 1.2.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/d4d05f99-9ded-481f-c91b-7746746c5900/md2x =1512x802)

Inside it, the `SELECT book for checkout` span ran for 3.06 s and the charge for 3.3 s. **Slow queries** promoted that SELECT to first place with 67.6% of total query impact, and outgoing HTTP calls were traced automatically, so the slow price service appeared under slow API requests.

Two things still fell short. Checkouts that died on the new payment error were stored with nothing below the root span, so the most interesting traces had no breakdown. And my anomaly trigger for the web namespace's mean above 1 s never fired, because fast requests elsewhere kept the average down.

### BugSnag: Performance arrives through OpenTelemetry

BugSnag's timing views run entirely on OpenTelemetry input, which the error package never produces:

![BugSnag performance page asking for the OpenTelemetry SDK](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/309143e2-6849-4eea-07dd-5e65c1586600/lg2x =935x737)

All four tabs, from page loads to custom spans, sit blank until an OpenTelemetry SDK feeds them. That's an advantage if your services already run OpenTelemetry, and a second rollout if they don't.

### Performance comparison

| Capability | AppSignal | BugSnag |
|---|---|---|
| Server timing out of the box | ✔: same package | ✘: needs OpenTelemetry |
| Express, SQLite and fetch in traces | ✔: automatic | Not tested |
| Latency per deploy | ✔: per action | Not tested |
| Slow query ranking | ✔: by impact | Not tested |
| Spans on failed requests | ✘: root span only | Not tested |
| Triggers that caught 1.2.0 | ✘: namespace mean too low | Not tested |

**Verdict: AppSignal.** One table showed which deploy slowed checkout, and one trace showed which query. BugSnag can't see request timing until you add OpenTelemetry.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/7tQ7haFmSXI" title="Explore Traces | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

AppSignal's failed checkout kept only its root span, and BugSnag times nothing without OpenTelemetry. Better Stack stored the same failing 1.2.0 checkout with its full span tree:

![Better Stack spans on the failing 1.2.0 checkout](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/65353da5-9fc2-4deb-6b1a-26ad95621f00/lg1x =1512x744)

The book query accounts for 1.53 s and the declined payment for 660 ms of a 2.19-second request. Because the failed request carries its own breakdown, there's no need to dig up a healthy one for comparison.

**[Keep the spans on failed requests](https://betterstack.com/tracing)**
[/summary]

## Logs and metrics

AppSignal includes both. BugSnag stores neither, so you'd pair it with a log tool.

### AppSignal: Logging with Time Detective

Calling `Appsignal.logger()` shipped every app log line, tagged with level, hostname and fields, into a viewer that also tails live:

![AppSignal logs viewer](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/c0ef2347-8fbe-48e0-bdd0-ef646a5a6100/md2x =1512x802)

Each line can open its neighbors, launch Time Detective or become a metric. Error pages showed no logs at all until I tied log lines to traces. Custom metrics like checkout revenue have no default view, so each one needed a dashboard chart, roughly ten clicks apiece.

### BugSnag: Only what rides on the error

BugSnag keeps breadcrumbs and metadata attached to each event, and nothing beyond that. It has no log storage and no custom metrics.

| Capability | AppSignal | BugSnag |
|---|---|---|
| Searchable logs | ✔: plus live tail | ✘: none |
| Logs beside an error | ✔: after trace linking | ✘: none |
| Your own metrics | ✔: on dashboards | ✘: none |
| One view across signals | ✔: Time Detective | ✘: none |

**Verdict: AppSignal only.** It keeps logs and metrics next to the errors. With BugSnag, both mean another product.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/XJv7ON314k4" title="Live Tail Overview | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

AppSignal links logs to an error only after you connect logs and traces, and BugSnag has no logs at all. In Better Stack, the failed checkout's error page had a logs button, and it opened Live tail scoped to that single request:

![Better Stack Live tail filtered to one failing checkout](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/0bd2859e-1627-424b-5fcb-b7bb7027c200/public =1512x744)

Beside the failure is the request's slow-query warning, which names the cause before you search for anything.

**[Open an error's logs in one click](https://betterstack.com/log-management)**
[/summary]

## Hosts, uptime and cron jobs

This section is AppSignal only, because BugSnag doesn't monitor servers, uptime or scheduled jobs.

### Host metrics on a real server

Once the app moved to an Ubuntu server, CPU, memory and disk appeared without any setting, because the agent collects them on Linux:

![AppSignal host metrics list](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/41bd94a5-8509-4fae-58c3-a37638fd2a00/orig =1512x802)

The list leads with load, memory and disk, and opening a host gives you charts for processor, memory, swap, disk throughput and network, with each deploy drawn on the timeline.

### Heartbeat monitoring

Running the app under `appsignal-run` makes it emit heartbeats. I had to create a matching heartbeat monitor before any of them counted, which the CLI never mentioned. When I then killed the app, the monitor flipped to "Missed" roughly two minutes later. Uptime checks come with the plan too; my app lived on localhost, out of their reach, so they went untested.

| Capability | AppSignal | BugSnag |
|---|---|---|
| Server metrics | ✔: collected by the agent on Linux | ✘: none |
| Heartbeats for jobs | ✔: worked in my test | ✘: none |
| Uptime checks | In the plan, untested | ✘: none |

**Verdict: AppSignal only.** Teams that would otherwise add a server monitor and a cron checker can skip both.

## Alerts

I didn't connect Slack, email or a pager to either tool, so no alert actually went out.

On AppSignal's side, anomaly triggers watch a namespace for error rates and counts, throughput, slow actions, server metrics or your own metrics. Each error incident also has its own alerting setting, such as "First in deploy". My slow-actions trigger missed 1.2.0, as described above.

BugSnag sends email and connects to Slack, PagerDuty, Jira, Datadog, webhooks and more. Where it stands out is the snooze menu:

![BugSnag snooze options](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/6c865473-2d86-419a-2527-a99c34dc7000/public =1126x737)

A snooze can end on the next occurrence, after a set count, or once the error "impacts an additional" number of users, so a noisy error stays quiet until it starts reaching more people.

| Capability | AppSignal | BugSnag |
|---|---|---|
| Performance and host triggers | ✔: per namespace | ✘: errors only without OpenTelemetry |
| Per-error alert setting | ✔: such as first in deploy | ✔: through snooze conditions |
| Conditional snooze | ✘: not offered | ✔: by recurrence, count or users |
| Chat and incident integrations | ✔: offered | ✔: Slack, PagerDuty and more |
| Alert delivery tested | ✘: no | ✘: no |

**Verdict: Not compared.** AppSignal can alert on more kinds of signal, and BugSnag has the better triage controls for errors.

## AI-assisted debugging

AppSignal's Intelligence menu offers an MCP server and a command-line tool. BugSnag adds a "Fix with MCP" button to every error, which sends you to install the SmartBear MCP Server so an outside assistant can read your errors. I didn't run either, so treat this as a feature list.

![BugSnag Fix with MCP prompt to install the MCP server](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/6b9f4b38-5469-4df9-884c-569311142e00/lg2x =1126x737)

It tells you this project hasn't connected the server yet; any analysis then runs in your editor, through whichever assistant you use.

| Capability | AppSignal | BugSnag |
|---|---|---|
| Built-in AI assistant | ✘: didn't find one | ✘: no |
| MCP server | ✔: offered, untested | ✔: SmartBear's, untested |

**Verdict: Not compared.** Both leave the AI to an assistant you bring.

[summary]
<iframe width="100%" class="aspect-video h-auto" src="https://www.youtube.com/embed/3bw21kiNAuM" title="AI SRE and MCP | Better Stack" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

Neither AppSignal nor BugSnag goes past handing data to an assistant you supply. Better Stack's AI SRE does the digging in the product itself, so I asked it to explain release 1.2.0:

![Better Stack AI SRE on release 1.2.0](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/9c18a3bf-a83b-4e4c-2b40-adaf417dfc00/md2x =1512x744)

It traced the slowdown to checkout's book query and tied ten failed charges out of 48 to the new payment error, in about four minutes for $0.49. The same agent is also reachable over MCP from your editor.

**[Ask AI SRE what a release broke](https://betterstack.com/ai-sre)**
[/summary]

## Pricing

AppSignal bills on requests per month, gives every plan the full feature set and never charges for going over. BugSnag sets prices for error events and spans with a volume slider and bills errors and performance as two plans.

I read AppSignal's pricing page on November 16, 2026 and BugSnag's on October 30, 2026. Both may have moved since, so confirm them on the vendors' sites.

### Free plans and trials

| At signup | AppSignal | BugSnag |
|---|---|---|
| Free plan | ✔: 30,000 requests a month | ✔: 7,500 events a month |
| Free users | Unlimited | 1 |
| Free retention | 5 days | 7 days |
| Free extras | 1 GB of logs | 1M spans, needs OpenTelemetry |
| Trial | A month on paid tiers, card not required | Two weeks, card not required |

### Entry-level paid plans

| Cheapest paid tier | AppSignal | BugSnag Select |
|---|---|---|
| Price | $279 a year | Price not listed |
| Volume | 250,000 requests | 50,000 to 3M events, 1M to 150M spans |
| Over your limit | No charge; AppSignal reviews the plan a month later | Move up a volume tier |
| Retention | Not listed | 60 days |
| Includes | Errors, traces, logs, hosts, uptime | Errors, with spans on the same slider |

For both Select and Preferred, BugSnag's page shows only "Starting at $0" next to the slider, so getting a real figure means picking a volume or contacting sales. AppSignal sells long-term log retention and HIPAA compliance as $89-a-month add-ons.

### Comparing the actual cost

Paid yearly, AppSignal's smallest plan is about $23 a month, and that buys 250,000 requests of errors, traces, logs, server metrics and uptime. BugSnag's free plan is generous with events for one person but stops at a single user and seven days of data, and its paid price depends on the slider.

A bad release hits the two meters differently. AppSignal's is request-based with no overage fees, so a burst of exceptions doesn't change the bill. BugSnag meters events, so the same burst uses up your tier. For AppSignal against a cheaper error tracker, see our [AppSignal vs Honeybadger comparison](https://betterstack.com/community/comparisons/appsignal-vs-honeybadger/).

**Verdict: AppSignal.** It publishes its prices and covers far more per dollar. BugSnag is cheaper to try for a solo developer who only needs errors.

## Full feature comparison

| Feature | AppSignal | BugSnag |
|---|---|---|
| Main focus | APM, errors, logs and hosts | Errors and release stability |
| ESM support in onboarding | ✘: `--require` only | ✔: no loader needed |
| Server errors caught | Five of six | ✔: all six |
| Handled and unhandled badges | ✘: not shown | ✔: on every row |
| Server source lines | ✘: ESM frames not parsed | ✘: frames only |
| Server breadcrumbs | Custom data | ✔: native |
| Correlated events | ✘: not offered | ✔: same user and session |
| Fix tied to a version | ✘: not offered | ✔: until a newer version |
| Release stability score | ✘: not offered | ✔: session stability |
| Automatic deploys | ✔: from the revision | ✔: from `appVersion` |
| Browser errors and source maps | ✔: push-key upload | Not tested |
| Server tracing | ✔: built in | Needs OpenTelemetry |
| Latency per deploy | ✔: per action | Not tested |
| Logs and custom metrics | ✔: in every plan | ✘: none |
| Servers, uptime, cron | ✔: in every plan | ✘: none |
| Conditional snooze | ✘: not offered | ✔: by recurrence, count or users |
| AI | Via MCP | Via MCP |
| Free plan | ✔: 30,000 requests, any number of users | ✔: 7,500 events, a single user |
| Published paid prices | ✔: yes | ✘: slider, no figure |

## Which should you choose?

BugSnag is the better error tracker. AppSignal is the better monitoring platform. Your choice depends on which of those you're actually shopping for.

### Choose AppSignal if you'd rather run one backend tool than four

- **Slow releases are your real problem.** The per-deploy table and the query ranking took me from "checkout is slow" to the guilty SELECT almost immediately.
- **You're tired of tool sprawl.** Logs, custom metrics, server stats, job heartbeats and uptime all come with the same subscription.
- **Your budget needs to be fixed.** Prices are public, there are no overage fees, and the free tier doesn't cap users.

What you accept: manual ESM setup, a rejection it never reported, ESM stack frames without code, a browser package still in beta, and failed requests stored without child spans. Our [hands-on Sentry vs AppSignal test](https://betterstack.com/community/comparisons/sentry-vs-appsignal/) weighs it against a tool built around errors.

### Choose BugSnag if error quality and release health come first

- **You want every crash, labeled.** It caught all six server bugs and badged each row handled or unhandled.
- **You review each release.** Fixes hold until a newer version, reopens are logged with a reason, and every version gets a stability score.
- **You debug from the user's side.** Correlated events show the rest of a bad session on one page.

What you accept: request timing only after an OpenTelemetry rollout, no logs or server monitoring, a free plan for one person and paid prices you have to ask for. Our [Sentry vs BugSnag test](https://betterstack.com/community/comparisons/sentry-vs-bugsnag/) covers what a wider platform adds, and our [BugSnag vs Raygun comparison](https://betterstack.com/community/comparisons/bugsnag-vs-raygun/) weighs it against a tool that sells RUM and APM separately.

## FAQ

### Does AppSignal work with ES modules on Node.js?

Yes, but the onboarding only shows the CommonJS `--require` path. Register OpenTelemetry's import hook before your server loads, then confirm Express spans appear in your first trace.

### Does BugSnag monitor performance?

Only through OpenTelemetry. Its performance product lists page loads, inbound and outbound requests and custom spans, and the error SDK alone sends none of that.

### Which tool catches unhandled promise rejections on Node.js?

In my test, BugSnag did and AppSignal didn't. AppSignal saw the rejection only as a log line, because my app logged it.

### Which is cheaper?

AppSignal for most teams. Its free plan covers 30,000 requests with unlimited users, and $279 a year adds tracing, logs and hosts. BugSnag's free plan allows one user, and its paid prices depend on a volume slider.

## Final thoughts

The two tools split this comparison almost exactly along their own product lines. **BugSnag won every section about the errors themselves:** it caught the most, explained each event best and kept the clearest record of a fix that didn't hold. **AppSignal won everything around the errors:** the slow release, the logs, the server and the bill.

So the real decision is whether you need an error tracker or a backend monitor that also tracks errors. If you already run tracing and logs elsewhere, BugSnag is the sharper tool for the one job. If you don't, AppSignal replaces several tools at once.

Either way, **plant a promise rejection with no catch and make sure your tool reports it**.
