> ## 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.

# Integração com PagerDuty

> Encaminhe incidentes do PagerDuty ao Devin para investigação automatizada

<div id="overview">
  ## Visão geral
</div>

O PagerDuty se integra ao Devin como um mecanismo de encaminhamento de alertas. Quando incidentes são disparados no PagerDuty, eles acionam sessões do Devin por meio da [Devin API](/pt-BR/api-reference/overview) usando uma ponte leve via webhook. O Devin então investiga o incidente automaticamente — coletando telemetria, rastreando causas-raiz e, opcionalmente, abrindo PRs de correção.

Esse padrão funciona especialmente bem quando combinado com a [integração do Datadog MCP](/pt-BR/enterprise/integrations/datadog), em que o PagerDuty encaminha o alerta para o Devin, e o Devin usa o Datadog para investigar logs e métricas.

<div id="setup">
  ## Configuração
</div>

<Steps>
  <Step title="Implante um serviço intermediário de webhook">
    Crie um serviço simples que receba payloads de incidentes do PagerDuty e chame a API do Devin para iniciar sessões de investigação.

    Crie um [service user](/pt-BR/api-reference/v3/overview) em **Settings > Service Users** com a permissão `ManageOrgSessions`. Armazene o token da API como `DEVIN_API_KEY`, o ID da sua organização como `DEVIN_ORG_ID` e um segredo compartilhado como `WEBHOOK_SECRET` no seu serviço intermediário. Você configurará esse mesmo segredo nos **Custom Headers** do webhook do PagerDuty na próxima etapa.

    ```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);
    ```

    Implante isso em qualquer ambiente que possa receber requisições HTTPS — como um Cloudflare Worker, AWS Lambda ou um pequeno contêiner.
  </Step>

  <Step title="Adicione uma integração de webhook no PagerDuty">
    1. No PagerDuty, acesse **Services > \[your service] > Integrations**
    2. Clique em **Add Integration** e selecione **Generic Webhooks (v3)**
    3. Defina a **Webhook URL** como o endpoint do seu serviço intermediário (por exemplo, `https://your-bridge.example.com/pagerduty-alert`)
    4. Em **Custom Headers**, adicione `X-Webhook-Secret` com o mesmo valor que você armazenou como `WEBHOOK_SECRET` no seu serviço intermediário
    5. Em **Event Subscription**, filtre pelo tipo de evento `incident.triggered` para acionar apenas em novos incidentes
  </Step>

  <Step title="Verifique o fluxo">
    Gere um incidente de teste no PagerDuty (ou use um serviço de teste) e confirme que:

    1. Seu serviço intermediário recebe o payload do webhook
    2. Uma nova sessão do Devin é criada em [app.devin.ai](https://app.devin.ai)
    3. Devin começa a investigar o incidente
  </Step>
</Steps>

<div id="best-practices">
  ## Boas práticas
</div>

* **Comece com monitores no nível de aviso.** Teste o pipeline com incidentes não críticos antes de encaminhar alertas P1 de produção para o Devin.
* **Filtre por serviço ou severidade.** Use as assinaturas de eventos de webhook do PagerDuty ou adicione lógica à sua bridge para ignorar serviços de baixa prioridade ou muito ruidosos. Isso evita que o Devin fique sobrecarregado com alertas de baixo valor.
* **Use playbooks diferentes para cada severidade.** Encaminhe alertas P1 para investigação imediata e hotfix. Encaminhe alertas P3 apenas para análise de causa raiz. Passe valores de `playbook_id` diferentes na solicitação à API do Devin com base na urgência.
* **Adicione tags às sessões para facilitar o rastreamento.** O código de exemplo marca cada sessão com `pagerduty-triage` e o nome do serviço, facilitando a filtragem e a revisão no dashboard do Devin.

<div id="combining-with-datadog">
  ## Combinando com Datadog
</div>

O PagerDuty geralmente é usado em conjunto com a [integração do Datadog MCP](/pt-BR/enterprise/integrations/datadog). Nesse padrão:

1. **PagerDuty** encaminha o alerta para o Devin (acionando a sessão de investigação)
2. **Devin** usa o **Datadog MCP** para consultar logs, métricas e traces do serviço afetado

Isso dá ao Devin tanto o contexto do alerta do PagerDuty quanto dados detalhados de observabilidade do Datadog, resultando em investigações mais completas.

<Tip>
  Add [Knowledge](/pt-BR/product-guides/knowledge) sobre a arquitetura do seu serviço e os runbooks de plantão para que o Devin possa seguir automaticamente os procedimentos de investigação da sua equipe.
</Tip>

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

* [Integração com o Datadog](/pt-BR/enterprise/integrations/datadog)
* [Documentação do MCP Marketplace](/pt-BR/work-with-devin/mcp)
* [Referência da API do Devin](/pt-BR/api-reference/overview)