Integração com Sentry

Conecte o Devin ao Sentry para triagem e remediação automatizadas de erros

Visão geral

O Sentry é uma integração MCP oficial disponível no MCP Marketplace. Ela usa autenticação OAuth, concedendo ao Devin acesso aos seus projetos no Sentry para consultar detalhes de problemas, stack traces, breadcrumbs de eventos e muito mais.

Depois de conectado, você pode configurar a triagem automatizada de erros por meio de webhooks ou agendar sessões recorrentes de remediação que processam erros do Sentry em lote.

Ative o MCP do Sentry

1. Abra o MCP Marketplace

   Acesse Configurações > MCP Marketplace e encontre Sentry.

2. Conclua o fluxo de OAuth

   Clique em Ativar e autentique-se com a conta do Sentry que tem acesso aos seus projetos. Isso concede ao Devin acesso de leitura aos seus problemas, eventos e stack traces no Sentry.

3. Verifique a conexão

   Teste a conexão iniciando uma sessão e pedindo ao Devin para listar problemas recentes em um dos seus projetos. Você também pode clicar em Test listing tools no MCP Marketplace para confirmar a conectividade.

Capacidades

Depois que o Sentry MCP estiver ativado, o Devin poderá executar as seguintes ações em qualquer sessão:

Capacidade	Descrição
Consultar detalhes do problema	Ver metadados do problema, status, responsável e contagem de eventos
Obter stack traces completos	Acessar stack traces completos de qualquer evento
Ler breadcrumbs dos eventos	Ver ações do usuário e eventos do sistema que antecederam um erro
Inspecionar tags de release	Verificar qual release introduziu ou resolveu um problema
Atualizar o status do problema	Marcar problemas como resolvidos, ignorados ou atribuí-los a membros da equipe
Gerenciar atribuições e tags	Atualizar atribuições, tags e favoritos do problema
Configurar alertas	Ver e gerenciar regras de alerta e configurações de notificação

Pipeline de triagem automática (via webhook)

Você pode conectar alertas do Sentry diretamente ao Devin para que novos erros de produção sejam triados automaticamente. Isso usa uma Internal Integration do Sentry para enviar webhooks a um serviço intermediário que chama a API do Devin.

