# Application Observability | Sentry

> Your observability stack accumulated over time. Sentry connects errors, traces, logs, replays, and application metrics in one place so you can find and fix problems faster.

**URL:** https://sentry.io/solutions/application-observability/

---

Traditional observability gives you more to accumulate: more dashboards, more silos, more tabs. Sentry connects errors, traces, logs, replays, and application metrics into workflows and issues so you can actually fix things faster.

## Details

### Trace requests across your entire stack

#### From browser to database, in one view

Modern applications span dozens of services, queues, and databases. Sentry's distributed tracing follows requests end-to-end so you can pinpoint exactly where slowdowns and failures originate. It works across frontend, backend, mobile, and AI agents running inside your app.

### One place for errors, traces, logs, replays, and metrics

#### Stop copying trace IDs between tools

[Logs](https://sentry.io/product/logs/), errors, traces, and metrics usually live in separate panes that don't talk to each other. Sentry connects all of these signals, including high-cardinality [application metrics](https://sentry.io/product/metrics/) that link back to traces, so you can go from symptom to root cause in one place. You can also send existing logs to Sentry via log drains, so your whole team is looking at the same data.

### Catch issues before users report them

#### Detect regressions at deploy time

Sentry detects regressions the moment they appear, not when a customer opens a support ticket. Anomaly detection surfaces latency spikes and error rate changes without manual threshold configuration. Performance Insights automatically finds N+1 queries, slow database calls, and render-blocking operations, ranked by user impact.

## Cookbook recipes

- **Adopt structured logging for faster debugging**: Replace noisy console.log and print statements with structured, queryable log events in Sentry using stable event names, dot-notated keys, and request context. — [Learn more](https://sentry.io/cookbook/structure-your-logs/)

- **Replace console.log with structured, trace-connected logging using LogTape and Sentry**: Set up LogTape with Sentry to replace console.log with structured, trace-connected logging. Query, alert on, and debug production issues with high-cardinality log data. — [Learn more](https://sentry.io/cookbook/structured-logging-logtape/)

- **Build a dashboard and alert from custom metrics in a Next.js app**: Emit a custom metric from your Next.js app, build a dashboard around it, and add a threshold or anomaly-detection alert that fires the moment it drifts. — [Learn more](https://sentry.io/cookbook/custom-metrics-dashboard-alerts-nextjs/)

- **Monitor Neon Functions with Sentry**: Add error tracking, structured logs, request tracing, and AI agent observability to your Neon Functions using the Sentry Node SDK. — [Learn more](https://sentry.io/cookbook/monitor-neon-functions-sentry/)

- **Set up a monitor and alert from a Supabase log drain**: Drain Supabase logs into Sentry, filter by severity and message, then create threshold monitors and alerts that notify your team when patterns change. — [Learn more](https://sentry.io/cookbook/setup-supabase-log-drain-monitoring/)

## Application observability FAQ

**What is application observability?**

Application observability is the practice of understanding what your application is doing in production using signals like errors, traces, logs, application metrics, and [session replays](https://sentry.io/product/session-replay/). Unlike infrastructure monitoring, which focuses on hosts and containers, application observability gives developers visibility into how their code behaves for real users.

**What's the difference between monitoring and observability?**

Monitoring tells you that something is wrong. Observability helps you understand why. Monitoring is detection-focused (dashboards, alerts), while observability is exploration-focused (connected [traces](https://sentry.io/product/tracing/), logs, and code context). Sentry goes a step further with what we call [debuggability](https://blog.sentry.io/monitoring-observability-and-debuggability-explained/): not just identifying problems, but giving you the context to solve them down to the line of code.

**How is Sentry different from tools like Datadog or New Relic?**

Traditional observability platforms are built around infrastructure metrics and custom dashboards. Sentry is built for application developers: every error, trace, and log connects to the code that caused it. There's no complex agent setup, and pricing is transparent and predictable. As one team [put it on G2](https://www.g2.com/products/sentry/reviews/sentry-review-12552237): "The seamless integration and ease of use were reasons my team switched to Sentry from Datadog." If you're currently on New Relic, see our [migration guide](https://sentry.io/from/new-relic/).

**What platforms and layers does Sentry cover?**

Sentry covers frontend (JavaScript, React, Next.js, Vue, Angular), backend (Python, Node.js, Go, Java, .NET, Ruby, PHP), mobile (React Native, Flutter, iOS, Android), and AI agents (OpenAI Agents, Vercel AI). Distributed tracing connects all of these layers so you can follow a request from a button click through your API, database, and back. Over 100 SDKs with built-in OpenTelemetry support.

## Customer Story

> Sentry helps us bridge the gap between what the server sees and what the user feels. During any major incident, Sentry is the first thing we look at.

[Read the full story](https://sentry.io/customers/flo/)

- **50%** faster key transactions

- **99.9%+** crash-free sessions across 100M+ users

- **50+** backend deploys per day with full visibility

## Application observability resources

- [Workshop: Observability consolidation](https://sentry.io/resources/workshop-observability-consolidation/): Learn how to evaluate and consolidate your observability stack. Covers vendor evaluation, cost analysis, and migration strategies.

- [Debugging microservices and distributed systems](https://sentry.io/resources/debugging-microservices-and-distributed-systems/): Learn how to debug distributed systems with connected traces and code-level context.

- [Full-stack performance and debugging workshop](https://sentry.io/resources/full-stack-debugging-workshop-june-10/): 1.5 hours of hands-on walkthroughs covering tracing frontend to backend with Vite, React, Neon, and Drizzle.

## Comparison

### Traditional observability

Separate tools for errors, traces, logs, and metrics.

Requires agents, sidecars, and complex configuration.

Dashboards show metrics, not where the problem is in your code.

Threshold-based alerts that require manual tuning.

Pricing scales with data volume in ways that are hard to predict.

### Observability with Sentry

Errors, traces, logs, replays, and high-cardinality application metrics connected in one workflow.

SDK-based setup. Install and go, no infrastructure to manage.

Every issue and every metric links to the exact function, file, and commit.

Anomaly detection with no manual threshold configuration.

Transparent, predictable pricing with a generous free tier.

## 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/solutions/application-observability/](https://sentry.io/solutions/application-observability/)*