@braxtonbooth/datadog-mcp-server 1.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 datadog-mcp-server
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,330 @@
+# Datadog MCP Server
+
+> **Note:** This is an audited fork of [GeLi2001/datadog-mcp-server](https://github.com/GeLi2001/datadog-mcp-server) maintained by [@braxtonbooth](https://github.com/braxtonbooth). Security reviewed and monitored via Dependabot.
+
+A Model Context Protocol (MCP) server for interacting with the Datadog API.
+
+<a href="https://glama.ai/mcp/servers/@GeLi2001/datadog-mcp-server">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@GeLi2001/datadog-mcp-server/badge" alt="Datadog MCP server" />
+</a>
+
+## Features
+
+- **Monitoring**: Access monitor data and configurations
+- **Dashboards**: Retrieve and view dashboard definitions
+- **Metrics**: Query available metrics and their metadata
+- **Events**: Search and retrieve events within timeframes
+- **Logs**: Search logs with advanced filtering and sorting options
+- **Incidents**: Access incident management data
+- **API Integration**: Direct integration with Datadog's v1 and v2 APIs
+- **Comprehensive Error Handling**: Clear error messages for API and authentication issues
+- **Service-Specific Endpoints**: Support for different endpoints for logs and metrics
+
+## Prerequisites
+
+1. Node.js (version 16 or higher)
+2. Datadog account with:
+   - API key - Found in Organization Settings > API Keys
+   - Application key - Found in Organization Settings > Application Keys
+
+## Application Key Scopes
+
+For improved security, you can scope your Application Key to grant only the minimum permissions required by this MCP server. By default, Application Keys inherit all permissions from the user who created them, but [scoped Application Keys](https://docs.datadoghq.com/account_management/api-app-keys/#scopes) allow you to follow the principle of least privilege.
+
+### Required Scopes
+
+The following scopes are required for the corresponding features:
+
+| Tool(s) | Required Scope | Description |
+|---------|----------------|-------------|
+| `get-monitors`, `get-monitor` | `monitors_read` | Read access to monitor configurations and states |
+| `get-dashboards`, `get-dashboard` | `dashboards_read` | Read access to dashboard definitions |
+| `get-metrics`, `get-metric-metadata` | `metrics_read` | Read access to metrics list and metadata |
+| `get-events` | `events_read` | Read access to events from the event stream |
+| `search-logs`, `aggregate-logs` | `logs_read_data` | Read access to log data for search and aggregation |
+| `get-incidents` | `incident_read` | Read access to incident management data |
+
+### Creating a Scoped Application Key
+
+1. Go to **Organization Settings** > **Application Keys**
+2. Click **New Key**
+3. Enter a name (e.g., "MCP Server - Read Only")
+4. Under **Scopes**, select only the permissions you need:
+   - For full functionality: `monitors_read`, `dashboards_read`, `metrics_read`, `events_read`, `logs_read_data`, `incident_read`
+   - For logs only: `logs_read_data`
+   - For monitoring only: `monitors_read`, `dashboards_read`, `metrics_read`
+5. Click **Create Key**
+
+> **Note**: If you don't specify any scopes when creating an Application Key, it will have full access with all permissions of the creating user. For production use, we recommend always specifying explicit scopes.
+
+## Installation
+
+### Via npm (recommended)
+
+```bash
+npm install -g datadog-mcp-server
+```
+
+### From Source
+
+1. Clone this repository
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the project:
+   ```bash
+   npm run build
+   ```
+
+## Configuration
+
+You can configure the Datadog MCP server using either environment variables or command-line arguments.
+
+### Environment Variables
+
+Create a `.env` file with your Datadog credentials:
+
+```
+DD_API_KEY=your_api_key_here
+DD_APP_KEY=your_app_key_here
+DD_SITE=datadoghq.com
+DD_LOGS_SITE=datadoghq.com
+DD_METRICS_SITE=datadoghq.com
+```
+
+**Note**: `DD_LOGS_SITE` and `DD_METRICS_SITE` are optional and will default to the value of `DD_SITE` if not specified.
+
+### Command-line Arguments
+
+Basic usage with global site setting:
+
+```bash
+datadog-mcp-server --apiKey=your_api_key --appKey=your_app_key --site=datadoghq.eu
+```
+
+Advanced usage with service-specific endpoints:
+
+```bash
+datadog-mcp-server --apiKey=your_api_key --appKey=your_app_key --site=datadoghq.com --logsSite=logs.datadoghq.com --metricsSite=metrics.datadoghq.com
+```
+
+Note: Site arguments don't need `https://` - it will be added automatically.
+
+### Regional Endpoints
+
+Different Datadog regions have different endpoints:
+
+- US (Default): `datadoghq.com`
+- EU: `datadoghq.eu`
+- US3 (GovCloud): `ddog-gov.com`
+- US5: `us5.datadoghq.com`
+- AP1: `ap1.datadoghq.com`
+
+### Usage with Claude Desktop
+
+Add this to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "datadog": {
+      "command": "npx",
+      "args": [
+        "datadog-mcp-server",
+        "--apiKey",
+        "<YOUR_API_KEY>",
+        "--appKey",
+        "<YOUR_APP_KEY>",
+        "--site",
+        "<YOUR_DD_SITE>(e.g us5.datadoghq.com)"
+      ]
+    }
+  }
+}
+```
+
+For more advanced configurations with separate endpoints for logs and metrics:
+
+```json
+{
+  "mcpServers": {
+    "datadog": {
+      "command": "npx",
+      "args": [
+        "datadog-mcp-server",
+        "--apiKey",
+        "<YOUR_API_KEY>",
+        "--appKey",
+        "<YOUR_APP_KEY>",
+        "--site",
+        "<YOUR_DD_SITE>",
+        "--logsSite",
+        "<YOUR_LOGS_SITE>",
+        "--metricsSite",
+        "<YOUR_METRICS_SITE>"
+      ]
+    }
+  }
+}
+```
+
+Locations for the Claude Desktop config file:
+
+- MacOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%/Claude/claude_desktop_config.json`
+
+## Usage with MCP Inspector
+
+To use with the MCP Inspector tool:
+
+```bash
+npx @modelcontextprotocol/inspector datadog-mcp-server --apiKey=your_api_key --appKey=your_app_key
+```
+
+## Available Tools
+
+The server provides these MCP tools:
+
+- **get-monitors**: Fetch monitors with optional filtering
+- **get-monitor**: Get details of a specific monitor by ID
+- **get-dashboards**: List all dashboards
+- **get-dashboard**: Get a specific dashboard by ID
+- **get-metrics**: List available metrics
+- **get-metric-metadata**: Get metadata for a specific metric
+- **get-events**: Fetch events within a time range
+- **get-incidents**: List incidents with optional filtering
+- **search-logs**: Search logs with advanced query filtering
+- **aggregate-logs**: Perform analytics and aggregations on log data
+
+## Examples
+
+### Example: Get Monitors
+
+```javascript
+{
+  "method": "tools/call",
+  "params": {
+    "name": "get-monitors",
+    "arguments": {
+      "groupStates": ["alert", "warn"],
+      "limit": 5
+    }
+  }
+}
+```
+
+### Example: Get a Dashboard
+
+```javascript
+{
+  "method": "tools/call",
+  "params": {
+    "name": "get-dashboard",
+    "arguments": {
+      "dashboardId": "abc-def-123"
+    }
+  }
+}
+```
+
+### Example: Search Logs
+
+```javascript
+{
+  "method": "tools/call",
+  "params": {
+    "name": "search-logs",
+    "arguments": {
+      "filter": {
+        "query": "service:web-app status:error",
+        "from": "now-15m",
+        "to": "now"
+      },
+      "sort": "-timestamp",
+      "limit": 20
+    }
+  }
+}
+```
+
+### Example: Aggregate Logs
+
+```javascript
+{
+  "method": "tools/call",
+  "params": {
+    "name": "aggregate-logs",
+    "arguments": {
+      "filter": {
+        "query": "service:web-app",
+        "from": "now-1h",
+        "to": "now"
+      },
+      "compute": [
+        {
+          "aggregation": "count"
+        }
+      ],
+      "groupBy": [
+        {
+          "facet": "status",
+          "limit": 10,
+          "sort": {
+            "aggregation": "count",
+            "order": "desc"
+          }
+        }
+      ]
+    }
+  }
+}
+```
+
+### Example: Get Incidents
+
+```javascript
+{
+  "method": "tools/call",
+  "params": {
+    "name": "get-incidents",
+    "arguments": {
+      "includeArchived": false,
+      "query": "state:active",
+      "pageSize": 10
+    }
+  }
+}
+```
+
+## Troubleshooting
+
+If you encounter a 403 Forbidden error, verify that:
+
+1. Your API key and Application key are correct
+2. The keys have the necessary permissions to access the requested resources
+3. Your account has access to the requested data
+4. You're using the correct endpoint for your region (e.g., `datadoghq.eu` for EU customers)
+
+## Debugging
+
+If you encounter issues, check Claude Desktop's MCP logs:
+
+```bash
+# On macOS
+tail -n 20 -f ~/Library/Logs/Claude/mcp*.log
+
+# On Windows
+Get-Content -Path "$env:APPDATA\Claude\Logs\mcp*.log" -Tail 20 -Wait
+```
+
+Common issues:
+
+- 403 Forbidden: Authentication issue with Datadog API keys
+- API key or App key format invalid: Ensure you're using the full key strings
+- Site configuration errors: Make sure you're using the correct Datadog domain
+- Endpoint mismatches: Verify that service-specific endpoints are correctly set if you're using separate domains for logs and metrics
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const dotenv_1 = __importDefault(require("dotenv"));
+const minimist_1 = __importDefault(require("minimist"));
+const zod_1 = require("zod");
+// Import tools
+const aggregateLogs_js_1 = require("./tools/aggregateLogs.js");
+const getDashboard_js_1 = require("./tools/getDashboard.js");
+const getDashboards_js_1 = require("./tools/getDashboards.js");
+const getEvents_js_1 = require("./tools/getEvents.js");
+const getIncidents_js_1 = require("./tools/getIncidents.js");
+const getMetricMetadata_js_1 = require("./tools/getMetricMetadata.js");
+const getMetrics_js_1 = require("./tools/getMetrics.js");
+const getMonitor_js_1 = require("./tools/getMonitor.js");
+const getMonitors_js_1 = require("./tools/getMonitors.js");
+const searchLogs_js_1 = require("./tools/searchLogs.js");
+// Parse command line arguments
+const argv = (0, minimist_1.default)(process.argv.slice(2));
+// Load environment variables from .env file (if it exists)
+dotenv_1.default.config();
+// Define environment variables - from command line or .env file
+const DD_API_KEY = argv.apiKey || process.env.DD_API_KEY;
+const DD_APP_KEY = argv.appKey || process.env.DD_APP_KEY;
+// Get site configuration - defines the base domain for Datadog APIs
+const DD_SITE = argv.site || process.env.DD_SITE || "datadoghq.com";
+// Define service-specific endpoints for different Datadog services
+// This follows Datadog's recommended approach for configuring regional endpoints
+const DD_LOGS_SITE = argv.logsSite || process.env.DD_LOGS_SITE || DD_SITE;
+const DD_METRICS_SITE = argv.metricsSite || process.env.DD_METRICS_SITE || DD_SITE;
+// Remove https:// prefix if it exists to prevent double prefix issues
+const cleanupUrl = (url) => url.startsWith("https://") ? url.substring(8) : url;
+// Store clean values in process.env for backwards compatibility
+process.env.DD_API_KEY = DD_API_KEY;
+process.env.DD_APP_KEY = DD_APP_KEY;
+process.env.DD_SITE = cleanupUrl(DD_SITE);
+process.env.DD_LOGS_SITE = cleanupUrl(DD_LOGS_SITE);
+process.env.DD_METRICS_SITE = cleanupUrl(DD_METRICS_SITE);
+// Validate required environment variables
+if (!DD_API_KEY) {
+    console.error("Error: DD_API_KEY is required.");
+    console.error("Please provide it via command line argument or .env file.");
+    console.error(" Command line: --apiKey=your_api_key");
+    process.exit(1);
+}
+if (!DD_APP_KEY) {
+    console.error("Error: DD_APP_KEY is required.");
+    console.error("Please provide it via command line argument or .env file.");
+    console.error(" Command line: --appKey=your_app_key");
+    process.exit(1);
+}
+// Initialize Datadog client tools
+// We initialize each tool which will use the appropriate site configuration
+getMonitors_js_1.getMonitors.initialize();
+getMonitor_js_1.getMonitor.initialize();
+getDashboards_js_1.getDashboards.initialize();
+getDashboard_js_1.getDashboard.initialize();
+getMetrics_js_1.getMetrics.initialize();
+getMetricMetadata_js_1.getMetricMetadata.initialize();
+getEvents_js_1.getEvents.initialize();
+getIncidents_js_1.getIncidents.initialize();
+searchLogs_js_1.searchLogs.initialize();
+aggregateLogs_js_1.aggregateLogs.initialize();
+// Set up MCP server
+const server = new mcp_js_1.McpServer({
+    name: "datadog",
+    version: "1.0.0",
+    description: "MCP Server for Datadog API, enabling interaction with Datadog resources"
+});
+// Add tools individually, using their schemas directly
+server.tool("get-monitors", "Fetch monitors from Datadog with optional filtering. Use groupStates to filter by monitor status (e.g., 'alert', 'warn', 'no data'), tags or monitorTags to filter by tag criteria, and limit to control result size.", {
+    groupStates: zod_1.z.array(zod_1.z.string()).optional(),
+    tags: zod_1.z.string().optional(),
+    monitorTags: zod_1.z.string().optional(),
+    limit: zod_1.z.number().default(100)
+}, async (args) => {
+    const result = await getMonitors_js_1.getMonitors.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("get-monitor", "Get detailed information about a specific Datadog monitor by its ID. Use this to retrieve the complete configuration, status, and other details of a single monitor.", {
+    monitorId: zod_1.z.number()
+}, async (args) => {
+    const result = await getMonitor_js_1.getMonitor.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("get-dashboards", "Retrieve a list of all dashboards from Datadog. Useful for discovering available dashboards and their IDs for further exploration.", {
+    filterConfigured: zod_1.z.boolean().optional(),
+    limit: zod_1.z.number().default(100)
+}, async (args) => {
+    const result = await getDashboards_js_1.getDashboards.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("get-dashboard", "Get the complete definition of a specific Datadog dashboard by its ID. Returns all widgets, layout, and configuration details.", {
+    dashboardId: zod_1.z.string()
+}, async (args) => {
+    const result = await getDashboard_js_1.getDashboard.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("get-metrics", "List available metrics from Datadog. Optionally use the q parameter to search for specific metrics matching a pattern. Helpful for discovering metrics to use in monitors or dashboards.", {
+    q: zod_1.z.string().optional()
+}, async (args) => {
+    const result = await getMetrics_js_1.getMetrics.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("get-metric-metadata", "Retrieve detailed metadata about a specific metric, including its type, description, unit, and other attributes. Use this to understand a metric's meaning and proper usage.", {
+    metricName: zod_1.z.string()
+}, async (args) => {
+    const result = await getMetricMetadata_js_1.getMetricMetadata.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("get-events", "Search for events in Datadog within a specified time range. Events include deployments, alerts, comments, and other activities. Useful for correlating system behaviors with specific events.", {
+    start: zod_1.z.number(),
+    end: zod_1.z.number(),
+    priority: zod_1.z.enum(["normal", "low"]).optional(),
+    sources: zod_1.z.string().optional(),
+    tags: zod_1.z.string().optional(),
+    unaggregated: zod_1.z.boolean().optional(),
+    excludeAggregation: zod_1.z.boolean().optional(),
+    limit: zod_1.z.number().default(100)
+}, async (args) => {
+    const result = await getEvents_js_1.getEvents.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("get-incidents", "List incidents from Datadog's incident management system. Can filter by active/archived status and use query strings to find specific incidents. Helpful for reviewing current or past incidents.", {
+    includeArchived: zod_1.z.boolean().optional(),
+    pageSize: zod_1.z.number().optional(),
+    pageOffset: zod_1.z.number().optional(),
+    query: zod_1.z.string().optional(),
+    limit: zod_1.z.number().default(100)
+}, async (args) => {
+    const result = await getIncidents_js_1.getIncidents.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("search-logs", "Search logs in Datadog with advanced filtering options. Use filter.query for search terms (e.g., 'service:web-app status:error'), from/to for time ranges (e.g., 'now-15m', 'now'), and sort to order results. Essential for investigating application issues.", {
+    filter: zod_1.z
+        .object({
+        query: zod_1.z.string().optional(),
+        from: zod_1.z.string().optional(),
+        to: zod_1.z.string().optional(),
+        indexes: zod_1.z.array(zod_1.z.string()).optional()
+    })
+        .optional(),
+    sort: zod_1.z.string().optional(),
+    page: zod_1.z
+        .object({
+        limit: zod_1.z.number().optional(),
+        cursor: zod_1.z.string().optional()
+    })
+        .optional(),
+    limit: zod_1.z.number().default(100)
+}, async (args) => {
+    const result = await searchLogs_js_1.searchLogs.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+server.tool("aggregate-logs", "Perform analytical queries and aggregations on log data. Essential for calculating metrics (count, avg, sum, etc.), grouping data by fields, and creating statistical summaries from logs. Use this when you need to analyze patterns or extract metrics from log data.", {
+    filter: zod_1.z
+        .object({
+        query: zod_1.z.string().optional(),
+        from: zod_1.z.string().optional(),
+        to: zod_1.z.string().optional(),
+        indexes: zod_1.z.array(zod_1.z.string()).optional()
+    })
+        .optional(),
+    compute: zod_1.z
+        .array(zod_1.z.object({
+        aggregation: zod_1.z.string(),
+        metric: zod_1.z.string().optional(),
+        type: zod_1.z.string().optional()
+    }))
+        .optional(),
+    groupBy: zod_1.z
+        .array(zod_1.z.object({
+        facet: zod_1.z.string(),
+        limit: zod_1.z.number().optional(),
+        sort: zod_1.z
+            .object({
+            aggregation: zod_1.z.string(),
+            order: zod_1.z.string()
+        })
+            .optional()
+    }))
+        .optional(),
+    options: zod_1.z
+        .object({
+        timezone: zod_1.z.string().optional()
+    })
+        .optional()
+}, async (args) => {
+    const result = await aggregateLogs_js_1.aggregateLogs.execute(args);
+    return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+    };
+});
+// Start the server
+const transport = new stdio_js_1.StdioServerTransport();
+server
+    .connect(transport)
+    .then(() => { })
+    .catch((error) => {
+    console.error("Failed to start Datadog MCP Server:", error);
+});

package/dist/tools/aggregateLogs.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateLogs = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.aggregateLogs = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_LOGS_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_LOGS_SITE
+            });
+        }
+        // Enable any unstable operations
+        configuration.unstableOperations["v2.aggregateLogs"] = true;
+    },
+    execute: async (params) => {
+        try {
+            const { filter, compute, groupBy, options } = params;
+            // Directly call with fetch to use the documented aggregation endpoint
+            const apiUrl = `https://${process.env.DD_LOGS_SITE || "datadoghq.com"}/api/v2/logs/analytics/aggregate`;
+            const headers = {
+                "Content-Type": "application/json",
+                "DD-API-KEY": process.env.DD_API_KEY || "",
+                "DD-APPLICATION-KEY": process.env.DD_APP_KEY || ""
+            };
+            const body = {
+                filter: filter,
+                compute: compute,
+                group_by: groupBy,
+                options: options
+            };
+            const response = await fetch(apiUrl, {
+                method: "POST",
+                headers: headers,
+                body: JSON.stringify(body)
+            });
+            if (!response.ok) {
+                throw {
+                    status: response.status,
+                    message: await response.text()
+                };
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            if (error.status === 403) {
+                console.error("Authorization failed (403 Forbidden): Check that your API key and Application key are valid and have sufficient permissions to access log analytics.");
+                throw new Error("Datadog API authorization failed. Please verify your API and Application keys have the correct permissions.");
+            }
+            else {
+                console.error("Error aggregating logs:", error);
+                throw error;
+            }
+        }
+    }
+};

package/dist/tools/getDashboard.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDashboard = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.getDashboard = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_SITE
+            });
+        }
+    },
+    execute: async (params) => {
+        try {
+            const { dashboardId } = params;
+            const apiInstance = new datadog_api_client_1.v1.DashboardsApi(configuration);
+            const apiParams = {
+                dashboardId: dashboardId
+            };
+            const response = await apiInstance.getDashboard(apiParams);
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching dashboard ${params.dashboardId}:`, error);
+            throw error;
+        }
+    }
+};

package/dist/tools/getDashboards.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDashboards = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.getDashboards = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_SITE
+            });
+        }
+    },
+    execute: async (params) => {
+        try {
+            const { filterConfigured, limit } = params;
+            const apiInstance = new datadog_api_client_1.v1.DashboardsApi(configuration);
+            // No parameters needed for listDashboards
+            const response = await apiInstance.listDashboards();
+            // Apply client-side filtering if specified
+            let filteredDashboards = response.dashboards || [];
+            // Apply client-side limit if specified
+            if (limit && filteredDashboards.length > limit) {
+                filteredDashboards = filteredDashboards.slice(0, limit);
+            }
+            return {
+                ...response,
+                dashboards: filteredDashboards
+            };
+        }
+        catch (error) {
+            console.error("Error fetching dashboards:", error);
+            throw error;
+        }
+    }
+};

package/dist/tools/getEvents.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEvents = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.getEvents = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_SITE
+            });
+        }
+    },
+    execute: async (params) => {
+        try {
+            const { start, end, priority, sources, tags, unaggregated, excludeAggregation, limit } = params;
+            const apiInstance = new datadog_api_client_1.v1.EventsApi(configuration);
+            const apiParams = {
+                start: start,
+                end: end,
+                priority: priority,
+                sources: sources,
+                tags: tags,
+                unaggregated: unaggregated,
+                excludeAggregate: excludeAggregation
+            };
+            const response = await apiInstance.listEvents(apiParams);
+            // Apply client-side limit if specified
+            if (limit && response.events && response.events.length > limit) {
+                response.events = response.events.slice(0, limit);
+            }
+            return response;
+        }
+        catch (error) {
+            console.error("Error fetching events:", error);
+            throw error;
+        }
+    }
+};

package/dist/tools/getIncidents.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIncidents = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.getIncidents = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_SITE
+            });
+        }
+        // Enable the unstable operation
+        configuration.unstableOperations["v2.listIncidents"] = true;
+    },
+    execute: async (params) => {
+        try {
+            const { includeArchived, pageSize, pageOffset, query, limit } = params;
+            const apiInstance = new datadog_api_client_1.v2.IncidentsApi(configuration);
+            const apiParams = {};
+            if (includeArchived !== undefined) {
+                apiParams.include_archived = includeArchived;
+            }
+            if (pageSize !== undefined) {
+                apiParams.page_size = pageSize;
+            }
+            if (pageOffset !== undefined) {
+                apiParams.page_offset = pageOffset;
+            }
+            if (query !== undefined) {
+                apiParams.query = query;
+            }
+            const response = await apiInstance.listIncidents(apiParams);
+            // Apply client-side limit if specified
+            if (limit && response.data && response.data.length > limit) {
+                response.data = response.data.slice(0, limit);
+            }
+            return response;
+        }
+        catch (error) {
+            if (error.status === 403) {
+                console.error("Authorization failed (403 Forbidden): Check that your API key and Application key are valid and have sufficient permissions to access incidents.");
+                throw new Error("Datadog API authorization failed. Please verify your API and Application keys have the correct permissions.");
+            }
+            else {
+                console.error("Error fetching incidents:", error);
+                throw error;
+            }
+        }
+    }
+};

package/dist/tools/getMetricMetadata.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetricMetadata = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.getMetricMetadata = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_METRICS_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_METRICS_SITE
+            });
+        }
+    },
+    execute: async (params) => {
+        try {
+            const { metricName } = params;
+            const apiInstance = new datadog_api_client_1.v1.MetricsApi(configuration);
+            const apiParams = {
+                metricName: metricName
+            };
+            const response = await apiInstance.getMetricMetadata(apiParams);
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching metadata for metric ${params.metricName}:`, error);
+            throw error;
+        }
+    }
+};

package/dist/tools/getMetrics.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetrics = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.getMetrics = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_METRICS_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_METRICS_SITE
+            });
+        }
+    },
+    execute: async (params) => {
+        try {
+            const { q } = params;
+            const apiInstance = new datadog_api_client_1.v1.MetricsApi(configuration);
+            const queryStr = q || "*";
+            const apiParams = {
+                q: queryStr
+            };
+            const response = await apiInstance.listMetrics(apiParams);
+            return response;
+        }
+        catch (error) {
+            console.error("Error fetching metrics:", error);
+            throw error;
+        }
+    }
+};

package/dist/tools/getMonitor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMonitor = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.getMonitor = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_METRICS_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_METRICS_SITE
+            });
+        }
+    },
+    execute: async (params) => {
+        try {
+            const { monitorId } = params;
+            const apiInstance = new datadog_api_client_1.v1.MonitorsApi(configuration);
+            const apiParams = {
+                monitorId: monitorId
+            };
+            const response = await apiInstance.getMonitor(apiParams);
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching monitor ${params.monitorId}:`, error);
+            throw error;
+        }
+    }
+};

package/dist/tools/getMonitors.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMonitors = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.getMonitors = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_METRICS_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_METRICS_SITE
+            });
+        }
+    },
+    execute: async (params) => {
+        try {
+            const { groupStates, tags, monitorTags, limit } = params;
+            const apiInstance = new datadog_api_client_1.v1.MonitorsApi(configuration);
+            const groupStatesStr = groupStates ? groupStates.join(",") : undefined;
+            const apiParams = {
+                groupStates: groupStatesStr,
+                tags: tags,
+                monitorTags: monitorTags
+            };
+            const response = await apiInstance.listMonitors(apiParams);
+            if (limit && response.length > limit) {
+                return response.slice(0, limit);
+            }
+            return response;
+        }
+        catch (error) {
+            if (error.status === 403) {
+                console.error("Authorization failed (403 Forbidden): Check that your API key and Application key are valid and have sufficient permissions to access monitors.");
+                throw new Error("Datadog API authorization failed. Please verify your API and Application keys have the correct permissions.");
+            }
+            else {
+                console.error("Error fetching monitors:", error);
+                throw error;
+            }
+        }
+    }
+};

package/dist/tools/searchLogs.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchLogs = void 0;
+const datadog_api_client_1 = require("@datadog/datadog-api-client");
+let configuration;
+exports.searchLogs = {
+    initialize: () => {
+        const configOpts = {
+            authMethods: {
+                apiKeyAuth: process.env.DD_API_KEY,
+                appKeyAuth: process.env.DD_APP_KEY
+            }
+        };
+        configuration = datadog_api_client_1.client.createConfiguration(configOpts);
+        if (process.env.DD_LOGS_SITE) {
+            configuration.setServerVariables({
+                site: process.env.DD_LOGS_SITE
+            });
+        }
+        // Enable any unstable operations
+        configuration.unstableOperations["v2.listLogsGet"] = true;
+    },
+    execute: async (params) => {
+        try {
+            const { apiKey = process.env.DD_API_KEY, appKey = process.env.DD_APP_KEY, filter, sort, page, limit } = params;
+            if (!apiKey || !appKey) {
+                throw new Error("API Key and App Key are required");
+            }
+            const apiInstance = new datadog_api_client_1.v2.LogsApi(configuration);
+            // Use a more flexible approach with POST
+            // Create the search request based on API docs
+            const body = {
+                filter: filter,
+                sort: sort,
+                page: page
+            };
+            // Use DD_LOGS_SITE environment variable instead of DD_SITE
+            const apiUrl = `https://${process.env.DD_LOGS_SITE || "datadoghq.com"}/api/v2/logs/events/search`;
+            const headers = {
+                "Content-Type": "application/json",
+                "DD-API-KEY": apiKey,
+                "DD-APPLICATION-KEY": appKey
+            };
+            const response = await fetch(apiUrl, {
+                method: "POST",
+                headers: headers,
+                body: JSON.stringify(body)
+            });
+            if (!response.ok) {
+                throw {
+                    status: response.status,
+                    message: await response.text()
+                };
+            }
+            const data = await response.json();
+            // Apply client-side limit if specified
+            if (limit && data.data && data.data.length > limit) {
+                data.data = data.data.slice(0, limit);
+            }
+            return data;
+        }
+        catch (error) {
+            if (error.status === 403) {
+                console.error("Authorization failed (403 Forbidden): Check that your API key and Application key are valid and have sufficient permissions to access logs.");
+                throw new Error("Datadog API authorization failed. Please verify your API and Application keys have the correct permissions.");
+            }
+            else {
+                console.error("Error searching logs:", error);
+                throw error;
+            }
+        }
+    }
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@braxtonbooth/datadog-mcp-server",
+  "version": "1.0.9",
+  "description": "MCP Server for Datadog API (Audited fork of GeLi2001/datadog-mcp-server)",
+  "main": "dist/index.js",
+  "type": "commonjs",
+  "bin": {
+    "@braxtonbooth/datadog-mcp-server": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc && node dist/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "npm run build",
+    "publish:dry-run": "npm pack --dry-run"
+  },
+  "keywords": [
+    "datadog",
+    "mcp",
+    "model-context-protocol",
+    "observability",
+    "api"
+  ],
+  "author": "GeLi2001",
+  "license": "MIT",
+  "dependencies": {
+    "@datadog/datadog-api-client": "^1.33.1",
+    "@modelcontextprotocol/sdk": "^1.8.0",
+    "dotenv": "^16.4.7",
+    "minimist": "^1.2.8",
+    "typescript": "^5.8.2",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/minimist": "^1.2.5"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/braxtonbooth/datadog-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/braxtonbooth/datadog-mcp-server/issues"
+  },
+  "homepage": "https://github.com/braxtonbooth/datadog-mcp-server#readme"
+}