The quota maths comes first. Tracing bills per span, and an uninstrumented request can quietly emit dozens.

What Is a Span and What Does Tracing Actually Record?

A transaction is the whole request. A span is a unit of work inside it — a database query, an HTTP call, a function you wrapped. Spans nest, forming a waterfall.

Automatic instrumentation covers HTTP servers, common database drivers, and fetch clients. Everything in your business logic needs Sentry.startSpan() wrapped around it, which is the part most teams skip and then wonder why the waterfall stops at the controller.

How Do I Choose a tracesSampleRate Without Blowing the Quota?

Estimate before enabling. Take monthly requests, multiply by average spans per request, multiply by the sample rate.

The Team plan includes a span allowance in the low millions; higher volumes are billed on top. Start at 0.05 and raise it only if you cannot find your slow path.

A useful trick: sample high for slow requests and low for fast ones. Sentry supports this through tracesSampler, where you return a rate based on the transaction context.

How Do I Add Custom Spans That Answer Questions?

Wrap the operations you suspect, not everything.

• Sentry.startSpan({ name: 'invoice.generate' }, () => ...) around a suspected hot path.
• op: 'db.query' on manual queries so they group with automatic ones.
• op: 'http.client' on outbound calls to third parties.

Add attributes to spans rather than creating new span names for each variant: span.setAttribute('invoice.items', count) keeps the waterfall readable while preserving the detail. Span name cardinality is what makes trace views unusable on large projects.

How Do I Read the Waterfall to Find the Real Problem?

Open a trace and look for the widest bar, not the deepest one. Width is time; depth is call hierarchy. People reflexively scroll to the bottom leaf, but the 1.8-second gap between two spans usually means something unaccounted for — a synchronous block, a DNS lookup, or a wait on a lock.

Sort transactions by p95 duration rather than average. A 40 ms average with a 3-second p95 is a page that times out for one user in twenty, and averages hide it entirely.

What Are the Common Instrumentation Mistakes?

Three, consistently:

1. Sampling at 1.0 in staging and copying the config to production.
2. Leaving the front-end browserTracingIntegration with default tracePropagationTargets, which drops the trace header on cross-origin API calls and splits your waterfall into two unlinked traces.
3. Wrapping spans around code that already has automatic instrumentation, doubling the span count for the same work.

When Is Tracing Not Worth the Spend?

If your p95 is under 200 ms, there is no user-visible problem to chase. Optimizing a 120 ms endpoint to 90 ms is engineering theatre.

Also skip it if your bottleneck is already known — a missing database index shows up in slow query logs for free. Tracing earns its cost on distributed systems where the slow step is not obvious from any single service’s logs.

Quick Summary

• A transaction is the request; spans are nested operations inside it.
• Estimate spans as requests × spans per request × sample rate before enabling.
• Start at 0.05 sample rate and use tracesSampler to favour slow requests.
• Read the widest bar, not the deepest leaf, and sort by p95 not average.
• Tracing only pays off when the bottleneck is genuinely unknown.

Source maps are the step people skip, and it is the one that makes Sentry useful. Without them every stack trace reads vendor.bundle.js:1:48213 and you learn nothing.

What Does Sentry Actually Do?

Sentry is an error tracking service. It receives exception events from your app, deduplicates them into issues, and shows frequency, affected users, and the release where it first appeared.

It is not APM and not logging. Datadog covers infrastructure metrics and logs; Sentry covers “this code threw an error, here is the payload that broke it.” Teams use both, and the overlap in cost is a common budget argument.

How Do I Install Sentry in a Node Back End?

npm install @sentry/node

Sentry.init({ dsn: process.env.SENTRY_DSN, environment: process.env.NODE_ENV, release: process.env.GIT_SHA, tracesSampleRate: 0.1 })

Initialize before your framework mounts. In Express, that means before app.use(...) calls — Sentry’s docs say it plainly and people still get empty traces because they initialized after routes.

Set tracesSampleRate below 1.0 unless traffic is small. A 0.1 sample gives statistically usable performance data without paying for every request.

How Do I Set Up the Front End Correctly?

For React, npm i @sentry/react, then call Sentry.init with your DSN and integrations: [Sentry.browserTracingIntegration()].

The essential step is source map upload:

1. Create an auth token in Sentry with project:releases scope.
2. Add sentry-cli to your build pipeline and run sentry-cli releases new $GIT_SHA.
3. Upload maps: sentry-cli releases files $GIT_SHA upload-sourcemaps ./dist.
4. Finalize: sentry-cli releases finalize $GIT_SHA.
5. Delete .map files from the deployed bundle.

That last step matters for two reasons: maps expose your source publicly if left in place, and Sentry needs them at upload time, not at runtime.

How Do I Stop Alert Noise?

The defaults send an email for every new issue, which produces hundreds of notifications in the first week. Fix in this order:

• Ignore patterns per project for browser extension errors — they are never your bug.
• Inbound filters to drop errors from localhost, bots, and known browser quirks.
• Alert rules scoped to level:error and an event count threshold (10+ in an hour) rather than every event.
• Release tag on every deploy, so you can tell new breakage from ignored old breakage.

What Does Sentry Cost?

The free Developer plan includes 5,000 errors per month, 50 session replays, and one user. That is enough for a side project and not enough for a production app with real traffic.

Team starts around $26 per month with 50,000 errors included, and pricing scales by event volume. The trap is noisy errors: one retry loop hitting an unhandled promise can burn your entire monthly quota in an afternoon. Quota exhaustion also disables alerts, so you find out from users instead.

Set a per-key rate limit (Sentry.init({... maxBreadcrumbs: 50}) plus a server-side rate limiter) before you go live.

Where Sentry Falls Short

Error grouping occasionally splits one bug into many issues when the stack differs, and merges unrelated bugs when fingerprints collide. You will spend time on issue hygiene.

Context depth is also limited by what you attach. Without breadcrumbs and user context, an error report is a stack trace with no story.

Who Should Use It

Any app with paying users and more than one engineer. Skip it for a static site with no JavaScript logic — there is nothing to throw.

Quick Summary

• Sentry groups exceptions into issues by stack fingerprint and tracks releases.
• Initialize before framework routes mount or traces come back empty.
• Upload source maps per release, then delete them from the deployed bundle.
• Free plan: 5,000 errors/month, one user — rate-limit noisy errors or quota dies fast.
• Not a replacement for logs or infrastructure metrics.