Your product tool won't help you fix what's broken

Sentry connects metrics, errors, logs, and session replays so you can go from a graph spike to the broken line of code without switching tools. Built for the developers doing the fixing, not for the dashboards watching.

Setup in seconds

More SDKs...

npx @sentry/wizard@latest -i nextjs

Tolerated by 4 million developers.

Instrument once. Ask anything.

Tag every measurement with the dimensions you actually debug with: customer_id, route, region, plan, build SHA, A/B variant. High cardinality is the default in Sentry, not a limit you have to engineer around. Don't pre-aggregate. Don't pre-decide which dimensions to keep at instrumentation time. Emit the raw measurement, then ask new questions later, without redeploying. Slice and group after the fact, like grouping checkout.failed by customer_id to surface the top affected accounts.

Best-in-class error monitoring.

Trace errors across your entire stack down to the failing functions and the broken line of code.

Skip the manual log hunting.

Every log line is already connected to the error or trace it came from. No global searches, no copying trace IDs between tools. Click into a failing request, filter by real metadata like customer_id or payment_id, and see exactly what broke.

Stop asking users to repro it.

Replay real user sessions to understand when, where, and how an error impacted your app. See the click, the network call, the broken state. Replays are linked to the errors and traces they belong to, with best-in-class privacy controls so sensitive data never leaves the user's device.

Most tools felt ops-first. Sentry is developer-first, which fits how we operate. One issue page, all the context: stack traces and source maps, release and version, commits, env and device, and one click to traces and replays. We get to answers fast.

Glenn Burnside

VP of Engineering,

Skimmer

Get all four signals with one SDK

