> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Clasificación automática de errores de Sentry

export const UseCaseHero = ({title, description, prompt, category, features, devinUrl, agent, intent, playbookId, type}) => {
  const encodedPrompt = encodeURIComponent(prompt || '');
  const tag = 'docs-use-case-gallery';
  const utm = 'utm_source=docs&utm_medium=use-case-gallery&utm_campaign=hero-cta';
  const agentParams = (agent ? '&agent=' + agent : '') + (intent ? '&intent=' + intent : '') + (playbookId ? '&playbookId=' + playbookId : '');
  const devinHref = type === 'schedule' ? 'https://app.devin.ai/settings/schedules/create?' + utm + agentParams + (prompt ? '&prompt=' + encodedPrompt : '') : type === 'review' ? 'https://app.devin.ai/review?' + utm : agent === 'ada' ? 'https://app.devin.ai/search?' + utm + '&noSubmit=true' + (prompt ? '&prompt=' + encodedPrompt : '') : devinUrl ? devinUrl.includes('?') ? devinUrl + '&' + utm + agentParams : devinUrl + '?' + utm + agentParams : prompt ? 'https://app.devin.ai/?tags=' + tag + '&' + utm + agentParams + '&prompt=' + encodedPrompt : 'https://app.devin.ai/?' + utm + agentParams;
  const buttonLabel = type === 'schedule' ? 'Schedule in Devin ↗' : type === 'review' ? 'Set Up Devin Review ↗' : agent === 'advanced' ? 'Try in Devin ↗' : agent === 'dana' ? 'Try in Dana ↗' : agent === 'ada' ? 'Try in Ask Devin ↗' : 'Try in Devin ↗';
  const featureList = features ? features.split(',').map(f => f.trim()) : [];
  return <div className="uc-hero">
      <div className="uc-hero-inner">
        <div className="uc-hero-left">
          <h1 className="uc-hero-title">{title}</h1>
          <p className="uc-hero-desc">{description}</p>
          <div>
            <a href={devinHref} target="_blank" rel="noopener noreferrer" className="try-in-devin-btn">
              {buttonLabel}
            </a>
          </div>
        </div>
        <div className="uc-hero-meta">
          <div className="uc-meta-item">
            <span className="uc-meta-label">Author</span>
            <span className="uc-meta-value">Cognition</span>
          </div>
          <div className="uc-meta-item">
            <span className="uc-meta-label">Category</span>
            <span className="uc-meta-value">{category}</span>
          </div>
          {featureList.length > 0 && <div className="uc-meta-item">
              <span className="uc-meta-label">Features</span>
              <span className="uc-meta-value">{featureList.join(', ')}</span>
            </div>}
        </div>
      </div>
    </div>;
};

export const PromptBlock = ({children, type, agent, intent, playbookId}) => {
  var utm = 'utm_source=docs&utm_medium=use-case-gallery&utm_campaign=prompt-block';
  var tag = 'docs-use-case-gallery';
  var agentParams = (agent ? '&agent=' + agent : '') + (intent ? '&intent=' + intent : '') + (playbookId ? '&playbookId=' + playbookId : '');
  var label = type === 'schedule' ? 'Schedule in Devin' : type === 'playbook' ? 'Create Playbook' : type === 'knowledge' ? 'Add to Knowledge' : agent === 'advanced' ? 'Try in Devin' : agent === 'dana' ? 'Try in Dana' : agent === 'ada' ? 'Try in Ask Devin' : 'Try in Devin';
  var buildUrl = function (text) {
    var encoded = encodeURIComponent(text);
    if (type === 'schedule') return 'https://app.devin.ai/settings/schedules/create?' + utm + agentParams + '&prompt=' + encoded;
    if (type === 'playbook') return 'https://app.devin.ai/settings/playbooks/create?' + utm + '&body=' + encoded;
    if (type === 'knowledge') return 'https://app.devin.ai/knowledge?' + utm + '&body=' + encoded;
    if (agent === 'ada') return 'https://app.devin.ai/search?' + utm + '&noSubmit=true&prompt=' + encoded;
    return 'https://app.devin.ai/?tags=' + tag + '&' + utm + agentParams + '&prompt=' + encoded;
  };
  const ref = React.useRef(null);
  const [href, setHref] = React.useState('#');
  React.useEffect(() => {
    if (!ref.current) return;
    var codeEl = ref.current.querySelector('pre code');
    if (codeEl) {
      var text = codeEl.textContent.trim();
      if (text) setHref(buildUrl(text));
    }
    var header = ref.current.querySelector('[data-component-part="code-block-header"]');
    if (header && !header.querySelector('.prompt-block-devin-link')) {
      var link = document.createElement('a');
      link.href = href;
      link.target = '_blank';
      link.rel = 'noopener noreferrer';
      link.className = 'prompt-block-devin-link';
      link.style.cssText = 'display:inline-flex;align-items:center;gap:6px;text-decoration:none;color:#fff;font-size:11px;font-weight:500;padding:4px 10px;border-radius:6px;white-space:nowrap;background:#317CFF;transition:background 0.2s;margin-left:8px;';
      link.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/><polyline points="15 3 21 3 21 9"/><line x1="10" y1="14" x2="21" y2="3"/></svg> ' + label;
      link.onmouseenter = function () {
        link.style.background = '#2968D9';
      };
      link.onmouseleave = function () {
        link.style.background = '#317CFF';
      };
      header.appendChild(link);
    }
    var existingLink = ref.current.querySelector('.prompt-block-devin-link');
    if (existingLink && href !== '#') existingLink.href = href;
  });
  return <div className="prompt-block" ref={ref}>{children}</div>;
};

