Skip to main content

​
Panoramica

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 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, in cui PagerDuty instrada l’avviso a Devin e Devin usa Datadog per analizzare log e metriche.

​
Configurazione

1

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

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
3

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
  3. Devin inizi ad analizzare l’incidente

​
Best practice

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

​
In combinazione con Datadog

PagerDuty viene spesso usato insieme all’integrazione MCP di 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.
Aggiungi Knowledge sulla tua architettura di servizio e sui runbook di reperibilità, così Devin potrà seguire automaticamente le procedure di indagine del tuo team.