Monitoramento de erros

Obtenha insights práticos para resolver os problemas de código mais importantes. Rastreie, depure e resolva erros em qualquer linguagem ou framework com contexto personalizado para chegar à causa raiz sempre.

A escolha de 4 milhões de desenvolvedores.

Contexto a nível de código

Pare de perder tempo tentando reproduzir erros. Saiba a linha exata, as ações do usuário e as funções que causaram o erro para debugar e resolver o problema rápido.

Ver documentação

Automatize a triagem de problemas

Saiba quando seu código falha e quem pode ajudar a corrigi-lo. Atribua problemas automaticamente a quem criou o código e notifique o time no Slack assim que um erro aparecer, se repetir ou piorar.

Confira a documentação

Garanta a qualidade e estabilidade dos deploys

Tenha visibilidade imediata dos seus releases com métricas de sessões sem crash, adoção de versão e taxas de falha. Saiba na hora se a estabilidade caiu para fazer o rollback rápido... se precisar.

Ver documentação

Começar com o Sentry é simples

Suportamos todas as tecnologias (exceto as que não suportamos). Comece com apenas algumas linhas de código.

Cadastre-se e instale o Sentry com apenas uma linha de código:

npx @sentry/wizard@latest -i nextjs

Obtenha o SDK do Sentry para Go:

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

A configuração deve ser feita o mais cedo possível no ciclo de vida da sua aplicação:

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,
		TracesSampleRate: 1.0,
		TracesSampler: sentry.TracesSampler(func(ctx sentry.SamplingContext) float64 {
			if ctx.Span.Name == "GET /health" {
				return 0.0
			}
			return 1.0
		}),
	})
	if err != nil {
		log.Fatalf("sentry.Init: %s", err)
	}
	defer sentry.Flush(2 * time.Second)
}

Cadastre-se e instale o Sentry com apenas uma linha de código:

npx @sentry/wizard@latest -i angular

Adicione a dependência do Sentry:

dotnet add package Sentry.AspNetCore

Configure o Sentry em appsettings.json:

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

Depois adicione o SDK simplesmente chamando UseSentry:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            // Adicione a seguinte linha:
            webBuilder.UseSentry();
        });

Execute este comando para instalar e registrar a integração do Sentry com o Astro:

npx astro add @sentry/astro

E adicione seu DSN e a configuração do projeto ao arquivo astro.config.mjs:

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

Instale o pacote NuGet para adicionar a dependência do Sentry:

dotnet add package Sentry

Inicialize o SDK o mais cedo possível, como no método Main em Program.cs/Program.fs:

using (SentrySdk.Init(o => {
  o.Dsn = "https://<key>@sentry.io/<project>";
  o.Debug = true;
  o.TracesSampleRate = 1.0; }))
{
  // O código da aplicação vai aqui - o Dispose vai liberar os eventos
}

Obtenha o SDK do Sentry para JavaScript:

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

Configure seu DSN:

Sentry.init({ dsn: 'https://<key>@sentry.io/<project>',
  integrations: [Sentry.browserTracingIntegration()],
  tracesSampleRate: 1.0,
  tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
});

Instale o pacote sentry/sentry-laravel com o Composer:

composer require sentry/sentry-laravel

Adicione os relatórios do Sentry em 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();

Ative o Sentry Tracing em config/sentry.php:

'traces_sample_rate' => 0.2,
'traces_sampler' => function (\Sentry\Tracing\SamplingContext $context): float {
    // retorne um número entre 0 e 1
},

Execute este comando Artisan para configurar o DSN do Sentry:

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

Instale o pacote sentry/sentry com o Composer:

composer require sentry/sentry

Para capturar todos os erros, incluindo os da inicialização da sua aplicação, você deve inicializar o SDK do Sentry para PHP o mais cedo possível:

