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

# Integração com Datadog

> Conecte Devin ao Datadog para investigação automatizada de alertas e acesso à telemetria

<div id="overview">
  ## Visão geral
</div>

O Datadog é uma integração oficial de MCP disponível no [MCP Marketplace](/pt-BR/work-with-devin/mcp). Ele usa transporte HTTP com autenticação por Chave de API e chave de aplicativo, dando ao Devin acesso direto à sua conta do Datadog para consultar logs, métricas, monitores, traces e muito mais.

Depois de conectar, você também pode configurar a investigação automatizada de alertas — encaminhando alertas do Datadog para o Devin por meio de uma ponte leve via webhook, para que os incidentes sejam triados automaticamente.

<div id="enable-the-datadog-mcp">
  ## Ative o MCP do Datadog
</div>

<Steps>
  <Step title="Abra o MCP Marketplace">
    Vá para **Configurações > MCP Marketplace** e localize **Datadog**.
  </Step>

  <Step title="Configure suas credenciais">
    Clique em **Ativar** e, em seguida:

    1. Selecione o **site/região** do Datadog (por exemplo, `datadoghq.com`, `datadoghq.eu`)
    2. Insira sua **DD-API-KEY** e **DD-APPLICATION-KEY**

    Para gerar essas chaves:

    * Crie uma chave de API em [Organization Settings > API Keys](https://app.datadoghq.com/organization-settings/api-keys)
    * Crie uma chave de aplicativo em [Organization Settings > Application Keys](https://app.datadoghq.com/organization-settings/application-keys)
  </Step>

  <Step title="Verifique a conexão">
    Clique em **Test listing tools** para confirmar que Devin consegue se conectar à sua conta do Datadog. Se o teste for bem-sucedido, a integração estará pronta para uso.
  </Step>
</Steps>

<div id="capabilities">
  ## Capacidades
</div>

Assim que o Datadog MCP for ativado, Devin poderá realizar as seguintes ações em qualquer sessão:

| Capacidade                         | Descrição                                                                    |
| :--------------------------------- | :--------------------------------------------------------------------------- |
| Consultar logs de erro             | Pesquisar e filtrar entradas de log por serviço, status e intervalo de tempo |
| Obter séries temporais de métricas | Recuperar pontos de dados de métricas para dashboards e análise              |
| Listar monitores ativos            | Ver todos os monitores configurados e seus status atuais                     |
| Pesquisar traces                   | Encontrar traces distribuídos entre serviços                                 |
| Gerenciar incidentes               | Ver, criar e atualizar registros de incidentes                               |
| Gerenciar dashboards               | Listar e inspecionar configurações de dashboards                             |

<Tip>
  Combine o Datadog MCP com o [Knowledge](/pt-BR/product-guides/knowledge) sobre seus serviços — limiares normais, diagramas de arquitetura e runbooks de plantão — para que Devin inicie as investigações já com o contexto da sua equipe.
</Tip>

<div id="automated-alert-investigation">
  ## Investigação automatizada de alertas
</div>

Além de consultas interativas, você pode conectar alertas do Datadog ao Devin para que incidentes sejam investigados automaticamente. Isso usa um padrão de **ponte de webhook**: um pequeno serviço recebe payloads de webhook do Datadog e chama a [API do Devin](/pt-BR/api-reference/overview) para iniciar uma sessão de investigação.

<Steps>
  <Step title="Implante um serviço de ponte de webhook">
    Crie um serviço leve que receba webhooks do Datadog e inicie sessões do Devin. Implante-o como uma função serverless (AWS Lambda, Cloudflare Worker) ou um pequeno contêiner:

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

    app = Flask(__name__)

    def verify_signature(req):
        """Verifica a solicitação usando um segredo compartilhado configurado no webhook do 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

        # Campos do payload do webhook do Datadog
        alert_title = payload.get("title", "Alerta desconhecido")
        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:")),
            "serviço-desconhecido"
        )
        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"Alerta do Datadog disparado: '{alert_title}'\n"
                    f"Serviço: {service}\n"
                    f"Link do alerta: {alert_url}\n\n"
                    "Usando o MCP do Datadog:\n"
                    "1. Busque os logs de erro deste serviço nos últimos 30 min\n"
                    "2. Identifique as principais mensagens de erro e stack traces\n"
                    "3. Verifique se isso se correlaciona com um deploy recente\n"
                    "4. Se a causa raiz estiver clara, abra uma PR de hotfix\n"
                    "5. Publique suas conclusões em #incidents no Slack"
                ),
            }
        )
        return jsonify(response.json()), 200
    ```

    Crie um [service user](/pt-BR/api-reference/v3/overview) em **Configurações > Usuários de serviço** com a permissão `ManageOrgSessions`. Armazene o token da API como `DEVIN_API_KEY`, o ID da sua organização como `DEVIN_ORG_ID` e um segredo compartilhado como `WEBHOOK_SECRET` no serviço de ponte. Você configurará esse mesmo segredo nos **Custom Headers** do webhook do Datadog na próxima etapa.
  </Step>

  <Step title="Configure o webhook do Datadog">
    1. No painel do Datadog, acesse **Integrations > Webhooks**
    2. Clique em **New Webhook** e defina a URL como o endpoint da sua ponte (por exemplo, `https://your-bridge.example.com/alert`)
    3. Em **Custom Headers**, adicione `X-Webhook-Secret` com o mesmo valor que você armazenou como `WEBHOOK_SECRET` no serviço de ponte
    4. Na mensagem de notificação de qualquer monitor, adicione `@webhook-devin-bridge` — o Devin investigará sempre que esse monitor for acionado
  </Step>

  <Step title="Teste com um monitor em nível de aviso">
    Comece com um monitor em nível de aviso ou de baixa severidade para validar o pipeline de ponta a ponta antes de encaminhar alertas críticos. Depois de confirmar que as sessões do Devin estão sendo criadas e as investigações estão sendo executadas corretamente, expanda para monitores de maior severidade.
  </Step>
</Steps>

<Note>
  Você pode personalizar a investigação passando um `playbook_id` no corpo da solicitação da API do Devin. Duplique o playbook de modelo [`!triage`](https://app.devin.ai/settings/playbooks/14fed18b89d44713a26e673cf258f548) e adapte as etapas de investigação à sua stack.
</Note>

<div id="related-resources">
  ## Recursos relacionados
</div>

* [Guia completo: investigação automatizada de alertas do Datadog](/pt-BR/use-cases/gallery/api-datadog-alert-investigation)
* [Documentação do MCP Marketplace](/pt-BR/work-with-devin/mcp)
* [Referência da API do Devin](/pt-BR/api-reference/overview)