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

# Integrazione con PagerDuty

> Instrada gli incidenti di PagerDuty a Devin per l'analisi automatizzata

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

PagerDuty si integra con Devin come meccanismo di instradamento degli avvisi. Quando si verificano incidenti in PagerDuty, questi attivano sessioni di Devin tramite la [Devin API](/it/api-reference/overview) attraverso un leggero ponte webhook. Devin quindi analizza automaticamente l'incidente, recuperando la telemetria, individuando le cause all'origine e, facoltativamente, aprendo PR di correzione.

Questo modello funziona particolarmente bene se combinato con l'[integrazione MCP di Datadog](/it/enterprise/integrations/datadog), in cui PagerDuty instrada l'avviso a Devin e Devin usa Datadog per analizzare log e metriche.

<div id="setup">
  ## Configurazione
</div>

<Steps>
  <Step title="Distribuisci un servizio bridge webhook">
    Crea un piccolo handler che riceva i payload degli incidenti di PagerDuty e chiami l'API di Devin per avviare sessioni di analisi.

    Crea un [utente di servizio](/it/api-reference/v3/overview) in **Settings > Service Users** con l'autorizzazione `ManageOrgSessions`. Salva il token API come `DEVIN_API_KEY`, l'ID della tua organizzazione come `DEVIN_ORG_ID` e un segreto condiviso come `WEBHOOK_SECRET` sul servizio bridge. Configurerai questo stesso segreto nei **Custom Headers** del webhook di PagerDuty nel passaggio successivo.

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

    Distribuiscilo in qualsiasi ambiente che possa ricevere traffico HTTPS: un Cloudflare Worker, AWS Lambda o un piccolo container.
  </Step>

  <Step title="Aggiungi un'integrazione webhook in PagerDuty">
    1. In PagerDuty, vai a **Services > \[your service] > Integrations**
    2. Fai clic su **Add Integration** e seleziona **Generic Webhooks (v3)**
    3. Imposta il **Webhook URL** sull'endpoint del tuo servizio bridge (ad esempio `https://your-bridge.example.com/pagerduty-alert`)
    4. In **Custom Headers**, aggiungi `X-Webhook-Secret` con lo stesso valore che hai salvato come `WEBHOOK_SECRET` sul servizio bridge
    5. In **Event Subscription**, filtra per il tipo di evento `incident.triggered` in modo che si attivi solo per i nuovi incidenti
  </Step>

  <Step title="Verifica la pipeline">
    Genera un incidente di test in PagerDuty (o usa un servizio di test) e verifica che:

    1. Il tuo bridge riceva il payload del webhook
    2. Venga creata una nuova sessione Devin su [app.devin.ai](https://app.devin.ai)
    3. Devin inizi ad analizzare l'incidente
  </Step>
</Steps>

<div id="best-practices">
  ## Best practice
</div>

* **Inizia con monitor di livello warning.** Testa la pipeline con incidenti non critici prima di instradare a Devin gli avvisi P1 di produzione.
* **Filtra per servizio o gravità.** Usa le sottoscrizioni agli eventi webhook di PagerDuty oppure aggiungi logica nel tuo bridge per escludere i servizi a bassa priorità o che generano troppo rumore. In questo modo eviti di sovraccaricare Devin con avvisi di scarso valore.
* **Usa playbook diversi in base alla gravità.** Instrada gli avvisi P1 per l'indagine immediata e l'hotfix. Instrada gli avvisi P3 solo per l'analisi delle cause radice. Passa valori `playbook_id` diversi nella richiesta all'API di Devin in base all'urgenza.
* **Aggiungi tag alle sessioni per il monitoraggio.** Il codice di esempio assegna a ogni sessione il tag `pagerduty-triage` e il nome del servizio, rendendo più facile filtrare e rivedere le sessioni nella dashboard di Devin.

<div id="combining-with-datadog">
  ## In combinazione con Datadog
</div>

PagerDuty viene spesso usato insieme all'[integrazione MCP di Datadog](/it/enterprise/integrations/datadog). In questo schema:

1. **PagerDuty** instrada l'avviso a Devin (attivando la sessione di indagine)
2. **Devin** usa **Datadog MCP** per interrogare log, metriche e tracce del servizio interessato

Questo fornisce a Devin sia il contesto dell'avviso da PagerDuty sia dati di osservabilità approfonditi da Datadog, con il risultato di indagini più accurate.

<Tip>
  Aggiungi [Knowledge](/it/product-guides/knowledge) sulla tua architettura di servizio e sui runbook di reperibilità, così Devin potrà seguire automaticamente le procedure di indagine del tuo team.
</Tip>

<div id="related-resources">
  ## Risorse correlate
</div>

* [Integrazione Datadog](/it/enterprise/integrations/datadog)
* [Documentazione del Marketplace MCP](/it/work-with-devin/mcp)
* [Riferimento API di Devin](/it/api-reference/overview)