\Sentry\init(['dsn' => 'https://<key>@sentry.io/<project>',
    'traces_sample_rate' => 0.2,
    'traces_sampler' => function (\Sentry\Tracing\SamplingContext $context): float {
        // retorne um número entre 0 e 1
    }, ]);

Obtenha o SDK do Sentry para Python:

pip install --upgrade sentry-sdk

Configure seu DSN:

import sentry_sdk

sentry_sdk.init(
    "https://<key>@sentry.io/<project>",
    enable_tracing=True,
    traces_sample_rate=1.0,
)

Obtenha o SDK do Sentry para React:

npm install @sentry/react

Configure seu 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>",
  integrations: [
    Sentry.browserTracingIntegration(),
    Sentry.reactRouterV6BrowserTracingIntegration({
      useEffect: React.useEffect,
      useLocation,
      useNavigationType,
      createRoutesFromChildren,
      matchRoutes,
    }),
  ],
  tracesSampleRate: 1.0,
  tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
});

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

Adicione a gem sentry-ruby ao seu Gemfile:

gem "sentry-ruby"

Configure seu DSN:

Sentry.init do |config|
  config.dsn = 'https://<key>@sentry.io/<project>'
  config.traces_sample_rate = 1.0
  config.traces_sampler = lambda do |sampling_context|
    true
  end
end

Para usar o SDK, inicialize o Sentry no seu ponto de entrada Solid index.jsx antes de renderizar sua aplicação Solid:

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

Sentry.init({
  dsn: "__DSN__",
  integrations: [Sentry.browserTracingIntegration()],
  tracesSampleRate: 1.0,
  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)

Obtenha o SDK do Sentry para Java:

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

Configure seu DSN em application.properties:

sentry.dsn=https://<key>@sentry.io/<project>
sentry.traces-sample-rate=1.0

Para usar o SDK, inicialize o Sentry no seu ponto de entrada Svelte main.js antes de iniciar sua aplicação Svelte:

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

Sentry.init({
  dsn: "__DSN__",
  release: "my-project-name@2.3.12",
  integrations: [Sentry.browserTracingIntegration()],
  tracesSampleRate: 1.0,
  tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
});

const app = new App({
  target: document.getElementById("app"),
});

export default app;

Para integrar o Sentry no seu projeto Xcode, especifique-o no seu Podfile e depois execute pod install:

platform :ios, '9.0'
use_frameworks!

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

Inicialize o SDK o mais cedo possível no ciclo de vida da sua aplicação:

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
        options.tracesSampleRate = 1.0
    }
    return true
}

Obtenha o SDK do Sentry para Vue:

npm install @sentry/vue

Configure seu DSN:

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

const app = createApp({});

Sentry.init({
  app,
  dsn: "https://<key>@sentry.io/<project>",
  integrations: [Sentry.browserTracingIntegration()],
  tracesSampleRate: 1.0,
  tracePropagationTargets: ['localhost', /^https:\/\/yourserver\.io\/api/],
});

app.mount("#app");

Cadastre-se e instale o Sentry com apenas uma linha de código:

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

O mais louco é que eu provavelmente ficaria meses com esse bug sem nem saber que ele existia.

Estou percebendo que o Sentry melhora muito a UX, porque você resolve vários daqueles "probleminhas chatos" que nem sabia que tinha.

Dan Mindru

@d4m1n,

Finalmente arrumei a integração do @getsentry no meu site pessoal e, caramba, por que demorei tanto? Esse negócio é incrível.

Kent C. Dodds

@kentcdodds,

Uso o Sentry todos os dias agora e finalmente posso usar o que construímos juntos. O Sentry se tornou uma ferramenta crítica para organizar e corrigir apps críticos de negócios lá onde você sabe!

Maciej Walkowiak

@maciejwalkowiak,

Entenda o quem, o quê e o porquê por trás do código quebrado

Obtenha o contexto técnico necessário para focar no que realmente importa

Comece grátis

Agende uma demo