# Distributed Tracing | Monitor Performance Across Services

> Track requests across services with Sentry’s distributed tracing. Identify slow spans, fix bottlenecks, and improve performance across your entire stack.

**URL:** https://sentry.io/product/tracing/

---

Not sure why that API’s slow? Or where that crash came from? Sentry’s distributed tracing connects the full request path, from the first user action through every service and function call, so you find the root cause without digging through five different tools.

## Features

### Find the exact query slowing your app

A single bad query can bring your app to a crawl and run up your DB bill, but finding it among all your `EXPLAIN` outputs is tough. Jump straight to the query causing delays with Tracing and Insights.

### Pinpoint slow API calls across services

Your app usually loads fine, but some actions lag and you're not sure why. Trace Explorer shows which API calls are slow, whether it's an overloaded endpoint or a third-party service dragging. When spikes happen, filter by transaction, user, environment, or repo to find the cause.

### Trace slow UI back to the bottleneck

A user taps "Place Order" and waits. The checkout fires multiple requests, but one API call is lagging. Trace Explorer breaks down the full flow so you can see which request is the bottleneck and fix it before users bail.

### Debug vague LoadFailed errors

A missing module or failed request can break your app with a vague `LoadFailed` error and no clear cause. Instead of digging through network logs, use Sentry's Tracing to see the full chain of events. Whether it's a `404` on a missing file, a `CORS` rejection, or a Webpack resolution failure, you'll see exactly what happened.

## Use Cases

