Error monitoring

Get actionable insights to resolve the most important code-related issues. Track, debug, and resolve errors across any language or framework with tailored context to get to the root cause every time.

Tolerated by 4 million developers.

Code-level context when something goes wrong

Don’t waste cycles reproducing errors. Trace errors across your entire stack and act fast with all the context you need to fix the root cause – like the line of code, user actions and functions leading up to when it occurred.

NAVIGATE ISSUE DETAILS

Automate issue triaging

Know when your code fails and who can help fix it. Configure ownership rule to auto-assign issues to the developer that introduced the broken code and notify your team when the error happens the first time, reoccurs, or worsens.

SET UP OWNERSHIP RULES

Ensure release quality and stability

Get immediate visibility across releases with insights into core metrics like crash-free sessions, failure rates, and version adoption. Know when a release starts to degrade so you can revert quickly…if you have to.

SET UP RELEASES

Getting started with Sentry is simple

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:

Copied!Click to Copy

npx @sentry/wizard@latest -i nextjs

Grab the Sentry JavaScript SDK:

Copied!Click to Copy

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

Configure your DSN:

Copied!Click to Copy

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:

Copied!Click to Copy

npm install @sentry/react

Configure your DSN:

Copied!Click to Copy

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:

Copied!Click to Copy

pip install --upgrade sentry-sdk

Configure your DSN:

Copied!Click to Copy

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.
    enable_tracing=True,
    traces_sample_rate=1.0,
)

Grab the Sentry Node SDK:

Copied!Click to Copy

npm install @sentry/node

Configure your SDK:

Copied!Click to Copy

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

Add the sentry-ruby gem to your Gemfile:

Copied!Click to Copy

gem "sentry-ruby"

Configure your DSN:

Copied!Click to Copy

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:

Copied!Click to Copy

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

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

Copied!Click to Copy

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:

Copied!Click to Copy

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.

Copied!Click to Copy

\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:

Copied!Click to Copy

composer require sentry/sentry-laravel

Add Sentry reporting to bootstrap/app.php:

Copied!Click to Copy

<?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:

Copied!Click to Copy

// 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:

Copied!Click to Copy

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

Install the NuGet package to add the Sentry dependency:

Copied!Click to Copy

dotnet add package Sentry

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

Copied!Click to Copy

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.

Copied!Click to Copy

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:

Copied!Click to Copy

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:

Copied!Click to Copy

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:

Copied!Click to Copy

npm install @sentry/vue

Configure your DSN:

Copied!Click to Copy

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:

Copied!Click to Copy

npx @sentry/wizard@latest -i angular

Grab the Sentry Java SDK:

Copied!Click to Copy

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

Configure your DSN in application.properties:

Copied!Click to Copy

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:

Copied!Click to Copy

dotnet add package Sentry.AspNetCore

Configure Sentry in appsettings.json.

Copied!Click to Copy

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

Then add the SDK by simply calling UseSentry:

Copied!Click to Copy

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:

Copied!Click to Copy

// 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:

Copied!Click to Copy

// 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.

Copied!Click to Copy

npx astro add @sentry/astro

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

Copied!Click to Copy

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,
    }),
  ],
});

The amount of detail you get in a @sentry issue is NUTSSSS

- browser info
- reference to specific line of code
- specific error with tracing (through to backend)

This doesn't even cover session replays!

James Q Quick

@jamesqquick,

The craziest part about this is I would have likely had this bug for months and would have never known about it.

I'm beginning to realize that having Sentry ultimately results in better UX because you fix so many of these papercuts you didn't know you have.

Dan Mindru

@d4m1n,

I've finally fixed my integration with @sentry on my personal site and gosh why did I wait so long to do that? This thing's incredible.

Kent C. Dodds

@kentcdodds,

Know the who, what, why behind broken code

Get the code-level context you need to fix issues that matter most

Get Started Free

Get A Demo