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

# PagerDuty-Integration

> PagerDuty-Incidents zur automatisierten Untersuchung an Devin weiterleiten

<div id="overview">
  ## Überblick
</div>

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](/de/api-reference/overview). 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](/de/enterprise/integrations/datadog): Dabei leitet PagerDuty den Alert an Devin weiter, und Devin verwendet Datadog, um Logs und Metriken zu untersuchen.

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

<Steps>
  <Step title="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](/de/api-reference/v3/overview) 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**.

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

    Stellen Sie dies an einem Ort bereit, der HTTPS-Traffic empfangen kann — etwa in einem Cloudflare Worker, AWS Lambda oder einem kleinen Container.
  </Step>

  <Step title="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
  </Step>

  <Step title="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](https://app.devin.ai) erstellt wird
    3. Devin mit der Untersuchung des Incidents beginnt
  </Step>
</Steps>

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

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

<div id="combining-with-datadog">
  ## Kombination mit Datadog
</div>

PagerDuty wird häufig zusammen mit der [Datadog MCP-Integration](/de/enterprise/integrations/datadog) 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.

<Tip>
  Fügen Sie [Knowledge](/de/product-guides/knowledge) Informationen zu Ihrer Servicearchitektur und Ihren On-Call-Runbooks hinzu, damit Devin die Untersuchungsverfahren Ihres Teams automatisch befolgen kann.
</Tip>

<div id="related-resources">
  ## Weiterführende Ressourcen
</div>

* [Datadog-Integration](/de/enterprise/integrations/datadog)
* [MCP-Marketplace-Dokumentation](/de/work-with-devin/mcp)
* [Devin API-Referenz](/de/api-reference/overview)