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

> Collega Devin a Datadog per l'analisi automatica degli avvisi e l'accesso alla telemetria

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

Datadog è un'integrazione MCP ufficiale disponibile nel [MCP Marketplace](/it/work-with-devin/mcp). Utilizza il trasporto HTTP con autenticazione tramite API key e Application key, offrendo a Devin accesso diretto al tuo account Datadog per interrogare log, metriche, monitor, tracce e altro ancora.

Una volta connesso, puoi anche configurare l'analisi automatico degli avvisi, instradando gli avvisi di Datadog a Devin tramite un semplice bridge webhook, così che gli incidenti vengano gestiti automaticamente.

<div id="enable-the-datadog-mcp">
  ## Abilita il Datadog MCP
</div>

<Steps>
  <Step title="Apri il MCP Marketplace">
    Vai in **Settings > MCP Marketplace** e individua **Datadog**.
  </Step>

  <Step title="Configura le credenziali">
    Fai clic su **Enable**, quindi:

    1. Seleziona il **sito/area geografica** di Datadog (ad es. `datadoghq.com`, `datadoghq.eu`)
    2. Inserisci la tua **DD-API-KEY** e **DD-APPLICATION-KEY**

    Per generare queste chiavi:

    * Crea una API key in [Organization Settings > API Keys](https://app.datadoghq.com/organization-settings/api-keys)
    * Crea una Application key in [Organization Settings > Application Keys](https://app.datadoghq.com/organization-settings/application-keys)
  </Step>

  <Step title="Verifica la connessione">
    Fai clic su **Test listing tools** per confermare che Devin possa connettersi al tuo account Datadog. Se il test ha esito positivo, l'integrazione è pronta all'uso.
  </Step>
</Steps>

<div id="capabilities">
  ## Funzionalità
</div>

Una volta abilitato Datadog MCP, Devin può eseguire le seguenti azioni in qualsiasi sessione:

| Funzionalità                           | Descrizione                                                                 |
| :------------------------------------- | :-------------------------------------------------------------------------- |
| Interrogare i log di errore            | Cercare e filtrare le voci di log per servizio, stato e intervallo di tempo |
| Recuperare serie temporali di metriche | Recuperare i punti dati delle metriche per dashboard e analisi              |
| Elencare i monitor attivi              | Visualizzare tutti i monitor configurati e i relativi stati attuali         |
| Cercare tracce                         | Trovare tracce distribuite tra i servizi                                    |
| Gestire gli incidenti                  | Visualizzare, creare e aggiornare i record degli incidenti                  |
| Gestire le dashboard                   | Elencare e ispezionare le configurazioni delle dashboard                    |

<Tip>
  Combina Datadog MCP con [Knowledge](/it/product-guides/knowledge) sui tuoi servizi — soglie normali, diagrammi dell'architettura e runbook di reperibilità — così Devin avvierà le indagini partendo dal contesto del tuo team.
</Tip>

<div id="automated-alert-investigation">
  ## Indagine automatica degli avvisi
</div>

Oltre alle query interattive, puoi collegare gli avvisi di Datadog a Devin in modo che gli incidenti vengano analizzati automaticamente. Questo approccio usa un pattern di **webhook bridge**: un piccolo servizio riceve i payload webhook di Datadog e chiama la [Devin API](/it/api-reference/overview) per avviare una sessione di indagine.

<Steps>
  <Step title="Distribuire un servizio webhook bridge">
    Crea un servizio leggero che riceva i webhook di Datadog e avvii sessioni di Devin. Distribuiscilo come funzione serverless (AWS Lambda, Cloudflare Worker) o come piccolo container:

    ```python theme={null}
    from flask import Flask, request, jsonify
    import requests, os, hmac, hashlib

    app = Flask(__name__)

    def verify_signature(req):
        """Verifica la richiesta usando un segreto condiviso configurato nel webhook Datadog."""
        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

        # Campi del payload webhook di Datadog
        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
    ```

    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. Nel passaggio successivo configurerai questo stesso segreto in **Custom Headers** del webhook Datadog.
  </Step>

  <Step title="Configurare il webhook Datadog">
    1. Nella dashboard di Datadog, vai a **Integrations > Webhooks**
    2. Fai clic su **New Webhook** e imposta l'URL sull'endpoint del tuo bridge (ad esempio, `https://your-bridge.example.com/alert`)
    3. In **Custom Headers**, aggiungi `X-Webhook-Secret` con lo stesso valore che hai salvato come `WEBHOOK_SECRET` sul servizio bridge
    4. Nel messaggio di notifica di un monitor, aggiungi `@webhook-devin-bridge` — Devin eseguirà un'indagine ogni volta che quel monitor si attiva
  </Step>

  <Step title="Testare con un monitor di livello warning">
    Inizia con un monitor di livello warning o a bassa gravità per convalidare la pipeline end-to-end prima di inoltrare gli avvisi critici. Una volta confermato che le sessioni di Devin vengono create e le indagini vengono eseguite correttamente, estendi la configurazione ai monitor con gravità più elevata.
  </Step>
</Steps>

<Note>
  Puoi personalizzare l'indagine passando un `playbook_id` nel corpo della richiesta alla Devin API. Duplica il playbook modello [`!triage`](https://app.devin.ai/settings/playbooks/14fed18b89d44713a26e673cf258f548) e adatta i passaggi dell'indagine al tuo stack.
</Note>

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

* [Guida completa: analisi automatica degli avvisi Datadog](/it/use-cases/gallery/api-datadog-alert-investigation)
* [Documentazione di MCP Marketplace](/it/work-with-devin/mcp)
* [Riferimento API di Devin](/it/api-reference/overview)