Skip to main content

Überblick

PagerDuty lässt sich mit Devin als Mechanismus zur Alert-Weiterleitung integrieren. Wenn Incidents in PagerDuty ausgelöst werden, starten sie über eine schlanke Webhook-Bridge Devin-Sitzungen über die Devin API. Devin untersucht den Incident dann automatisch — ruft Telemetriedaten ab, verfolgt die Ursache zurück und erstellt bei Bedarf PRs mit Fixes. Dieses Muster funktioniert besonders gut in Kombination mit der Datadog MCP-Integration: Dabei leitet PagerDuty den Alert an Devin weiter, und Devin verwendet Datadog, um Logs und Metriken zu untersuchen.

Einrichtung

1

Einen Webhook-Bridge-Service bereitstellen

Erstellen Sie einen kleinen Handler, der PagerDuty-Incident-Payloads empfängt und die Devin API aufruft, um Sitzungen zur Untersuchung zu starten.Erstellen Sie einen Service-Benutzer in Settings > Service Users mit der Berechtigung ManageOrgSessions. Speichern Sie das API-Token als DEVIN_API_KEY, Ihre Organisations-ID als DEVIN_ORG_ID und ein gemeinsames Secret als WEBHOOK_SECRET auf Ihrem Bridge-Service. Im nächsten Schritt konfigurieren Sie dieses Secret auch in den PagerDuty-Webhooks unter Custom Headers.
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);
Stellen Sie dies an einem Ort bereit, der HTTPS-Traffic empfangen kann — etwa in einem Cloudflare Worker, AWS Lambda oder einem kleinen Container.
2

Eine Webhook-Integration in PagerDuty hinzufügen

  1. Gehen Sie in PagerDuty zu Services > [your service] > Integrations
  2. Klicken Sie auf Add Integration und wählen Sie Generic Webhooks (v3) aus
  3. Setzen Sie die Webhook URL auf den Endpunkt Ihres Bridge-Service (z. B. https://your-bridge.example.com/pagerduty-alert)
  4. Fügen Sie unter Custom Headers X-Webhook-Secret mit demselben Wert hinzu, den Sie auf Ihrem Bridge-Service als WEBHOOK_SECRET gespeichert haben
  5. Filtern Sie unter Event Subscription nach dem Ereignistyp incident.triggered, damit der Webhook nur bei neuen Incidents ausgelöst wird
3

Die Pipeline überprüfen

Lösen Sie in PagerDuty einen Test-Incident aus (oder verwenden Sie einen Test-Service) und bestätigen Sie, dass:
  1. Ihr Bridge-Service die Webhook-Payload empfängt
  2. Eine neue Devin-Sitzung unter app.devin.ai erstellt wird
  3. Devin mit der Untersuchung des Incidents beginnt

Best Practices

  • Beginnen Sie mit Monitoren auf Warnstufe. Testen Sie die Pipeline mit unkritischen Incidents, bevor Sie P1-Produktions-Alerts an Devin weiterleiten.
  • Filtern Sie nach Service oder Schweregrad. Verwenden Sie die Webhook-Ereignisabonnements von PagerDuty oder fügen Sie Logik in Ihrer Bridge hinzu, um Services mit niedriger Priorität oder hohem Alert-Aufkommen zu überspringen. So verhindern Sie, dass Devin von Alerts mit geringem Mehrwert überlastet wird.
  • Verwenden Sie je nach Schweregrad unterschiedliche Playbooks. Leiten Sie P1-Alerts zur sofortigen Untersuchung und für Hotfixes weiter. Leiten Sie P3-Alerts nur zur Root-Cause-Analyse weiter. Übergeben Sie je nach Dringlichkeit unterschiedliche playbook_id-Werte in der Devin-API-Anfrage.
  • Taggen Sie Sitzungen zur Nachverfolgung. Der Beispielcode versieht jede Sitzung mit pagerduty-triage und dem Servicenamen, sodass sie sich im Devin-Dashboard leicht filtern und prüfen lassen.

Kombination mit Datadog

PagerDuty wird häufig zusammen mit der Datadog MCP-Integration verwendet. In diesem Muster:
  1. PagerDuty leitet den Alert an Devin weiter (wodurch die Untersuchungssitzung gestartet wird)
  2. Devin verwendet Datadog MCP, um Logs, Metriken und Traces für den betroffenen Service abzufragen
So erhält Devin sowohl den Alert-Kontext aus PagerDuty als auch detaillierte Observability-Daten aus Datadog, was zu gründlicheren Untersuchungen führt.
Fügen Sie Knowledge Informationen zu Ihrer Servicearchitektur und Ihren On-Call-Runbooks hinzu, damit Devin die Untersuchungsverfahren Ihres Teams automatisch befolgen kann.