<UseCaseHero title="Clasificación automática de errores de Sentry" description="Conecta los webhooks de Sentry con la API de Devin para clasificar automáticamente cada nuevo error en producción." prompt="Ayúdame a configurar un pipeline de clasificación automática de Sentry a Devin. Sigue la guía en https://docs.devin.ai/use-cases/gallery/api-sentry-auto-triage y acompáñame paso a paso: habilitar el MCP de Sentry, crear la integración interna y desplegar el manejador de webhooks." category="Respuesta a incidentes" features="API, MCP" />

<div className="uc-detail-wrapper">
  <Tip>Para una guía de integración de Sentry más detallada, [haz clic aquí](/es/enterprise/integrations/sentry).</Tip>

  <Steps>
    <Step title="Habilitar MCP de Sentry">
      Devin necesita acceso a tu cuenta de Sentry para poder extraer stack traces, breadcrumbs y metadatos de eventos durante el triaje.

      1. Ve a **Settings > Connections > servidores MCP** y busca **Sentry**
      2. Haz clic en **Enable** y completa el flujo de OAuth con la cuenta de Sentry que tenga acceso a tus proyectos
      3. Prueba la conexión: inicia una sesión y pídele a Devin que liste las incidencias recientes en uno de tus proyectos

      Una vez conectado, Devin puede consultar cualquier proyecto de Sentry al que tenga acceso tu cuenta: detalles de incidencias, stack traces completos, breadcrumbs de eventos, etiquetas de release y más. Consulta la [documentación de MCP Marketplace](/es/work-with-devin/mcp) para obtener detalles de configuración.
    </Step>

    <Step title="Crear una integración interna en Sentry">
      Sentry envía webhooks mediante Internal Integrations. 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:** Un servicio que implementarás en el siguiente paso (por ejemplo, `https://your-domain.com/sentry-webhook`)
      * **Alert Rule Action:** Activa el interruptor en **on** — esto hace que la integración esté disponible como acción en las reglas de alerta
      * **Permissions:** Acceso de solo lectura a **Issue & Event** y **Project**

      Guarda la integración y luego crea una regla de alerta. Ve a **Alerts > Create Alert Rule > Issue Alert** para tu proyecto:

      * **When:** Se crea un nuevo issue
      * **If:** El issue tiene más de **50** eventos en **1 hora** (ajusta según tu tráfico)
      * **Then:** Envía una notificación mediante **Devin Auto-Triage**
    </Step>

    <Step title="Configura el webhook para Devin API">
      Crea un pequeño controlador que reciba el payload de alerta de Sentry y inicie una sesión de Devin. Crea un [usuario de servicio](/es/api-reference/v3/overview) en **Settings > Service Users** con el permiso `ManageOrgSessions` y almacena su token como `DEVIN_API_KEY` en el entorno de tu controlador. Configura `DEVIN_ORG_ID` con el ID de tu organización; puedes obtenerlo llamando a `GET https://api.devin.ai/v3/enterprise/organizations` con tu token.

      ```javascript theme={null}
      const express = require('express');
      const app = express();
      app.use(express.json());

      app.post('/sentry-webhook', async (req, res) => {
        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);
      ```

      Impleméntalo en cualquier lugar que pueda recibir tráfico HTTPS: un Cloudflare Worker, AWS Lambda o un pequeño VPS. Configura la URL de webhook de tu Sentry Internal Integration para que apunte a este servicio.

      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 a través de la API](/es/api-reference/v3/sessions/get-organizations-sessions) usando el parámetro de consulta `tags`, lo que resulta útil para hacer un seguimiento de cuántos errores clasifica Devin por proyecto.

      Para verificar que el pipeline funciona, activa una alerta de prueba en Sentry (o reduce temporalmente tu umbral) y luego revisa [app.devin.ai](https://app.devin.ai/?utm_source=docs\&utm_medium=use-case-gallery) para encontrar una nueva sesión etiquetada como `sentry-auto-triage`.
    </Step>

    <Step title="Qué hace Devin con cada alerta">
      Cuando un nuevo error supera tu umbral y se activa el webhook, Devin inicia una sesión y trabaja en el problema:

      1. **Consulta Sentry vía MCP** — obtiene el stack trace completo, los breadcrumbs (acciones del usuario que llevan al fallo), las etiquetas de navegador/SO/release afectadas y la frecuencia del evento
      2. **Localiza la causa raíz** — lee el archivo fuente en la línea exacta del stack trace y sigue el flujo de datos para entender por qué el valor es `undefined` o `null`
      3. **Escribe una corrección específica** — implementa manejo de errores (encadenamiento opcional, valores predeterminados, validación de datos de entrada) que coincide con los patrones existentes de tu base de código
      4. **Añade una prueba de regresión** — crea un caso de prueba que reproduce el escenario original del fallo y verifica que la corrección lo evita
      5. **Abre un PR** — incluye la URL del issue de Sentry en la descripción del PR para que los revisores puedan cruzar el contexto original del error con el volumen de eventos

      Descripción de PR de ejemplo:

      ```
      Fix: TypeError in UserProfile when user.profile is null

      Root cause: The /api/users/:id endpoint returns { profile: null }
      for users who haven't completed onboarding. UserProfile.tsx:47
      destructures email from user.profile without a null check.

      Fix: Added optional chaining and a fallback state.
      Test: Added test for users with null profile — verifies the
      component renders "Complete your profile" instead of crashing.

      Sentry issue: FRONTEND-1892 (340 events in the past hour)
      ```
    </Step>

    <Step title="Optimiza el triaje con playbooks y Knowledge">
      Una vez que la pipeline esté en ejecución, haz que el auto-triaje sea más inteligente:

      **Crea un playbook de triaje.** Empieza desde el [playbook de plantilla `!triage`](https://app.devin.ai/settings/playbooks/14fed18b89d44713a26e673cf258f548?utm_source=docs\&utm_medium=use-case-gallery): duplícalo y personalízalo con las convenciones de manejo de errores de tu equipo (error boundaries, patrones de comprobación de valores nulos, formato de logging). Luego pasa el ID del playbook en tu controlador de webhook agregando `"playbook_id": "your-playbook-id"` al cuerpo de la solicitud. También puedes pedirle a Devin que genere un playbook a partir de una descripción de tu flujo de trabajo de triaje.

      **Agrega [Knowledge](/es/product-guides/knowledge)** sobre tus contratos de API y casos límite conocidos; por ejemplo: "Las respuestas de `/api/users` pueden devolver `{ profile: null }` para usuarios que no hayan completado el onboarding. Asegúrate siempre de manejar este caso." Pídele a Devin que te ayude a redactar entradas de Knowledge a partir de tu documentación existente. Cuanto más contexto tenga Devin sobre tu dominio, más precisas serán sus correcciones.

      **Delimita bien el alcance de las alertas.** Usa las condiciones de reglas de alerta de Sentry para limitar qué errores activan a Devin: filtra por proyecto, entorno (solo `production`) o volumen de errores. Un buen punto de partida: que solo se disparen para incidencias con más de 50 eventos en la primera hora, para centrarte en los errores de mayor impacto.

      **Configura un calendario de revisión semanal.** Crea un [schedule](https://app.devin.ai/settings/schedules/create?utm_source=docs\&utm_medium=use-case-gallery) que se ejecute una vez por semana para revisar los resultados de tus sesiones de auto-triaje y volcar los aprendizajes en tu playbook y en Knowledge:

      <PromptBlock type="schedule">
        ```txt Weekly Sentry auto-triage review theme={null}
        Revisa todas las sesiones de Devin etiquetadas como "sentry-auto-triage" de la última semana.
        Para cada sesión, comprueba:

        1. Resultado del PR: ¿se fusionó, se cerró sin fusionar o sigue abierto?
        2. Estado de la incidencia en Sentry: ¿se marcó como resuelta/corregida, ignorada o descartada?
        3. Comentarios de revisores o cambios solicitados en el PR

        En función de estas señales:
        - Si los PR se cerraron de forma sistemática o recibieron el mismo tipo de comentarios (por ejemplo, "no uses
          optional chaining aquí, usa una protección explícita"), actualiza el playbook
          !sentry-triage con esa convención
        - Si Devin no tuvo en cuenta contexto que llevó a una mala corrección, añade una entrada de Knowledge
          que cubra esa área del dominio (por ejemplo, contratos de API, dependencias de servicios)
        - Resume: cuántas sesiones se ejecutaron, cuántos PR se fusionaron frente a los que se cerraron y
          cualquier patrón en los comentarios

        Publica el resumen en #engineering-ops en Slack.
        ```
      </PromptBlock>
    </Step>
  </Steps>
</div>