Skip to main content

Descripción general

Sentry es una integración oficial de MCP disponible en el MCP Marketplace. Utiliza autenticación OAuth, lo que le da a Devin acceso a tus proyectos de Sentry para consultar detalles de incidencias, trazas de pila, breadcrumbs de eventos y más. Una vez conectado, puedes configurar el triaje automatizado de errores mediante webhooks o programar sesiones recurrentes de remediación para procesar errores de Sentry por lotes.

Habilita el MCP de Sentry

1

Abre el MCP Marketplace

Ve a Settings > MCP Marketplace y busca Sentry.
2

Completa el flujo de OAuth

Haz clic en Enable y autentícate con la cuenta de Sentry que tenga acceso a tus proyectos. Esto le da a Devin acceso de lectura a tus incidencias, eventos y trazas de pila de Sentry.
3

Verifica la conexión

Prueba la conexión iniciando una sesión y pidiéndole a Devin que liste las incidencias recientes de uno de tus proyectos. También puedes hacer clic en Test listing tools en el MCP Marketplace para confirmar la conexión.

Capacidades

Una vez habilitado Sentry MCP, Devin puede realizar las siguientes acciones en cualquier sesión:
CapacidadDescripción
Consultar detalles de incidenciasVer los metadatos de la incidencia, su estado, la asignación y el recuento de eventos
Obtener trazas de pila completasAcceder a las trazas de pila completas de cualquier evento
Leer breadcrumbs de eventosVer las acciones del usuario y los eventos del sistema que precedieron a un error
Inspeccionar etiquetas de versiónComprobar qué versión introdujo o resolvió una incidencia
Actualizar el estado de las incidenciasMarcar incidencias como resueltas o ignoradas, o asignarlas a miembros del equipo
Gestionar asignaciones y etiquetasActualizar las asignaciones de incidencias, las etiquetas y los marcadores
Configurar alertasVer y gestionar reglas de alerta y la configuración de notificaciones

Pipeline de triaje automático (basado en webhooks)

Puedes conectar las alertas de Sentry directamente a Devin para que los nuevos errores de producción se clasifiquen automáticamente. Esto usa una integración interna de Sentry para enviar webhooks a un servicio puente que llama a la API de Devin.
1

Crear una integración interna de Sentry

En tu panel de Sentry, ve a Settings > Developer Settings > Custom Integrations y haz clic en Create New Integration > Internal Integration.Configúrala:
  • Name: Devin Auto-Triage
  • Webhook URL: El endpoint de tu servicio puente (p. ej., https://your-domain.com/sentry-webhook)
  • Alert Rule Action: Actívala — esto hace que la integración esté disponible como una acción en las reglas de alerta
  • Permissions: Acceso de lectura a Issue & Event y Project
2

Crear una regla de alerta

Ve a Alerts > Create Alert Rule > Issue Alert para tu proyecto:
  • When: Se crea un problema nuevo
  • If: El problema tiene más de 50 eventos en 1 hora (ajústalo según tu tráfico)
  • Then: Enviar una notificación mediante Devin Auto-Triage
3

Implementar un handler de webhook

Compila un pequeño handler que reciba el payload de alerta de Sentry e inicie una sesión de Devin. Crea un usuario de servicio en Settings > Service Users con el permiso ManageOrgSessions (agrega también ViewOrgSessions si quieres listar o filtrar sesiones mediante la API). Almacena el token de la API como DEVIN_API_KEY, el ID de tu organización como DEVIN_ORG_ID y el Client Secret de tu integración interna de Sentry como SENTRY_CLIENT_SECRET en el entorno de tu 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);
Implementa esto en cualquier lugar que pueda recibir tráfico HTTPS: un Cloudflare Worker, AWS Lambda o un VPS pequeño. Haz que la URL de webhook de tu integración interna de Sentry apunte a este servicio.
4

Probar el pipeline

Activa una alerta de prueba en Sentry (o reduce temporalmente tu umbral) y luego revisa app.devin.ai para ver una nueva sesión etiquetada con sentry-auto-triage.
El código anterior etiqueta cada sesión con sentry-auto-triage y el nombre del proyecto de Sentry. Esto te permite filtrar estas sesiones en el panel de Devin y obtenerlas mediante la API usando el parámetro de consulta tags. Para listar sesiones, se requiere el permiso ViewOrgSessions en tu usuario de servicio; consulta la descripción general de la API para ver la tabla completa de permisos.

Remediación por lotes programada

En lugar de reaccionar a alertas individuales, puedes programar una sesión recurrente de Devin que recupere en lote los errores de Sentry sin resolver e inicie sesiones de corrección para cada uno.
1

Crear una programación

Ve a Settings > Schedules y haz clic en Create schedule.
  • Name: Remediación diaria de Sentry
  • Frequency: Todos los días a las 6:00 a. m. (para que las PR de corrección estén listas antes del standup)
  • Agent: Devin — esto permite que Devin inicie una sesión independiente para cada error, de modo que las correcciones se ejecuten en paralelo
  • Prompt:
Usa el MCP de Sentry para recuperar todos los errores sin resolver de las últimas
24 horas en el proyecto payments-api, ordenados por cantidad de eventos.
Omite los errores etiquetados como `wontfix` o `expected-behavior`.

Para los 5 errores principales:
1. Recupera el stack trace completo y los breadcrumbs
2. Encuentra los archivos fuente relevantes en nuestro repo
3. Identifica la causa raíz
4. Inicia una sesión de Devin para abrir una PR con una corrección y una prueba
   de regresión, enlazando la URL del issue de Sentry en la descripción de la PR

Publica un resumen de todos los errores y sus PR en Slack.
2

Revisar e iterar

Después de una semana de ejecuciones, ajusta el ámbito:
  • Aumenta o reduce la cantidad de errores según cuántas correcciones se puedan fusionar
  • Filtra por proyecto o etiqueta para centrarte en áreas específicas de tu base de código
  • Agrega Knowledge sobre tus convenciones de manejo de errores para que las correcciones de Devin se ajusten a los patrones de tu equipo
Combina la clasificación impulsada por webhooks para errores de alto impacto (50+ eventos/hora) con la remediación por lotes programada para la larga cola de problemas de menor frecuencia. Esto garantiza que se aborden tanto los errores urgentes como los recurrentes.