1. Criar uma Internal Integration do Sentry

   No painel do Sentry, acesse Settings > Developer Settings > Custom Integrations e clique em Create New Integration > Internal Integration.

   Configure-a:

   • Name: Devin Auto-Triage
   • Webhook URL: O endpoint do seu serviço intermediário (por exemplo, https://your-domain.com/sentry-webhook)
   • Alert Rule Action: Ative a opção (on) — isso torna a integração disponível como uma ação nas regras de alerta
   • Permissions: Acesso de leitura a Issue & Event e Project
2. Criar uma regra de alerta

   Acesse Alerts > Create Alert Rule > Issue Alert para o seu projeto:

   • When: Uma nova issue é criada
   • If: A issue tem mais de 50 eventos em 1 hora (ajuste conforme seu volume de tráfego)
   • Then: Enviar uma notificação via Devin Auto-Triage
3. Implantar um handler de webhook

   Crie um pequeno handler que receba o payload de alerta do Sentry e inicie uma sessão do Devin. Crie um usuário de serviço em Settings > Service Users com a permissão ManageOrgSessions (adicione ViewOrgSessions também se quiser listar ou filtrar sessões pela API). Armazene o token da API como DEVIN_API_KEY, o ID da sua organização como DEVIN_ORG_ID e o Client Secret da sua Internal Integration do Sentry como SENTRY_CLIENT_SECRET nas variáveis de ambiente do handler.

   const express = require('express');
   const crypto = require('crypto');
   const app = express();
   app.use(express.json({
     verify: (req, _res, buf) => { req.rawBody = buf; },
   }));
   
   function verifySignature(req) {
     const signature = req.headers['sentry-hook-signature'];
     if (!signature) return false;
     const expected = crypto
       .createHmac('sha256', process.env.SENTRY_CLIENT_SECRET)
       .update(req.rawBody)
       .digest('hex');
     if (signature.length !== expected.length) return false;
     return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
   }
   
   app.post('/sentry-webhook', async (req, res) => {
     if (!verifySignature(req)) return res.status(401).send('Bad signature');
   
     const event = req.body.data?.event;
     if (!event) return res.sendStatus(200);
   
     const orgId = process.env.DEVIN_ORG_ID;
     const response = await fetch(
       `https://api.devin.ai/v3/organizations/${orgId}/sessions`, {
       method: 'POST',
       headers: {
         'Authorization': `Bearer ${process.env.DEVIN_API_KEY}`,
         'Content-Type': 'application/json',
       },
       body: JSON.stringify({
         prompt: [
           `A Sentry alert fired for a new issue: "${event.title}"`,
           `Culprit: ${event.culprit}`,
           `Sentry URL: ${event.web_url}`,
           ``,
           `Use the Sentry MCP to pull the full stack trace and breadcrumbs.`,
           `Identify the root cause, fix the issue, and open a PR with a`,
           `regression test.`,
         ].join('\n'),
         tags: ['sentry-auto-triage', `project:${event.project}`],
       }),
     });
   
     const { session_id } = await response.json();
     console.log(`Started Devin session ${session_id} for: ${event.title}`);
     res.sendStatus(200);
   });
   
   app.listen(3000);
   

   Implante isso em qualquer lugar que possa receber tráfego HTTPS — um Cloudflare Worker, AWS Lambda ou uma VPS pequena. Aponte a URL de webhook da sua Internal Integration do Sentry para esse handler.

4. Testar o pipeline

   Acione um alerta de teste no Sentry (ou reduza temporariamente o limite) e depois verifique em app.devin.ai se há uma nova sessão com a tag sentry-auto-triage.

O código acima adiciona a tag sentry-auto-triage e o nome do projeto do Sentry a cada sessão. Isso permite filtrar essas sessões no painel do Devin e buscá-las pela API usando o parâmetro de consulta tags. Para listar sessões, é necessária a permissão ViewOrgSessions no seu usuário de serviço — consulte a visão geral da API para ver a tabela completa de permissões.

Remediação em lote agendada

Em vez de reagir a alertas individuais, você pode agendar uma sessão recorrente do Devin que busca erros não resolvidos do Sentry em lote e inicia sessões de correção para cada um deles.

1. Criar um agendamento

   Vá para Configurações > Schedules e clique em Create schedule.

   • Nome: Daily Sentry remediation
   • Frequência: Diariamente às 6h00 (para que os PRs de correção estejam prontos antes da standup)
   • Agent: Devin — isso permite que o Devin inicie uma sessão separada para cada erro, para que as correções sejam executadas em paralelo
   • Prompt:

   Use o Sentry MCP para buscar todos os erros não resolvidos das últimas
   24 horas no projeto payments-api, ordenados pela contagem de eventos.
   Pule erros marcados com `wontfix` ou `expected-behavior`.
   
   Para os 5 principais erros:
   1. Busque o stack trace completo e os breadcrumbs
   2. Encontre os arquivos-fonte relevantes no nosso repositório
   3. Identifique a causa raiz
   4. Inicie uma sessão do Devin para abrir um PR com uma correção e um teste
      de regressão, vinculando a URL do issue do Sentry na descrição do PR
   
   Publique um resumo de todos os erros e seus PRs no Slack.
   
2. Revisar e iterar

   Após uma semana de execuções, ajuste o escopo:

   • Aumente ou diminua a contagem de erros com base em quantas correções podem ser mescladas
   • Filtre por projeto ou tag para focar em áreas específicas da sua base de código
   • Adicione Knowledge sobre suas convenções de tratamento de erros para que as correções do Devin sigam os padrões da sua equipe

Combine a triagem orientada por webhook para erros de alto impacto (50+ eventos/hora) com a remediação em lote agendada para a cauda longa de issues menos frequentes. Isso garante que tanto os erros urgentes quanto os recorrentes sejam tratados.

Recursos relacionados

• Guia completo: triagem automática de erros do Sentry
• Guia completo: correções diárias de erros do Sentry
• Documentação do MCP Marketplace
• Referência da API do Devin