We support every technology (except the ones we don't).
Get started with just a few lines of code.

Signup and install Sentry with just one line of code:

npx @sentry/wizard@latest -i nextjs

Grab the Sentry JavaScript SDK:

<script src="https://browser.sentry-cdn.com/<VERSION>/bundle.min.js"></script>

Configure your DSN:

Sentry.init({ dsn: 'https://<key>@sentry.io/<project>',
  // This enables automatic instrumentation (highly recommended),
  // but is not necessary for purely manual usage
  // If you only want to use custom instrumentation:
  // * Remove the BrowserTracing integration
  // * add Sentry.addTracingExtensions() above your Sentry.init() call
  integrations: [Sentry.browserTracingIntegration()],

  // We recommend adjusting this value in production, or using tracesSampler
  // for finer control
  tracesSampleRate: 1.0,

  // Set tracePropagationTargets to control for which URLs distributed tracing should be enabled
  tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
});

Grab the Sentry React SDK:

npm install @sentry/react

Configure your DSN:

import React from "react";
import ReactDOM from "react-dom";
import * as Sentry from "@sentry/react";
import App from "./App";

Sentry.init({
  dsn: "https://<key>@sentry.io/<project>",
  // This enables automatic instrumentation (highly recommended)
  // If you only want to use custom instrumentation:
  // * Remove the BrowserTracing integration
  // * add Sentry.addTracingExtensions() above your Sentry.init() call
  integrations: [
    Sentry.browserTracingIntegration(),
    // Or, if you are using react router, use the appropriate integration
    // See docs for support for different versions of react router
    // https://docs.sentry.io/platforms/javascript/guides/react/configuration/integrations/react-router/
    Sentry.reactRouterV6BrowserTracingIntegration({
      useEffect: React.useEffect,
      useLocation,
      useNavigationType,
      createRoutesFromChildren,
      matchRoutes,
    }),
  ],

  // For finer control of sent transactions you can adjust this value, or
  // use tracesSampler
  tracesSampleRate: 1.0,

  // Set tracePropagationTargets to control for which URLs distributed tracing should be enabled
  tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
});

ReactDOM.render(<App />, document.getElementById("root"));

Grab the Sentry Python SDK:

pip install --upgrade sentry-sdk

Configure your DSN:

import sentry_sdk

sentry_sdk.init(
    "https://<key>@sentry.io/<project>",

    # Set traces_sample_rate to 1.0 to capture 100%
    # of transactions for Tracing.
    # We recommend adjusting this value in production.
    traces_sample_rate=1.0,
)

Grab the Sentry Node SDK:

npm install @sentry/node

Configure your SDK:

const Sentry = require('@sentry/node');
Sentry.init({ dsn: 'https://<key>@sentry.io/<project>' });

Add the sentry-ruby gem to your Gemfile:

gem "sentry-ruby"

Configure your DSN:

Sentry.init do |config|
  config.dsn = 'https://<key>@sentry.io/<project>'

  # Set a uniform sample rate between 0.0 and 1.0
  # We recommend adjusting the value in production:
  config.traces_sample_rate = 1.0

  # or control sampling dynamically
  config.traces_sampler = lambda do |sampling_context|
    # sampling_context[:transaction_context] contains the information about the transaction
    # sampling_context[:parent_sampled] contains the transaction's parent's sample decision
    true # return value can be a boolean or a float between 0.0 and 1.0
  end
end

Grab the Sentry Go SDK:

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

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

package main

import (
	"log"
	"time"

	"github.com/getsentry/sentry-go"
)

func main() {
	err := sentry.Init(sentry.ClientOptions{
		Dsn: "https://<key>@sentry.io/<project>",
		EnableTracing: true,
		// Specify a fixed sample rate:
		// We recommend adjusting this value in production
		TracesSampleRate: 1.0,
		// Or provide a custom sample rate:
		TracesSampler: sentry.TracesSampler(func(ctx sentry.SamplingContext) float64 {
			// As an example, this does not send some
			// transactions to Sentry based on their name.
			if ctx.Span.Name == "GET /health" {
				return 0.0
			}

			return 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)
}

Install the sentry/sentry package with Composer:

composer require sentry/sentry

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

\Sentry\init(['dsn' => 'https://<key>@sentry.io/<project>',
    // Specify a fixed sample rate:
    'traces_sample_rate' => 0.2,
    // Or provide a custom sampler:
    'traces_sampler' => function (\Sentry\Tracing\SamplingContext $context): float {
        // return a number between 0 and 1
    }, ]);

Install the sentry/sentry-laravel package with Composer:

composer require sentry/sentry-laravel

Add Sentry reporting to bootstrap/app.php:

<?php

use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use Sentry\Laravel\Integration;

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        commands: __DIR__.'/../routes/console.php',
        health: '/up',
    )
    ->withMiddleware(function (Middleware $middleware) {
        //
    })
    ->withExceptions(function (Exceptions $exceptions) {
        Integration::handles($exceptions);
    })->create();

Enable Sentry Tracing in config/sentry.php:

// Specify a fixed sample rate:
'traces_sample_rate' => 0.2,
// Or provide a custom sampler:
'traces_sampler' => function (\Sentry\Tracing\SamplingContext $context): float {
    // return a number between 0 and 1
},

Run this Artisan command to configure the Sentry DSN:

php artisan sentry:publish --dsn=<paste-your-DSN-here>

Install the NuGet package to add the Sentry dependency:

dotnet add package Sentry

Initialize the SDK as early as possible, like in the Main method in Program.cs/Program.fs:

using (SentrySdk.Init(o => {
  // Tells which project in Sentry to send events to:
  o.Dsn = "https://<key>@sentry.io/<project>";
  // When configuring for the first time, to see what the SDK is doing:
  o.Debug = true;
  // Set TracesSampleRate to 1.0 to capture 100% of transactions for Tracing.
  // We recommend adjusting this value in production.
  o.TracesSampleRate = 1.0; }))
{
  // App code goes here - Disposing will flush events out
}

Just run this command to sign up for and install Sentry.

brew install getsentry/tools/sentry-wizard && sentry-wizard -i android

To integrate Sentry into your Xcode project, specify it in your Podfile, then run pod install:

platform :ios, '9.0'
use_frameworks! # This is important

target 'YourApp' do
  pod 'Sentry', :git => 'https://github.com/getsentry/sentry-cocoa.git', :tag => '<VERSION>'
end

Initialize the SDK as soon as possible in your application lifecycle, such as in your AppDelegate application:didFinishLaunchingWithOptions method:

import Sentry // Make sure you import Sentry

func application(_ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {

    SentrySDK.start { options in
        options.dsn = "https://<key>@sentry.io/<project>"
        options.debug = true // Enabled debug when first installing is always helpful
        // Example uniform sample rate: capture 100% of transactions for Tracing
        options.tracesSampleRate = 1.0
    }

    return true
}

Grab the Sentry Vue SDK:

npm install @sentry/vue

Configure your DSN:

import { createApp } from "vue";
import * as Sentry from "@sentry/vue";

const app = createApp({
  // ...
});

Sentry.init({
  app,
  dsn: "https://<key>@sentry.io/<project>",
  // This enables automatic instrumentation (highly recommended),
  // but is not necessary for purely manual usage
  // If you only want to use custom instrumentation:
  // * Remove the BrowserTracing integration
  // * add Sentry.addTracingExtensions() above your Sentry.init() call
  integrations: [Sentry.browserTracingIntegration()],

  // We recommend adjusting this value in production, or using tracesSampler
  // for finer control
  tracesSampleRate: 1.0,
  // Set tracePropagationTargets to control for which URLs distributed tracing should be enabled
  tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
});

app.mount("#app");

Install with one line of code:

npx @sentry/wizard@latest -i angular

Grab the Sentry Java SDK:

<dependency>
  <groupId>io.sentry</groupId>
  <artifactId>sentry-spring-boot-starter</artifactId>
  <version><VERSION></version>
</dependency>

Configure your DSN in application.properties:

sentry.dsn=https://<key>@sentry.io/<project>
# Set traces_sample_rate to 1.0 to capture 100%
# of transactions for performance monitoring.
# We recommend adjusting this value in production.
sentry.traces-sample-rate=1.0

Add the Sentry dependency:

dotnet add package Sentry.AspNetCore

Configure Sentry in appsettings.json.

"Sentry": {
  "Dsn": "https://examplePublicKey@o0.ingest.sentry.io/0",
  "Debug": true,
},

Then add the SDK by simply calling UseSentry:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            // Add the following line:
            webBuilder.UseSentry();
        });

To use the SDK, initialize Sentry in your Svelte entry point main.js before you bootstrap your Svelte app:

// main.js / main.ts

import App from "./App.svelte";

import * as Sentry from "@sentry/svelte";

// Initialize the Sentry SDK here
Sentry.init({
  dsn: "__DSN__",
  release: "my-project-name@2.3.12",

  integrations: [Sentry.browserTracingIntegration()],

  // We recommend adjusting this value in production
  tracesSampleRate: 1.0,

  // Set tracePropagationTargets to control for which URLs distributed tracing should be enabled
  tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
});

// Then bootstrap your Svelte app
const app = new App({
  target: document.getElementById("app"),
});

export default app;

To use the SDK, initialize Sentry in your Solid entry point index.jsx before you render your Solid app:

// index.jsx / index.tsx

import * as Sentry from "@sentry/solid";
import { useBeforeLeave, useLocation } from "@solidjs/router";
import { render } from "solid-js/web";
import App from "./app";

// Initialize the Sentry SDK here
Sentry.init({
  dsn: "__DSN__",
  integrations: [Sentry.browserTracingIntegration()],

  // Performance Monitoring
  tracesSampleRate: 1.0, //  Capture 100% of the transactions
  // Set 'tracePropagationTargets' to control for which URLs trace propagation should be enabled
  tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],
});

const app = document.getElementById("app");

if (!app) throw new Error("No #app element found in the DOM.");

render(() => <App />, app)

Just run this command to install and register Sentry's Astro integration.

npx astro add @sentry/astro

And add your DSN and project config to your astro.config.mjs file:

import { defineConfig } from "astro/config";
import sentry from "@sentry/astro";

export default defineConfig({
  integrations: [
    sentry({
      dsn: "__DSN__",
      sourceMapsUploadOptions: {
        project: "your-project-slug",
        authToken: process.env.SENTRY_AUTH_TOKEN,
      },
      tracesSampleRate: 1.0,
    }),
  ],
});

FAQs

How is this different from product analytics tools?

Product analytics tools are built for marketers and PMs tracking funnels and feature adoption. Sentry is built for developers tracking what actually breaks in production. Sentry's metrics are high-cardinality and trace-connected, so when a graph spikes you can click straight into the request, span, and line of code that caused it. Errors come with stack traces and the commit that introduced the regression. Replays connect to the errors they belong to. It's all aimed at one outcome: get devs from "something broke" to "here's the fix."

Do I get help finding the fix?

What does "trace-connected" actually mean?

Every metric, log, and replay in Sentry is automatically tagged with trace_id and span_id. That means a spike on a metric chart is one click away from the trace that produced it. The log lines from a failed request are one click away from the error. The session replay of a broken checkout is attached to the error you're debugging. No correlating timestamps across tools. No copying IDs between browser tabs.

How much does it cost?

How do I get started?

Ship faster. Fix faster.

Get metrics, errors, logs, and replays connected to the line of code that broke. And when you're stuck, Seer (our AI debugger) walks you to the fix.

Try Sentry For Free

Talk to Sales