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

# Integración con PagerDuty

> Enruta incidentes de PagerDuty a Devin para una investigación automatizada

<div id="overview">
  ## Resumen
</div>

PagerDuty se integra con Devin como mecanismo de enrutamiento de alertas. Cuando se activan incidentes en PagerDuty, estos activan sesiones de Devin mediante la [API de Devin](/es/api-reference/overview) a través de un puente ligero basado en webhook. Después, Devin investiga el incidente automáticamente: recopila telemetría, rastrea la causa raíz y, de forma opcional, abre PR con correcciones.

Este patrón funciona especialmente bien cuando se combina con la [integración de Datadog MCP](/es/enterprise/integrations/datadog), donde PagerDuty enruta la alerta a Devin y Devin usa Datadog para investigar registros y métricas.

<div id="setup">
  ## Configuración
</div>

<Steps>
  <Step title="Despliega un servicio puente de webhook">
    Crea un pequeño controlador que reciba cargas de incidentes de PagerDuty y llame a la API de Devin para iniciar sesiones de investigación.

    Crea un [usuario de servicio](/es/api-reference/v3/overview) en **Settings > Service Users** con el permiso `ManageOrgSessions`. Guarda el token de la API como `DEVIN_API_KEY`, el ID de tu organización como `DEVIN_ORG_ID` y un secreto compartido como `WEBHOOK_SECRET` en tu servicio puente. Configurarás este mismo secreto en los **Custom Headers** del webhook de PagerDuty en el siguiente paso.

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

    function verifySignature(req) {
      const secret = Buffer.from(req.headers['x-webhook-secret'] || '');
      const expected = Buffer.from(process.env.WEBHOOK_SECRET || '');
      if (!expected.length) throw new Error('WEBHOOK_SECRET environment variable is not set');
      if (secret.length !== expected.length) return false;
      return crypto.timingSafeEqual(secret, expected);
    }

    app.post('/pagerduty-alert', async (req, res) => {
      if (!verifySignature(req)) return res.status(401).send('Bad signature');

      const event = req.body?.event;
      if (!event || event.event_type !== 'incident.triggered') {
        return res.sendStatus(200);
      }

      const incident = event.data;
      const title = incident.title || 'Unknown incident';
      const service = incident.service?.summary || 'unknown-service';
      const urgency = incident.urgency || 'high';
      const incidentUrl = incident.html_url || '';

      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: [
            `PagerDuty incident triggered: "${title}"`,
            `Service: ${service}`,
            `Urgency: ${urgency}`,
            `Incident URL: ${incidentUrl}`,
            ``,
            `Investigate this incident:`,
            `1. Check recent logs and metrics for ${service}`,
            `2. Identify the root cause of the issue`,
            `3. If the root cause is a code issue, open a hotfix PR`,
            `4. Post your findings to #incidents on Slack`,
          ].join('\n'),
          tags: ['pagerduty-triage', `service:${service}`],
        }),
      });

      const { session_id } = await response.json();
      console.log(`Started Devin session ${session_id} for: ${title}`);
      res.sendStatus(200);
    });

    app.listen(3000);
    ```

    Despliega esto en cualquier lugar que pueda recibir tráfico HTTPS: un Cloudflare Worker, AWS Lambda o un contenedor pequeño.
  </Step>

  <Step title="Agrega una integración de webhook en PagerDuty">
    1. En PagerDuty, ve a **Services > \[your service] > Integrations**
    2. Haz clic en **Add Integration** y selecciona **Generic Webhooks (v3)**
    3. Configura la **Webhook URL** con el endpoint de tu servicio puente (por ejemplo, `https://your-bridge.example.com/pagerduty-alert`)
    4. En **Custom Headers**, agrega `X-Webhook-Secret` con el mismo valor que guardaste como `WEBHOOK_SECRET` en tu servicio puente
    5. En **Event Subscription**, filtra por el tipo de evento `incident.triggered` para que solo se active con incidentes nuevos
  </Step>

  <Step title="Verifica el flujo">
    Genera un incidente de prueba en PagerDuty (o usa un servicio de prueba) y confirma que:

    1. Tu servicio puente recibe la carga del webhook
    2. Se crea una nueva sesión de Devin en [app.devin.ai](https://app.devin.ai)
    3. Devin comienza a investigar el incidente
  </Step>
</Steps>

<div id="best-practices">
  ## Mejores prácticas
</div>

* **Empieza con monitores de nivel de advertencia.** Prueba el pipeline con incidentes no críticos antes de enrutar a Devin las alertas P1 de producción.
* **Filtra por servicio o gravedad.** Usa las suscripciones a eventos de webhook de PagerDuty o agrega lógica en tu puente para omitir servicios de baja prioridad o ruidosos. Esto evita que Devin se sature con alertas de poco valor.
* **Usa distintos playbooks según la gravedad.** Enruta las alertas P1 para una investigación inmediata y hotfix. Enruta las alertas P3 solo para el análisis de causa raíz. Pasa distintos valores de `playbook_id` en la solicitud a la API de Devin según la urgencia.
* **Etiqueta las sesiones para facilitar el seguimiento.** El código de ejemplo etiqueta cada sesión con `pagerduty-triage` y el nombre del servicio, lo que facilita filtrarlas y revisarlas en el panel de Devin.

<div id="combining-with-datadog">
  ## Combinación con Datadog
</div>

PagerDuty suele usarse junto con la [integración de Datadog MCP](/es/enterprise/integrations/datadog). En este patrón:

1. **PagerDuty** enruta la alerta a Devin (lo que activa la sesión de investigación)
2. **Devin** usa **Datadog MCP** para consultar registros, métricas y trazas del servicio afectado

Esto le da a Devin tanto el contexto de la alerta de PagerDuty como datos de observabilidad detallados de Datadog, lo que permite realizar investigaciones más exhaustivas.

<Tip>
  Agrega [Knowledge](/es/product-guides/knowledge) sobre la arquitectura de tu servicio y los runbooks de guardia para que Devin pueda seguir automáticamente los procedimientos de investigación de tu equipo.
</Tip>

<div id="related-resources">
  ## Recursos relacionados
</div>

* [Integración de Datadog](/es/enterprise/integrations/datadog)
* [Documentación del Marketplace de MCP](/es/work-with-devin/mcp)
* [Referencia de la API de Devin](/es/api-reference/overview)