Skip to main content

​
Panoramica

Sentry è un’integrazione MCP ufficiale disponibile nel MCP Marketplace. Utilizza l’autenticazione OAuth, consentendo a Devin di accedere ai tuoi progetti Sentry per recuperare i dettagli dei problemi, gli stack trace, i breadcrumb degli eventi e altro ancora. Una volta collegato, puoi configurare il triage automatico degli errori tramite webhook oppure pianificare sessioni ricorrenti di risoluzione che elaborano in batch gli errori di Sentry.

​
Abilita l’MCP di Sentry

1

Apri il MCP Marketplace

Vai a Settings > MCP Marketplace e trova Sentry.
2

Completa il flusso OAuth

Fai clic su Enable e autenticati con l’account Sentry che ha accesso ai tuoi progetti. In questo modo, Devin ottiene l’accesso in sola lettura ai problemi, agli eventi e agli stack trace di Sentry.
3

Verifica la connessione

Verifica la connessione avviando una sessione e chiedendo a Devin di elencare i problemi recenti in uno dei tuoi progetti. Puoi anche fare clic su Test listing tools nel MCP Marketplace per confermare la connettività.

​
Funzionalità

Una volta abilitato l’MCP di Sentry, Devin può eseguire le seguenti azioni in qualsiasi sessione:
FunzionalitàDescrizione
Recuperare i dettagli del problemaVisualizzare i metadati del problema, lo stato, l’assegnazione e il numero di eventi
Ottenere stack trace completiAccedere agli stack trace completi per qualsiasi evento
Leggere i breadcrumb degli eventiVisualizzare le azioni dell’utente e gli eventi di sistema che precedono un errore
Ispezionare i tag di releaseVerificare quale release ha introdotto o risolto un problema
Aggiornare lo stato del problemaContrassegnare i problemi come risolti, ignorati o assegnarli ai membri del team
Gestire assegnazioni e tagAggiornare le assegnazioni dei problemi, i tag e i segnalibri
Configurare gli avvisiVisualizzare e gestire le regole di avviso e le impostazioni di notifica

​
Pipeline di auto-triage (basata su webhook)

Puoi collegare direttamente gli avvisi di Sentry a Devin, in modo che i nuovi errori di produzione vengano sottoposti automaticamente a triage. Questa configurazione usa una Sentry Internal Integration per inviare webhook a un servizio bridge che chiama la Devin API.
1

Crea una Sentry Internal Integration

Nella dashboard di Sentry, vai a Settings > Developer Settings > Custom Integrations e fai clic su Create New Integration > Internal Integration.Configúrala:
  • Name: Devin Auto-Triage
  • Webhook URL: L’endpoint del tuo servizio bridge (ad esempio https://your-domain.com/sentry-webhook)
  • Alert Rule Action: Attiva on — in questo modo l’integrazione sarà disponibile come azione nelle regole di avviso
  • Permissions: Accesso in lettura a Issue & Event e Project
2

Crea una regola di avviso

Vai a Alerts > Create Alert Rule > Issue Alert per il tuo progetto:
  • When: Viene creato un nuovo issue
  • If: L’issue ha più di 50 eventi in 1 ora (adatta la soglia al tuo traffico)
  • Then: Invia una notifica tramite Devin Auto-Triage
3

Distribuisci un gestore di webhook

Crea un piccolo gestore che riceva il payload di avviso di Sentry e avvii una session di Devin. Crea un utente di servizio in Settings > Service Users con l’autorizzazione ManageOrgSessions (aggiungi anche ViewOrgSessions se vuoi elencare o filtrare le session tramite API). Salva il token API come DEVIN_API_KEY, l’ID della tua organizzazione come DEVIN_ORG_ID e il Client Secret della tua Sentry Internal Integration come SENTRY_CLIENT_SECRET nell’ambiente del gestore.
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);
Distribuiscilo ovunque possa ricevere traffico HTTPS — ad esempio su Cloudflare Workers, AWS Lambda o una piccola VPS. Quindi imposta il webhook URL della tua Sentry Internal Integration in modo che punti a questo endpoint.
4

Testa la pipeline

Attiva un avviso di test in Sentry (oppure abbassa temporaneamente la soglia), quindi controlla app.devin.ai per verificare che sia stata creata una nuova session con il tag sentry-auto-triage.
Il codice sopra aggiunge a ogni session il tag sentry-auto-triage e il nome del progetto Sentry. Questo ti consente di filtrare queste session nella dashboard di Devin e di recuperarle tramite API usando il parametro di query tags. Per elencare le session è necessaria l’autorizzazione ViewOrgSessions per il tuo utente di servizio — consulta la panoramica API per la tabella completa delle autorizzazioni.

​
Correzione batch pianificata

Invece di reagire ai singoli avvisi, puoi pianificare una sessione ricorrente di Devin che recupera in batch gli errori Sentry non risolti e avvia una sessione di correzione per ciascuno.
1

Crea una pianificazione

Vai su Settings > Schedules e fai clic su Create schedule.
  • Nome: Remediation Sentry giornaliera
  • Frequenza: Tutti i giorni alle 6:00 (così le PR di correzione sono pronte prima dello standup)
  • Agent: Devin — questo consente a Devin di avviare una sessione separata per ogni errore, così le correzioni vengono eseguite in parallelo
  • Prompt:
Usa Sentry MCP per recuperare tutti gli errori non risolti delle ultime
24 ore nel progetto payments-api, ordinati per numero di eventi.
Ignora gli errori con tag `wontfix` o `expected-behavior`.

Per i primi 5 errori:
1. Recupera la stack trace completa e i breadcrumb
2. Trova i file sorgente pertinenti nella nostra repo
3. Identifica la causa principale
4. Avvia una sessione Devin per aprire una PR con una correzione e un test
   di regressione, collegando l'URL del problema Sentry nella descrizione della PR

Pubblica su Slack un riepilogo di tutti gli errori e delle relative PR.
2

Rivedi e itera

Dopo una settimana di run, regola l’ambito:
  • Aumenta o riduci il numero di errori in base a quante correzioni possono essere unite
  • Filtra per progetto o tag per concentrarti su aree specifiche della tua codebase
  • Aggiungi Knowledge sulle tue convenzioni di gestione degli errori, così le correzioni di Devin si allineano ai pattern del tuo team
Combina il triage basato su webhook per gli errori ad alto impatto (50+ eventi/ora) con la correzione batch pianificata per i problemi meno frequenti. In questo modo vengono affrontati sia gli errori urgenti sia quelli ricorrenti.