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.
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:
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:
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:
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:
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 ApiErrors 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.
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:
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.
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:
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:
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:
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:
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:
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:
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:
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:
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.
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:
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.
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:
Copied!
curl -X POST \
-F "name[]=http://localhost:5173/assets/index.js" \
After the upload, the wishlist crash pointed at the right file:
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:
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:
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:
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.
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:
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.
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:
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.
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:
Beside the failure is the request's slow-query warning, which names the cause before you search for anything.
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:
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:
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.
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.
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:
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.
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.
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 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 covers what a wider platform adds, and our BugSnag vs Raygun comparison 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.