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

The second release of my test app quietly reintroduced a bug I'd closed, and its 1.2.0 release made checkout more than 2,000 times slower. Raygun handled the first one best: its deployment page listed the returning bug under Regressions with no extra work. AppSignal handled the second: a table on the checkout route showed the mean jump from 2 ms to 4.59 s on the deploy that caused it.

Each tool's best release view answered a different question, and that shapes this whole comparison. **AppSignal is an APM platform for small teams,** with errors, traces, slow queries, logs, host metrics, uptime and cron monitoring in one app, priced by request volume with no overage charges. Its Node.js package includes the agent and runs on OpenTelemetry.

**Raygun sells three products separately: Crash Reporting, Real User Monitoring and APM**. Its crash reporter has the stronger release workflow of the two, and its RUM measures page speed and Core Web Vitals for every visit.

[ad-logs]

Both tools watched my storefront and my API through all three releases, so the sections below compare them directly. One exception: Raygun's APM ran on 1.0.0 only, because installing it broke Raygun's own crash reporting, which I'll cover under performance.

You'll find them weighed on setup, capture, source maps, debugging, real user monitoring, grouping, releases, performance, logs and metrics, infrastructure, alerts, AI and pricing.

## AppSignal vs Raygun: Results at a glance

I followed each vendor's own instructions on a single Express API with a Vite front end, using trial accounts for both. A CommonJS app or a paid Raygun plan would make setup smoother for each.

| Area | Better in my test | Why |
|---|---|---|
| Setup | **AppSignal** | One app for both tiers; Raygun needs an application per tier and a queued browser loader |
| Error capture | **AppSignal**, narrowly | Both missed the unhandled rejection; AppSignal kept both tiers in one list |
| Source maps | **AppSignal** | API upload with the push key; Raygun's API needs a paid token |
| Debugging an error | **AppSignal** | Detailed browser breadcrumbs and Time Detective; neither showed server code |
| Real user monitoring | **Raygun** | Page loads, Core Web Vitals and sessions; AppSignal keeps vitals as raw metrics |
| Error grouping | **AppSignal** | One group per bug through 1.2.0; Raygun split by amounts and URLs |
| Releases and regressions | **Raygun** | Version-aware fixes, with a deployment page listing what came back |
| Performance | **AppSignal** | Per-deploy means and spans found the slow query; Raygun's APM broke its errors |
| Logs and metrics | **AppSignal** | Logs, custom metrics and dashboards; Raygun has neither |
| Hosts, uptime and cron | AppSignal only | Host metrics and heartbeats tested; Raygun offers none |
| Alerts | Not compared | No notifier was connected in either |
| AI-assisted debugging | Not compared | Both offer an MCP server; neither was tested |
| Price | **AppSignal** | A free plan and $279 a year for both tiers; Raygun starts at $40 a month for errors alone |

## How I tested AppSignal and Raygun

The app is monitoring-lab, a bookstore with deliberate faults. Shoppers use a Vite front end, orders go through an Express service writing to SQLite, a dummy pricing endpoint fails on cue, and a reporting job runs every sixty seconds. Each tool connects through one browser adapter and one server adapter, and nothing else in the app changes.

The planted failures:

- **Storefront:** the wishlist click crashes, order tracking leaves a rejection unhandled, and some API requests come back 404, 500 or 502.
- **API:** checkout dies on a bogus coupon, a book page dies on a missing book, sold-out stock raises a handled error, prices return 503, and the recommendations promise rejects with nothing to catch it.
- **Job:** occasional failed report runs.

alice and bob shop in headless Chromium, and carol calls the API directly.

### The releases

| Version | Purpose |
|---|---|
| 1.0.0 | Install, errors from both tiers, maps, first traces |
| 1.1.0 | The coupon crash marked fixed, then deployed again unchanged |
| 1.2.0 | A slow lookup at checkout plus a payment bug on one charge in five |

1.2.0 tests whether a tool can show you a slowdown and a new error from the same deploy.