- **Catch slowdowns before users notice**:  — [Learn more](https://docs.sentry.io/product/monitors-and-alerts/alerts/)

- **Surface performance regressions after deploys**:  — [Learn more](https://docs.sentry.io/product/issues/issue-details/performance-issues/)

- **Track span performance over time**:  — [Learn more](https://docs.sentry.io/product/trace-explorer/#span-metrics)

- **Debug errors in background jobs**:  — [Learn more](https://www.youtube.com/watch?v=wb4Km8pCZRY&list=PLOwEowqdeNMpTNukOGxv37NHuQ1Ju7a-a&index=4)

- **Monitor and debug AI agent runs**:  — [Learn more](https://sentry.io/product/tracing/ai-agent/)

- **Build custom metrics dashboard in Next.js**:  — [Learn more](https://sentry.io/cookbook/custom-metrics-dashboard-alerts-nextjs/)

- **Fix checkout performance in React Native**:  — [Learn more](https://sentry.io/cookbook/track-checkout-performance-react-native/)

- **Automate performance triage**:  — [Learn more](https://sentry.io/cookbook/performance-bot-sentry-claude/)

- **Auto-fix regressions in Cursor**:  — [Learn more](https://sentry.io/cookbook/regressed-issue-to-pr-cursor/)

- **Route OTel traces to Sentry**:  — [Learn more](https://sentry.io/cookbook/route-opentelemetry-traces-to-sentry/)

- **Create structured logging with LogTape**:  — [Learn more](https://sentry.io/cookbook/structured-logging-logtape/)

- **Monitor Neon Functions**:  — [Learn more](https://sentry.io/cookbook/monitor-neon-functions-sentry/)

- **Track AI SDK costs in Next.js**:  — [Learn more](https://sentry.io/cookbook/monitor-ai-agent-costs-nextjs/)

- **Send AI SDK telemetry via OpenTelemetry**:  — [Learn more](https://sentry.io/cookbook/vercel-ai-sdk-otel-sentry/)

- **Monitor Claude Code costs**:  — [Learn more](https://sentry.io/cookbook/monitor-claude-code-with-sentry/)

- **Automate triage with Claude Routines**:  — [Learn more](https://sentry.io/cookbook/automate-ai-agent-triage-claude-routines/)

- **Monitor your MCP server**:  — [Learn more](https://sentry.io/cookbook/monitor-mcp-server/)

- **Agent conversations to evals**:  — [Learn more](https://sentry.io/cookbook/agent-conversations-to-evals/)

## FAQ

**What is Tracing?**

Tracing provides a connected view of related [errors](https://sentry.io/product/error-monitoring/) and transactions by capturing interactions among your software systems. With Tracing, Sentry tracks your software performance and displays the impact of errors across multiple systems.

**What languages and platforms is Tracing currently available for?**

Tracing is available for all languages and platforms that Sentry supports. [See the full list here](https://sentry.io/platforms/).

**How much does Tracing cost?**

To enable Tracing capabilities you need to purchase spans. See docs for [pricing details](https://docs.sentry.io/pricing/).

**How can I use Tracing?**

To use Tracing, you will first need a Sentry account. If you don’t have a Sentry account, you can [create one here](https://sentry.io/signup/). Then, follow the [instructions in our docs](https://docs.sentry.io/platform-redirect/?next=/tracing/) to use Tracing.

**Can I use OTel with Sentry Tracing?**

Yes, you can configure your OpenTelemetry SDK to send traces and spans to Sentry. [Learn more](https://docs.sentry.io/concepts/otlp/).

**What is agent tracing?**

[Agent tracing](https://sentry.io/product/tracing/ai-agent/) follows a single AI agent run from start to finish as a connected trace, capturing every LLM call, tool execution, and handoff as a span with its inputs, outputs, token counts, cost, and timing. Because AI agents make decisions across many steps, a flat log isn't enough; agent tracing shows you the full execution path so you can see exactly which step failed or stalled. [See how agent tracing works in Sentry](https://docs.sentry.io/product/agents/).

## Of course there’s more to distributed tracing

- [The Best Way to Debug Slow Web Pages](https://www.youtube.com/watch?v=v6wJgQRhY10): Tools like Page Speed Insights and Google Lighthouse are great for providing advice for front end performance issues. But what these tools can’t do, is evaluate performance across your entire stack of distributed services and applications.

- [Tracing for the Frontend to the Backend](https://www.youtube.com/watch?v=GSW7zJ9qFXM): Join Dustin Bailey as he shows how developers can trace those pesky performance issues to poor-performing API calls & slow database queries across all your services, from the frontend to the backend.

- [Tracing docs](https://docs.sentry.io/concepts/key-terms/tracing/): Learn more about the tracing features Sentry offers to help you track your software performance across multiple systems.

## Testimonials

> Monitoring a production environment is always a challenge, with regular deployments, third party integrations, and the cloud resources we depend on - the number of issues that can fire from any one system increases the complexity of figuring out which service or team owns what.

> — Roni Avidov, Monday.com

> If our app is slow, users won't wait—they'll just leave. Using Sentry to debug and monitor performance is a key factor to our success in keeping users in our app and engaged.

> — Vaidas Zlotkus, Flo Health

## Quick Start

### Python

Install the Sentry Python SDK with pip

```bash
pip install sentry-sdk
```

Configuration should happen as early as possible in your application's lifecycle.

```python
import sentry_sdk

sentry_sdk.init(
  dsn="https://examplePublicKey@o0.ingest.sentry.io/0",
  # Add data like request headers and IP for users, if applicable;
  # see https://docs.sentry.io/platforms/python/data-management/data-collected/ for more info
  send_default_pii=True,
  # Set traces_sample_rate to 1.0 to capture 100%
  # of transactions for tracing.
  traces_sample_rate=1.0,
  #Enable logs to be sent to Sentry
  enable_logs=True,
  # To collect profiles for all profile sessions,
  # set profile_session_sample_rate to 1.0.
  profile_session_sample_rate=1.0,
  # Profiles will be automatically collected while
  # there is an active span.
  profile_lifecycle="trace",
)
```

### JavaScript

Install the Sentry JavaScript SDK with npm

```bash
npm install @sentry/browser --save
```

Configuration should happen as early as possible in your application's lifecycle.

```javascript
import * as Sentry from "@sentry/browser";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  tracesSampleRate: 1.0,
  // Set tracePropagationTargets to control for which URLs trace propagation should be enabled
  tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
  integrations: [
    Sentry.browserTracingIntegration(),
    Sentry.browserProfilingIntegration(),
  ],
});
```

### React

Run the command for your preferred package manager to add the Sentry SDK to your application:

```bash
npm install @sentry/react --save
```

To import and initialize Sentry, create a file in your project's root directory, for example, `instrument.js`, and add the following code:

```javascript
import * as Sentry from "@sentry/react";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/react/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Set `tracePropagationTargets` to control for which URLs trace propagation should be enabled
  tracePropagationTargets: [/^//, /^https://yourserver.io/api/],
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
  integrations: [
    // If you're using react router, use the integration for your react router version instead.
    // Learn more at
    // https://docs.sentry.io/platforms/javascript/guides/react/features/react-router/
    Sentry.browserTracingIntegration(),
    Sentry.browserProfilingIntegration(),
  ],
});
```

Initialize Sentry as early as possible in your application. We recommend putting the import of your initialization code as the first import in your app's entry point:

```javascript
// Sentry initialization should be imported first!
import "./instrument";
import App from "./App";
import { createRoot } from "react-dom/client";

const container = document.getElementById("app");
const root = createRoot(container);
root.render(<App />);
```

To make sure Sentry captures all your app's errors, configure error handling based on your React version. 
 For React versions 19 and up:  

```javascript
import { createRoot } from "react-dom/client";
import * as Sentry from '@sentry/react';

const container = document.getElementById("app");
const root = createRoot(container, {
  // Callback called when an error is thrown and not caught by an ErrorBoundary.
  onUncaughtError: Sentry.reactErrorHandler((error, errorInfo) => {
    console.warn('Uncaught error', error, errorInfo.componentStack);
  }),
  // Callback called when React catches an error in an ErrorBoundary.
  onCaughtError: Sentry.reactErrorHandler(),
  // Callback called when React automatically recovers from errors.
  onRecoverableError: Sentry.reactErrorHandler(),
});
root.render();
```

For React versions 18 and below, use the ErrorBoundary component to automatically send errors from specific component trees to Sentry and provide a fallback UI:

```javascript
import React from "react";
import * as Sentry from "@sentry/react";

<Sentry.ErrorBoundary fallback={<p>An error has occurred</p>}>
  <Example />
</Sentry.ErrorBoundary>;
```

### Next.js

To install Sentry using the installation wizard, run thrun the following command and step through the prompts:

```bash
npx @sentry/wizard@latest -i nextjs
```

For manual installation run the following command and use the following configurations:

```bash
npm install @sentry/nextjs --save
```

Extend your app's default Next.js options by adding code with `withSentryConfig` into your `next.config.(js|mjs)` file:

```javascript
const { withSentryConfig } = require("@sentry/nextjs");
const nextConfig = {
  // Your existing Next.js configuration
};
// Make sure adding Sentry options is the last code to run before exporting
module.exports = withSentryConfig(nextConfig, {
  org: "example-org",
  project: "example-project",
  // Only print logs for uploading source maps in CI
  // Set to `true` to suppress logs
  silent: !process.env.CI,
  // Automatically tree-shake Sentry logger statements to reduce bundle size
  disableLogger: true,
});
```

#### Client-Side Configuration

```javascript
import * as Sentry from "@sentry/nextjs";
Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // We recommend adjusting this value in production
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
});

// This export will instrument router navigations, and is only relevant if you enable tracing.
// `captureRouterTransitionStart` is available from SDK version 9.12.0 onwards
export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
```

#### Server-Side Configuration

```javascript
import * as Sentry from "@sentry/nextjs";
Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // We recommend adjusting this value in production
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Enable logs to be sent to Sentry
  enableLogs: true,
});
```

#### Register Sentry Server-Side SDK Initialization

Create a Next.js Instrumentation file named `instrumentation.(js|ts)` in your project root or inside the `src` folder if you have one. Import your server and edge configurations, making sure that the imports point to your specific files:

```javascript
export async function register() {
  if (process.env.NEXT_RUNTIME === "nodejs") {
    await import("./sentry.server.config");
  }
  if (process.env.NEXT_RUNTIME === "edge") {
    await import("./sentry.edge.config");
  }
}
```

### Go

Grab the Sentry Go SDK:

```bash
go get "github.com/getsentry/sentry-go"
```

Configuration should happen as early as possible in your application's lifecycle.

```text
err := sentry.Init(sentry.ClientOptions{
  Dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Enable printing of SDK debug messages.
  // Useful when getting started or trying to figure something out.
  Debug: true,
  // Adds request headers and IP for users,
  // visit: https://docs.sentry.io/platforms/go/data-management/data-collected/ for more info
  SendDefaultPII: true,
  EnableTracing: true,
  // Set TracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  TracesSampleRate: 1.0,
})
if err != nil {
  log.Fatalf("sentry.Init: %s", err)
}
// Flush buffered events before the program terminates.
// Set the timeout to the maximum duration the program can afford to wait.
defer sentry.Flush(2 * time.Second)
```

### Ruby

Add the sentry-ruby gem to your Gemfile:

```ruby
gem "sentry-ruby"
```

Configuration should happen as early as possible in your application's lifecycle.

```ruby
require 'sentry-ruby'

Sentry.init do |config|
  config.dsn = 'https://examplePublicKey@o0.ingest.sentry.io/0'

  # get breadcrumbs from logs
  config.breadcrumbs_logger = [:sentry_logger, :http_logger]

  # Add data like request headers and IP for users, if applicable;
  # see https://docs.sentry.io/platforms/ruby/data-management/data-collected/ for more info
  config.send_default_pii = true
  # enable tracing
  # we recommend adjusting this value in production
  config.traces_sample_rate = 1.0
  # Enable logs to be sent to Sentry
  config.enable_logs = true
  # enable profiling
  # this is relative to traces_sample_rate
  config.profiles_sample_rate = 1.0
end
```

### PHP

Install the Sentry SDK using Composer:

```bash
composer require sentry/sentry
```

To use Profiling, you'll also need to install the Excimer extension via PECL:

```bash
pecl install excimer
```

To capture all errors, even the one during the startup of your application, you should initialize the Sentry PHP SDK as soon as possible.

```php
\Sentry\init([
  'dsn' => 'https://examplePublicKey@o0.ingest.sentry.io/0',
  // Add request headers, cookies and IP address,
  // see https://docs.sentry.io/platforms/php/data-management/data-collected/ for more info
  'send_default_pii' => true,
  // Specify a fixed sample rate
  'traces_sample_rate' => 1.0,
  // Enable logs to be sent to Sentry
  'enable_logs' => true,
  // Set a sampling rate for profiling - this is relative to traces_sample_rate
  'profiles_sample_rate' => 1.0,
]);
```

### .NET

Install the NuGet package to add the Sentry dependency:

```shell
dotnet add package Sentry -v 5.16.2
```

To use Profiling, you'll also need to install the Sentry.Profiling package:

```shell
dotnet add package Sentry.Profiling -v 5.16.2
```

To capture all errors, even the one during the startup of your application, you should initialize the Sentry .NET SDK as soon as possible.

```csharp
SentrySdk.Init(options =>
{
    options.Dsn = "https://examplePublicKey@o0.ingest.sentry.io/0";
    options.Debug = true;
    // Adds request URL and headers, IP and name for users, etc.
    options.SendDefaultPii = true;
    // A fixed sample rate of 1.0 - 100% of all transactions are getting sent
    options.TracesSampleRate = 1.0f;
    // A sample rate for profiling - this is relative to TracesSampleRate
    options.ProfilesSampleRate = 1.0f;
});
```

---

*Source: [sentry.io/product/tracing/](https://sentry.io/product/tracing/)*