> ## 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.
# Datadog-Integration
> Verbinden Sie Devin mit Datadog für die automatisierte Untersuchung von Alerts und den Zugriff auf Telemetriedaten
## Überblick
Datadog ist eine offizielle MCP-Integration, die im [MCP Marketplace](/de/work-with-devin/mcp) verfügbar ist. Sie nutzt HTTP-Transport mit Authentifizierung per API key und Anwendungsschlüssel und gibt Devin direkten Zugriff auf Ihr Datadog-Konto, um Logs, Metriken, Monitore, Traces und mehr abzufragen.
Nach dem Verbinden können Sie außerdem eine automatisierte Untersuchung von Alerts einrichten — dabei werden Datadog-Alerts über eine leichtgewichtige Webhook-Bridge an Devin weitergeleitet, sodass Incidents automatisch triagiert werden.
## Datadog MCP aktivieren
Gehen Sie zu **Settings > MCP Marketplace** und suchen Sie **Datadog**.
Klicken Sie auf **Enable** und dann:
1. Wählen Sie Ihre Datadog-**Site/Region** aus (z. B. `datadoghq.com`, `datadoghq.eu`)
2. Geben Sie Ihren **DD-API-KEY** und **DD-APPLICATION-KEY** ein
So erstellen Sie diese Schlüssel:
* Erstellen Sie unter [Organization Settings > API Keys](https://app.datadoghq.com/organization-settings/api-keys) einen API key
* Erstellen Sie unter [Organization Settings > Application Keys](https://app.datadoghq.com/organization-settings/application-keys) einen Anwendungsschlüssel
Klicken Sie auf **Test listing tools**, um zu prüfen, ob Devin eine Verbindung zu Ihrem Datadog-Konto herstellen kann. Wenn der Test erfolgreich ist, ist die Integration einsatzbereit.
## Funktionen
Sobald das Datadog MCP aktiviert ist, kann Devin in jeder Sitzung die folgenden Aktionen ausführen:
| Funktion | Beschreibung |
| :--------------------------- | :--------------------------------------------------------------------- |
| Fehlerprotokolle durchsuchen | Protokolleinträge nach Service, Status und Zeitraum suchen und filtern |
| Metrik-Zeitreihen abrufen | Metrikdatenpunkte für Dashboards und Analysen abrufen |
| Aktive Monitore auflisten | Alle konfigurierten Monitore und ihren aktuellen Status anzeigen |
| Traces durchsuchen | Verteilte Traces über mehrere Services hinweg finden |
| Incidents verwalten | Incident-Einträge anzeigen, erstellen und aktualisieren |
| Dashboards verwalten | Dashboard-Konfigurationen auflisten und einsehen |
Kombinieren Sie das Datadog MCP mit [Knowledge](/de/product-guides/knowledge) zu Ihren Services — normalen Schwellenwerten, Architekturdiagrammen und On-Call-Runbooks — damit Devin Untersuchungen direkt mit dem Kontext Ihres Teams beginnt.
## Automatisierte Untersuchung von Alerts
Neben interaktiven Abfragen können Sie Datadog-Alerts mit Devin verbinden, sodass Incidents automatisch untersucht werden. Dabei wird das Muster einer **Webhook-Bridge** verwendet: Ein kleiner Dienst empfängt Datadog-Webhook-Payloads und ruft die [Devin API](/de/api-reference/overview) auf, um eine Untersuchungssitzung zu starten.
Erstellen Sie einen schlanken Dienst, der Datadog-Webhooks empfängt und Devin-Sitzungen startet. Stellen Sie ihn als serverlose Funktion (AWS Lambda, Cloudflare Worker) oder als kleinen Container bereit:
```python theme={null}
from flask import Flask, request, jsonify
import requests, os, hmac, hashlib
app = Flask(__name__)
def verify_signature(req):
"""Verify the request using a shared secret configured in the Datadog webhook."""
signature = req.headers.get("X-Webhook-Secret", "")
expected = os.environ["WEBHOOK_SECRET"]
return hmac.compare_digest(signature, expected)
@app.route("/alert", methods=["POST"])
def handle_alert():
if not verify_signature(request):
return jsonify({"error": "bad signature"}), 401
payload = request.json
if not payload:
return jsonify({"error": "no payload"}), 400
# Datadog webhook payload fields
alert_title = payload.get("title", "Unknown alert")
tags = payload.get("tags", "")
if isinstance(tags, str):
tags = [t.strip() for t in tags.split(",")]
service = next(
(t.split(":", 1)[1] for t in tags if t.startswith("service:")),
"unknown-service"
)
alert_url = payload.get("link", "")
org_id = os.environ["DEVIN_ORG_ID"]
response = requests.post(
f"https://api.devin.ai/v3/organizations/{org_id}/sessions",
headers={"Authorization": f"Bearer {os.environ['DEVIN_API_KEY']}"},
json={
"prompt": (
f"Datadog alert fired: '{alert_title}'\n"
f"Service: {service}\n"
f"Alert link: {alert_url}\n\n"
"Using the Datadog MCP:\n"
"1. Pull error logs for this service from the past 30 min\n"
"2. Identify the top error messages and stack traces\n"
"3. Check if this correlates with a recent deploy\n"
"4. If the root cause is clear, open a hotfix PR\n"
"5. Post your findings to #incidents on Slack"
),
}
)
return jsonify(response.json()), 200
```
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 Organizations-ID als `DEVIN_ORG_ID` und ein gemeinsames Geheimnis als `WEBHOOK_SECRET` in Ihrem Bridge-Dienst. Dasselbe Geheimnis konfigurieren Sie im nächsten Schritt in den **Custom Headers** des Datadog-Webhooks.
1. Gehen Sie in Ihrem Datadog-Dashboard zu **Integrations > Webhooks**
2. Klicken Sie auf **New Webhook** und setzen Sie die URL auf Ihren Bridge-Endpunkt (z. B. `https://your-bridge.example.com/alert`)
3. Fügen Sie unter **Custom Headers** `X-Webhook-Secret` mit demselben Wert hinzu, den Sie in Ihrem Bridge-Dienst als `WEBHOOK_SECRET` gespeichert haben
4. Fügen Sie in der Benachrichtigungsnachricht eines beliebigen Monitors `@webhook-devin-bridge` hinzu — Devin untersucht den Vorfall jedes Mal, wenn dieser Monitor ausgelöst wird
Beginnen Sie mit einem Monitor auf Warnstufe oder mit niedriger Priorität, um die Pipeline Ende zu Ende zu validieren, bevor Sie kritische Alerts weiterleiten. Sobald Sie bestätigt haben, dass Devin-Sitzungen erstellt werden und die Untersuchungen korrekt ausgeführt werden, erweitern Sie dies auf Monitore mit höherer Priorität.
Sie können die Untersuchung anpassen, indem Sie im Request-Body der Devin API eine `playbook_id` übergeben. Duplizieren Sie das Template-Playbook [`!triage`](https://app.devin.ai/settings/playbooks/14fed18b89d44713a26e673cf258f548) und passen Sie die Untersuchungsschritte an Ihren Stack an.
## Weiterführende Ressourcen
* [Ausführliche Schritt-für-Schritt-Anleitung: Automatische Untersuchung von Datadog-Alerts](/de/use-cases/gallery/api-datadog-alert-investigation)
* [MCP Marketplace-Dokumentation](/de/work-with-devin/mcp)
* [Devin API-Referenz](/de/api-reference/overview)