### SDKs and test limitations

| Platform | AppSignal | Raygun |
|---|---|---|
| Browser | `@appsignal/browser` 1.0.0-beta.9 | `raygun4js` 3.1.4 with RUM |
| Node.js server | `@appsignal/nodejs` 3.9.4 | `raygun` 2.2.10 |
| Tracing | Built in, on OpenTelemetry | Separate agent with `raygun-apm` 2.3.0, first release only |
| Plan | Trial | 14-day trial |

- **Separate runs:** Raygun ran on October 23 and AppSignal on October 27, with the same traffic script. Counts don't line up between them.
- **AppSignal's browser SDK is a beta,** listed under Labs.
- **Host and cron monitoring** were tested for AppSignal on a Linux server afterwards. Raygun has no equivalent.
- **Not tested:** uptime checks, alert delivery and either tool's MCP server.

### Terms in each tool

| Idea | AppSignal | Raygun |
|---|---|---|
| Grouped errors | Error incident | Error group |
| One occurrence | Sample | Instance |
| Fixed | Closed | Resolved, optionally in a version |
| Release | Revision, which creates a deploy | `setVersion`, plus deployments |
| Browser and server | One app, two namespaces | Two applications |
| Request timing | Traces and actions | APM traces, RUM XHR timings |

## Setup and onboarding

You install each from npm, once per tier. AppSignal's wizard didn't fit my ESM app, and Raygun's structure added steps throughout.

### AppSignal: A wizard for CommonJS

AppSignal's onboarding picks a language, then a framework, then walks you through an `appsignal.cjs` file:

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

The wizard starts the app with `node --require`, which only works for CommonJS. My app uses ES modules, so the adapter had to register OpenTelemetry's import hook itself before Express would be traced. My first attempt failed with "Uh-oh! No data received", which was a placeholder key in my own `.env`, and the page pointed me at the log file and a diagnose command. With the right key, data arrived within a minute.

Setting `revision` in the config created a deploy automatically, with no separate deploy call. The browser SDK reported both tiers into the same app under separate namespaces.

### Raygun: An application per tier

Raygun's model is an application for each piece of your system, with products added one by one:

![Raygun create application form with notification defaults](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/7730796e-3b56-4056-25b4-65cdc95d2f00/public =2238x1566)

My storefront and API became two applications with separate keys and separate error lists. I couldn't leave onboarding until an event arrived, so I fired a bad-coupon request at the API. In the browser, `raygun4js` from npm reads its settings at the page's load event, so imported later from a module it never started. I copied the CDN snippet's queue and imported the library after load.

> **Worth turning on:** in AppSignal on an ESM app, confirm Express spans appear in your first trace, since the wizard's `--require` path won't trace them. In Raygun, keep the version string identical across your applications, since each one tracks its own deployments and regressions.

### Setup comparison

| Capability | AppSignal | Raygun |
|---|---|---|
| Both tiers in one app | ✔: namespaces | ✘: an application each |
| ESM support in the wizard | ✘: `--require` only | Not an issue |
| Browser SDK from npm | ✔: worked | Needed a queued loader |
| Deploys from the version | ✔: automatic | ✘: created separately |
| First-data diagnostics | ✔: log and CLI pointers | Waits on step three |

**Verdict: AppSignal.** One app with automatic deploys covered both tiers once the ESM hook was in. Raygun's two-application model adds work at setup and every step after it.

## Error capture

Both tools received both tiers, and both missed the same failure.

### AppSignal: One list, grouped by class and route

AppSignal's errors list held both namespaces, with "In selection" and "Total" counts on each row:

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

Browser `ApiError`s split by route template, so `/orders` and `/books/:id` failures get separate rows. The browser SDK also reports failed fetches as `HTTPError`, next to the app's own `ApiError`, so one failed call can count twice. The recommendations rejection never arrived. It only showed up in AppSignal's logs, because my app logs it.

### Raygun: Two lists, one split by URL

The API's application had five error groups, and the storefront's had eight, in a separate list:

![Raygun browser error groups split by URL](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/56902b55-07c6-47d2-01f1-e7b3399f2a00/public =1512x744)

One failed book load became four groups, one per book ID in the message. The recommendations rejection was missing here too.

### Error capture comparison

| Capability | AppSignal | Raygun |
|---|---|---|
| Browser crashes | ✔: captured | ✔: captured |
| API crashes | ✔: captured | ✔: captured |
| Unhandled rejection with an app listener | ✘: missed | ✘: missed |
| Report job | ✔: captured | ✔: captured |
| Both tiers in one list | ✔: by namespace | ✘: two applications |
| Failed fetches | Reported twice | Once, split by URL |

**Verdict: AppSignal, narrowly.** Both missed the same rejection. AppSignal's single list grouped browser failures by route, which is easier to read than four rows for one bug.

## Source maps

My storefront ran on localhost, so both tools needed uploads.

### AppSignal: An API call per file

AppSignal accepts maps through its API with the push key and 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"
```

The wishlist crash then showed `src/pages.js` at line 122, with the code around it:

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

An "Application backtrace" toggle hides library frames.

### Raygun: Hand-labeled uploads on the trial

To script uploads, Raygun asks for a Personal Access Token, and trial accounts can't make one. On the trial, you upload files in the **JS Source Map Center** and type a full URL for each one:

![Raygun Source Map Center with unlabeled files](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/4d84669b-b01f-40e1-216d-95b3fac48200/lg2x =2534x1482)

Bundle names change with each build, so the labeling repeats every release, and two labels swapped during my test. After fixing the labels, the **Re-process this error for Source Maps** button corrected errors that had already arrived.

### Source map comparison

| Capability | AppSignal | Raygun |
|---|---|---|
| Scripted upload | ✔: push key | ✘: paid token |
| Tied to a release | ✔: revision | By file URL |
| Fixes earlier errors | Not tested | ✔: Re-process button |
| Server source lines | ✘: `file://` frames not parsed | ✘: not shown |

**Verdict: AppSignal.** A scripted upload with a key you already have fits into any build. On a paid Raygun plan, the token would close most of this gap.

## Debugging an error

Neither tool showed server code. The rest of each error page differs.

### AppSignal: Detailed browser crumbs, thin server frames

AppSignal's browser SDK records breadcrumbs automatically: network calls with status and duration, clicks with the button's label and coordinates, hash navigation, and the error itself:

![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"` comes right before the crash. On the server, the coupon error carries the request body and the shopper as tags, but its backtrace has a parse warning on the app frame:

![AppSignal backend backtrace with a parse warning](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ca3d0cc7-7caa-4b6f-fb6f-dad3e5600a00/md1x =1512x802)

AppSignal couldn't read the ESM `file://` frame, so it showed no code. The Node SDK has no breadcrumbs API, so my server breadcrumbs went in as custom data and display as JSON. **Time Detective** makes up for some of it: from any error, it opens a one-minute snapshot of errors, performance, alerts, hosts and logs around that moment.

### Raygun: Request data and scoped breadcrumbs

Raygun's server error shows file and line with no code:

![Raygun server stack trace without code](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/7f7b2e48-5893-4afd-c5e1-27e35934bf00/lg2x =1512x744)

Its **HTTP** tab holds the request body, and its breadcrumbs belong to the request: POST /checkout, "checkout started", "book found". In the browser it logs clicks, route changes and XHR calls without any setup, and a **Customers** view gathers one person's sessions and errors.

### Debugging comparison

| Capability | AppSignal | Raygun |
|---|---|---|
| Server source lines | ✘: parse warning | ✘: not shown |
| Request body | ✔: payload | ✔: HTTP tab |
| Server breadcrumbs | Custom data as JSON | ✔: native, per request |
| Browser breadcrumbs | ✔: clicks with labels, fetch timing | ✔: clicks, XHR |
| Snapshot around the error | ✔: Time Detective | ✘: not offered |
| User history | Tags | ✔: Customers page |
| Browser error to server error | ✘: not joined | ✘: separate applications |

**Verdict: AppSignal.** Its browser crumbs and Time Detective gave more context per error. Raygun's native server breadcrumbs and Customers page are better than AppSignal's equivalents, so this one is close.

[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 never joined a browser error to its backend trace, and Raygun keeps the two tiers in separate applications. Better Stack put one storefront request on both sides into a single trace in my test:

![Better Stack timeline with browser and server spans](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/b980fb66-b9a0-438a-2be4-0225195d2300/public =1512x744)

The browser contributed 30 spans and the API 7, all under one trace ID. From a failed checkout you can step straight into the server exception.

**[Debug errors across browser and API](https://betterstack.com/error-tracking)**
[/summary]

## Real user monitoring

Raygun sells RUM as a product. AppSignal's browser SDK collects Web Vitals and leaves the presentation to you.

### Raygun: Pages, vitals and sessions

Raygun RUM's performance tab charts load time, FCP, LCP, CLS, INP and more across every visit:

![Raygun RUM performance overview](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/b5ebd5de-809c-40fd-3bb8-774d60f0ee00/lg2x =1512x744)

Virtual pages and XHR calls get their own tables with counts and timings, and each session is a timeline of pages with load times and errors. Routes like `/books/3` collapse into `/books/*`, so one slow book page hides in the average.

### AppSignal: Vitals as metrics

AppSignal's browser SDK sends CLS, FCP, INP, LCP and TTFB as metrics:

![AppSignal web vital metrics in the picker](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ee9f968a-5212-46c0-d56a-620df1305700/public =1512x802)

There's no Web Vitals page. You build a dashboard chart for each, and the `page_url` and `app_version` tags let you split them per page and release.

### RUM comparison

| Capability | AppSignal | Raygun |
|---|---|---|
| Core Web Vitals collected | ✔: as metrics | ✔: charted |
| Built-in vitals page | ✘: build your own | ✔: performance tab |
| Page and XHR tables | ✘: not offered | ✔: with counts and timing |
| Session timelines | ✘: not offered | ✔: per user |
| Split by release | ✔: `app_version` tag | ✔: Compare, page loads only |

**Verdict: Raygun.** It turns browser timings into pages you can read on day one. AppSignal collects the same numbers and asks you to chart them.

## Error grouping

1.2.0 changed the async path through checkout, which tests whether a tool keeps old bugs in their rows and gives a new bug just one.

### AppSignal: Class plus action

AppSignal groups by error class and the action, which is the route. The new payment error arrived as one incident, and old bugs stayed in their rows:

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

The payment error's "In selection" equals its "Total", the only sign it's new. It has no badge and sits fourth, sorted by last seen. One fix was mine: handled errors sent outside a request lost their route, until my adapter used `setError` inside requests.

### Raygun: Message text in the group

Raygun's Node grouping included the message. The payment error split by charge amount:

![Raygun 1.2.0 errors list with payment errors split](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/5193104c-25f5-443b-9a6d-5863c14ebf00/md1x =1512x744)

Charges of 44 USD and 35.5 USD failed identically yet got their own rows. The release also duplicated the coupon crash and the out-of-stock error into fresh groups beside the originals.

### Grouping comparison

| Behavior | AppSignal | Raygun |
|---|---|---|
| Groups by | Class and route | Message and stack |
| New payment bug | ✔: one incident | ✘: one group per amount |
| Old bugs in 1.2.0 | ✔: same rows | ✘: new duplicate groups |
| Browser API failures | By route | By URL |
| New-error signal | In selection equals Total | Deployment's New errors tab |

**Verdict: AppSignal.** It kept one row per bug through the release that changed timing. Raygun's list after 1.2.0 needed cleanup before it told the truth.

## Releases and regressions

Before 1.1.0, I closed the coupon crash in AppSignal and resolved it in Raygun. Then it shipped again.

### AppSignal: Reopened by notification rules

An incident in AppSignal can be Open, Work in progress or Closed, and a notification firing will reopen a closed one. With alerting on the coupon error left at "First in deploy", the new revision woke it up:

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

It's Open again with a 1.1.0 sample, while the page still says it first occurred in 1.0.0. The Logbook recorded my close and nothing about the reopen. The errors list's default "Most recent revisions" filter shows only errors seen in the latest release, with per-release counts, which works as a rough regression view. The Deploys page lists errors and errors per hour per revision, without a detail page.

### Raygun: Resolved in the next version

Raygun offers **Resolve in next version**, which keeps the error resolved for 1.0.0 and reactivates it in anything newer:

![Raygun Resolve in next version dialog](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/c8fb7442-3eef-442a-e848-b8ee10252900/lg1x =1512x800)

A checkbox, on by default, discards further events until a newer version arrives. Deployments on the trial are entered by hand. Filling every field gave me a server error, and a second attempt with just the version saved. Once traffic arrived, the deployment flagged the bug:

![Raygun 1.1.0 deployment with one regression](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/1eec3e22-6d7f-4c1e-546f-ecf853d63600/lg2x =1512x744)

Its Regressions tab contains exactly one entry, the coupon crash, which logs "Error reoccurred" in its activity. In the main list, it's just another Active row.

### Release comparison

| Capability | AppSignal | Raygun |
|---|---|---|
| Fix tied to a version | ✘: not offered | ✔: next version or a named one |
| Returning bug reopened | ✔: by notification rule | ✔: in a newer version |
| Reopen recorded | ✘: not in the Logbook | ✔: "Error reoccurred" |
| Regressions per release | Recent-revisions filter | ✔: Regressions tab |
| Deploys | ✔: automatic from the revision | Manual or API |
| Label in the list | ✘: none | ✘: none |

**Verdict: Raygun.** Version-aware resolving and a Regressions tab answer "did my fix hold" without searching. AppSignal reopened the bug but left no record of 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 reopened the coupon bug with no record of it, and Raygun named it on a deployment page while the list row stayed plain. Better Stack's list labeled the returning bug when I shipped 1.1.0:

![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 turned red with "Reoccurred". You catch it in the list you already triage from.

**[See regressions the moment they return](https://betterstack.com/error-tracking)**
[/summary]

## Performance monitoring

This is where the two diverged most. AppSignal's tracing comes in the same package as its errors, and Raygun's needs a separate agent.

### AppSignal: The deploy that slowed checkout

The checkout action's summary 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)

Average checkout time held at 2 ms for two releases, then hit 4.59 s with the third. A successful checkout trace from that release explained it:

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

`SELECT book for checkout` took 3.06 s and the payment span 3.3 s. The **Slow queries** page re-ranked itself too, putting that SELECT at 67.6% of query impact. Outgoing HTTP calls were instrumented automatically, so the slow price service showed up under slow API requests with no code.

Two gaps: a checkout that failed with the new payment error kept only its root span, so the error's own trace couldn't explain its three seconds. And an anomaly trigger I set for the web namespace's mean above 1 s didn't fire, because fast requests kept the namespace mean below it. Triggers can't target one action.

### Raygun: RUM called it faster, and APM broke errors

Crash Reporting has no timing. RUM's release comparison for 1.1.0 against 1.2.0 said this:

![Raygun RUM comparison calling 1.2.0 faster](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/633d1236-219f-4c23-b4f6-2da7434dfc00/md2x =1512x744)

It rated 1.2.0 "34.8% faster" by median load time. The comparison only covers whole page loads, and those were unaffected. The slow checkout call isn't part of that comparison.

Raygun APM, tested on 1.0.0, runs as a separate agent beside the `raygun-apm` package. Its traces showed Node internals and idle time with no app functions, and SQLite isn't supported. Worse, the package swaps out `global.Error` on install, and from then on the crash reporter delivered built-in JavaScript errors with an empty message and stack, titled "Unknown error":

![Raygun errors arriving as Unknown error after APM was installed](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/44ed786c-b5a5-41dd-c08d-e753fc28f500/lg1x =1512x800)

Both TypeError crashes collapsed into that single row until I uninstalled it. Setting `RAYGUN_APM_CRASH_REPORTING_INTEGRATION=false` is the documented way around it.

### Performance comparison

| Capability | AppSignal | Raygun |
|---|---|---|
| Server spans | ✔: in the same package | ✔: separate agent |
| App code and queries in traces | ✔: Express, SQLite, fetch | ✘: Node internals only |
| Latency by deploy | ✔: per action | RUM page loads only |
| Slow query ranking | ✔: by impact | ✘: SQLite unsupported |
| Spans on errored traces | ✘: root span only | Not tested |
| Side effects | None found | Broke crash reporting |

**Verdict: AppSignal.** It found the slow query and the deploy behind it from one table. Raygun's release comparison crowned the bad release, and its APM damaged its own error reports.

[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 failing checkout kept only its root span, and Raygun's APM couldn't see SQLite at all. In Better Stack, the 1.2.0 payment error came with its child spans:

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

Within 2.19 s, the book lookup ran 1.53 s and the rejected charge 660 ms. The failed request explains its own time, with no need to find a successful one to compare.

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

## Logs and metrics

AppSignal includes both. Raygun includes neither.

### AppSignal: Logging, metrics and Time Detective

`Appsignal.logger()` sent my app's logs with severity, host and attributes, plus live tailing:

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

From any line you can jump to its surrounding context, open Time Detective, or turn it into a metric. Custom metrics such as checkout revenue appear only after you build a dashboard chart, which took about ten clicks each, and tag combinations are enforced in the picker.

### Raygun: Only what's on the error

Beyond the breadcrumbs and custom fields attached to errors, Raygun stores no logs and has no metrics.

### Logs and metrics comparison

| Capability | AppSignal | Raygun |
|---|---|---|
| Log storage and search | ✔: with live tail | ✘: not offered |
| Logs linked to errors | ✔: show in context | ✘: not offered |
| Custom metrics | ✔: dashboards | ✘: not offered |
| Snapshot across signals | ✔: Time Detective | ✘: not offered |

**Verdict: AppSignal.** It stores logs and metrics beside the errors. With Raygun, both need another product.

## Hosts, uptime and cron jobs

This section is AppSignal alone, because Raygun has no host, uptime or cron monitoring.

### Host metrics on a real server

After I moved the app to an Ubuntu box, CPU, memory and disk figures showed up without any setting, because the agent gathers them on Linux:

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

Load average, memory and disk sit in the list, and the host page charts CPU, memory, swap, disk I/O and network with deploy markers. A host usage view compares request performance per host.

### Heartbeat monitoring

`appsignal-run` wraps a process and sends heartbeats. Once I created a heartbeat monitor with a matching name, it showed the app running:

![AppSignal heartbeat monitor running](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/ef15b85c-6e2e-4753-455b-b9e76ded5200/md2x =1512x802)

When I stopped the app, the monitor turned red with "Missed" about two minutes later. The monitor has to exist before the wrapper's heartbeats count, and the CLI doesn't warn you. Uptime checks are included too, though they can't reach localhost, so I didn't test them.

| Capability | AppSignal | Raygun |
|---|---|---|
| Host metrics | ✔: automatic on Linux | ✘: not offered |
| Cron and heartbeat monitors | ✔: tested | ✘: not offered |
| Uptime checks | Included, not tested | ✘: not offered |

**Verdict: AppSignal only.** If you'd otherwise buy a separate tool for servers and scheduled jobs, AppSignal covers them.

## Alerts

Neither tool had a notifier connected, so nothing was delivered.

AppSignal's anomaly detection offers triggers for error rate, error count, throughput, slow actions, host metrics and custom metrics, per namespace. My slow-actions trigger didn't fire on 1.2.0, as described above. Errors carry an alerting setting per incident, such as "First in deploy".

Each new Raygun application emails you about new errors from the start, plus daily and weekly digests.

| Capability | AppSignal | Raygun |
|---|---|---|
| On by default | Per-error alerting setting | ✔: new error email |
| Performance triggers | ✔: per namespace | Not tested |
| Host and metric triggers | ✔: offered | ✘: not offered |
| Fired on 1.2.0 in my test | ✘: no | Not configured |

**Verdict: Not compared.** On paper, AppSignal has more triggers. Mine missed the regression, because triggers average a whole namespace.

## AI-assisted debugging

AppSignal lists an MCP server and a CLI under its Intelligence features. Raygun has a remote MCP server for assistants like Claude Code and Cursor. Neither has an assistant inside the app, and I tested neither server.

| Capability | AppSignal | Raygun |
|---|---|---|
| Assistant in the product | ✘: none seen | ✘: none |
| MCP server | ✔: listed, not tested | ✔: remote, not tested |

**Verdict: Not compared.** Both leave AI to the 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>

AppSignal and Raygun both stop at an MCP server for your own assistant. Better Stack's AI SRE runs the investigation itself, and it answered the 1.2.0 question in my test:

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

It attributed the slowdown to checkout's query and counted ten failures among 48 charges on 1.2.0, in roughly four minutes for $0.49, and the same agent is reachable over MCP from your editor.

**[Investigate releases with AI SRE](https://betterstack.com/ai-sre)**
[/summary]

## Pricing

AppSignal charges by monthly requests, with every feature on every plan and no overage charges. Raygun prices Crash Reporting, RUM and APM separately, each by volume.

Prices below come from both vendors' pages on November 16, 2026, and may have moved since.

### Free plans and trials

| At signup | AppSignal | Raygun |
|---|---|---|
| Free plan | ✔: 30,000 requests a month | ✘: none |
| Free logs | 1 GB | Not applicable |
| Free retention | 5 days | Not applicable |
| Users | Unlimited | Unlimited on paid plans |
| Trial | 30 days on paid plans, no card | 14 days on every plan |

### Entry-level paid plans

| Cheapest tiers | AppSignal | Raygun Crash Reporting | Raygun RUM | Raygun APM |
|---|---|---|---|---|
| Billed yearly | $279 a year | $40 a month | $80 a month | $80 a month |
| Billed monthly | Not listed | $60 | $120 | $120 |
| Volume | 250,000 requests | 100,000 errors | 100,000 sessions | 100,000 traces |
| Past the quota | Free; plan reviewed after 30 days | A tenth of a cent per error | Two tenths of a cent per session | Two tenths of a cent per trace |
| Includes | Errors, traces, logs, hosts, uptime | Errors | Page speed and sessions | Server traces |

AppSignal's add-ons include long-term log storage and HIPAA compliance at $89 a month each.

### Comparing the actual cost

AppSignal's entry plan, about $23 a month billed yearly, covers errors, tracing, logs, host metrics and uptime for 250,000 requests. Raygun's error tracking alone costs $40 a month yearly, and matching AppSignal's coverage with RUM and APM brings it to $200.

The meters differ too. AppSignal counts requests, not errors, and never bills overages, so a noisy release costs nothing extra. Raygun counts errors, and its discard option on resolved errors exists partly to save quota. For Raygun against another bundled plan, see our [Raygun vs Honeybadger comparison](https://betterstack.com/community/comparisons/raygun-vs-honeybadger/).

**Verdict: AppSignal.** It covers more for less. Raygun's RUM is worth its price only if page speed is something you report on.

## Full feature comparison

| Feature | AppSignal | Raygun |
|---|---|---|
| Both tiers in one app | ✔: namespaces | ✘: two applications |
| Unhandled rejection with an app listener | ✘: missed | ✘: missed |
| Source map upload on a trial | ✔: push key | ✘: manual only |
| Browser breadcrumbs | ✔: detailed | ✔: automatic |
| Server breadcrumbs | Custom data | ✔: native |
| Server source lines | ✘: ESM frames not parsed | ✘: not shown |
| Grouping through 1.2.0 | ✔: one row per bug | ✘: split by amount, duplicates |
| Resolve in next version | ✘: not offered | ✔: with discard |
| Regressions per release | Recent-revisions filter | ✔: Regressions tab |
| Automatic deploys | ✔: from the revision | ✘: created separately |
| Server tracing | ✔: built in | APM agent, broke crash reporting |
| Latency per deploy | ✔: per action | ✘: page loads only |
| Slow queries | ✔: ranked | ✘: not offered |
| Real user monitoring | Vitals as metrics | ✔: full product |
| Logs and metrics | ✔: included | ✘: not offered |
| Host, uptime and cron | ✔: included | ✘: not offered |
| AI | MCP server | MCP server |
| Free plan | ✔: 30,000 requests | ✘: trial only |

## Which should you choose?

AppSignal is the broader platform at a lower price. Raygun is stronger on two specific jobs: release reviews and front-end performance.

### Choose AppSignal if you want one tool for the whole backend

- **You care why a release got slower.** Per-deploy means and slow-query rankings pointed at the query in two clicks.
- **You'd rather not run more tools.** Logs, metrics, host monitoring, heartbeats and uptime are in the same plan.
- **You want predictable bills.** No overages, and a free plan for small apps.

The trade-offs: an ESM setup the wizard doesn't cover, no server code on ESM frames, a beta browser SDK, triggers that average a whole namespace, and errored traces without their child spans. Our [Sentry vs AppSignal comparison](https://betterstack.com/community/comparisons/sentry-vs-appsignal/) sets it against a tool with deeper error features, and our [AppSignal vs Honeybadger comparison](https://betterstack.com/community/comparisons/appsignal-vs-honeybadger/) against a cheaper error tracker.

### Choose Raygun if releases and page speed are what you report on

- **You review every deploy.** Resolve in next version and a Regressions tab show which fixes held.
- **Front-end speed is a product metric.** RUM tracks load times and Core Web Vitals for every visit.
- **You want error tracking you can buy on its own.** Crash Reporting stands alone without the other two products.

The trade-offs: separate applications per tier, grouping that splits on message values, manual source maps on the trial, an APM agent that can break crash reporting, and no logs or host monitoring. Our [Sentry vs Raygun comparison](https://betterstack.com/community/comparisons/sentry-vs-raygun/) puts Raygun beside a platform with fuller tracing.

## FAQ

### Does AppSignal support ES modules on Node.js?

Yes, but the onboarding wizard only shows the CommonJS `--require` path. For an ESM app, register OpenTelemetry's import hook before your server loads, then check that Express spans appear in your first trace.

### Can I use Raygun APM and Crash Reporting in the same Node.js app?

Only after changing one environment variable. Installing `raygun-apm` made built-in errors arrive empty in my test, and `RAYGUN_APM_CRASH_REPORTING_INTEGRATION=false` disables the integration responsible.

### Does AppSignal have real user monitoring?

Its browser SDK collects Core Web Vitals as metrics you can chart on a dashboard, split by page and release. It has no RUM pages or session timelines like Raygun's.

### Which is cheaper?

AppSignal. A free tier covers 30,000 requests monthly, and $279 a year buys a paid plan with tracing, logs and hosts. Raygun skips the free tier, and Crash Reporting alone costs $40 monthly on annual billing.

## Final thoughts

**AppSignal won more sections here, and it did so by covering the server deeply: traces that found the slow query, logs, metrics, hosts and cron jobs, all from one package**. Raygun's two wins were the ones its products are built around, a release workflow that names regressions and RUM that measures every page.

The decision is whether your hardest questions are about releases or about the backend. If your team reviews every deploy and reports on page speed, Raygun answers those questions better. If you need to know why the API got slow and what the server was doing at the time, AppSignal answers them for less money.

And if you do pick Raygun's APM for Node.js, turn off its crash reporting bridge before you install it.