dd-mcp-server 1.0.0

package/src/tools/logs.ts

@@ -0,0 +1,110 @@
+import { z } from "zod";
+import { getClient } from "../datadog/client.js";
+
+export const searchLogsSchema = z.object({
+  query: z.string().describe("Datadog logs query string (e.g., 'service:my-app status:error')"),
+  from: z.string().describe("Start time in ISO 8601 format or relative time (e.g., 'now-1h')"),
+  to: z.string().describe("End time in ISO 8601 format or relative time (e.g., 'now')"),
+  limit: z.number().optional().default(50).describe("Maximum number of logs to return (default: 50, max: 1000)"),
+  sort: z.enum(["timestamp", "-timestamp"]).optional().default("-timestamp").describe("Sort order: 'timestamp' (oldest first) or '-timestamp' (newest first)"),
+  index: z.string().optional().describe("Log index to search (optional)"),
+});
+
+export type SearchLogsInput = z.infer<typeof searchLogsSchema>;
+
+interface LogsSearchResponse {
+  data: Array<{
+    id: string;
+    type: string;
+    attributes: {
+      timestamp: string;
+      message: string;
+      status: string;
+      service: string;
+      host: string;
+      tags: string[];
+      attributes: Record<string, unknown>;
+    };
+  }>;
+  meta?: {
+    page?: {
+      after?: string;
+    };
+  };
+}
+
+export async function searchLogs(input: SearchLogsInput): Promise<string> {
+  const client = getClient();
+
+  const body = {
+    filter: {
+      query: input.query,
+      from: input.from,
+      to: input.to,
+      ...(input.index && { indexes: [input.index] }),
+    },
+    sort: input.sort,
+    page: {
+      limit: Math.min(input.limit, 1000),
+    },
+  };
+
+  const response = await client.post<LogsSearchResponse>(
+    "/api/v2/logs/events/search",
+    body
+  );
+
+  const logs = response.data.map((log) => ({
+    id: log.id,
+    timestamp: log.attributes.timestamp,
+    message: log.attributes.message,
+    status: log.attributes.status,
+    service: log.attributes.service,
+    host: log.attributes.host,
+    tags: log.attributes.tags,
+  }));
+
+  return JSON.stringify({ logs, count: logs.length }, null, 2);
+}
+
+export const getLogSchema = z.object({
+  logId: z.string().describe("The unique ID of the log to retrieve"),
+});
+
+export type GetLogInput = z.infer<typeof getLogSchema>;
+
+interface LogResponse {
+  data: {
+    id: string;
+    type: string;
+    attributes: {
+      timestamp: string;
+      message: string;
+      status: string;
+      service: string;
+      host: string;
+      tags: string[];
+      attributes: Record<string, unknown>;
+    };
+  };
+}
+
+export async function getLog(input: GetLogInput): Promise<string> {
+  const client = getClient();
+
+  const response = await client.get<LogResponse>(
+    `/api/v2/logs/events/${input.logId}`
+  );
+
+  const log = response.data;
+  return JSON.stringify({
+    id: log.id,
+    timestamp: log.attributes.timestamp,
+    message: log.attributes.message,
+    status: log.attributes.status,
+    service: log.attributes.service,
+    host: log.attributes.host,
+    tags: log.attributes.tags,
+    attributes: log.attributes.attributes,
+  }, null, 2);
+}

package/src/tools/monitors.ts

@@ -0,0 +1,252 @@
+import { z } from "zod";
+import { getClient } from "../datadog/client.js";
+
+interface Monitor {
+  id: number;
+  name: string;
+  type: string;
+  query: string;
+  message: string;
+  tags: string[];
+  overall_state: string;
+  created: string;
+  modified: string;
+  options?: Record<string, unknown>;
+}
+
+export const listMonitorsSchema = z.object({
+  name: z.string().optional().describe("Filter monitors by name (partial match)"),
+  tags: z.string().optional().describe("Comma-separated list of tags to filter by"),
+  monitorTags: z.string().optional().describe("Comma-separated list of monitor tags to filter by"),
+});
+
+export type ListMonitorsInput = z.infer<typeof listMonitorsSchema>;
+
+export async function listMonitors(input: ListMonitorsInput): Promise<string> {
+  const client = getClient();
+
+  const params = new URLSearchParams();
+  if (input.name) params.append("name", input.name);
+  if (input.tags) params.append("tags", input.tags);
+  if (input.monitorTags) params.append("monitor_tags", input.monitorTags);
+
+  const queryString = params.toString();
+  const path = `/api/v1/monitor${queryString ? `?${queryString}` : ""}`;
+
+  const response = await client.get<Monitor[]>(path);
+
+  const monitors = response.map((m) => ({
+    id: m.id,
+    name: m.name,
+    type: m.type,
+    state: m.overall_state,
+    tags: m.tags,
+  }));
+
+  return JSON.stringify({ monitors, count: monitors.length }, null, 2);
+}
+
+export const getMonitorSchema = z.object({
+  monitorId: z.number().describe("The ID of the monitor to retrieve"),
+});
+
+export type GetMonitorInput = z.infer<typeof getMonitorSchema>;
+
+export async function getMonitor(input: GetMonitorInput): Promise<string> {
+  const client = getClient();
+  const response = await client.get<Monitor>(`/api/v1/monitor/${input.monitorId}`);
+
+  return JSON.stringify({
+    id: response.id,
+    name: response.name,
+    type: response.type,
+    query: response.query,
+    message: response.message,
+    tags: response.tags,
+    state: response.overall_state,
+    created: response.created,
+    modified: response.modified,
+    options: response.options,
+  }, null, 2);
+}
+
+export const createMonitorSchema = z.object({
+  name: z.string().describe("Name of the monitor"),
+  type: z.enum([
+    "metric alert",
+    "service check",
+    "event alert",
+    "query alert",
+    "composite",
+    "log alert",
+    "process alert",
+    "rum alert",
+    "trace-analytics alert",
+    "slo alert",
+    "event-v2 alert",
+    "audit alert",
+    "ci-pipelines alert",
+    "ci-tests alert",
+    "error-tracking alert",
+  ]).describe("Type of the monitor"),
+  query: z.string().describe("The monitor query"),
+  message: z.string().describe("Message to include with notifications"),
+  tags: z.array(z.string()).optional().describe("Tags to associate with the monitor"),
+  priority: z.number().optional().describe("Priority of the monitor (1-5)"),
+  options: z.object({
+    thresholds: z.object({
+      critical: z.number().optional(),
+      warning: z.number().optional(),
+      ok: z.number().optional(),
+    }).optional(),
+    notifyNoData: z.boolean().optional(),
+    noDataTimeframe: z.number().optional(),
+    renotifyInterval: z.number().optional(),
+  }).optional().describe("Monitor options"),
+});
+
+export type CreateMonitorInput = z.infer<typeof createMonitorSchema>;
+
+export async function createMonitor(input: CreateMonitorInput): Promise<string> {
+  const client = getClient();
+
+  const body = {
+    name: input.name,
+    type: input.type,
+    query: input.query,
+    message: input.message,
+    tags: input.tags || [],
+    priority: input.priority,
+    options: input.options ? {
+      thresholds: input.options.thresholds,
+      notify_no_data: input.options.notifyNoData,
+      no_data_timeframe: input.options.noDataTimeframe,
+      renotify_interval: input.options.renotifyInterval,
+    } : undefined,
+  };
+
+  const response = await client.post<Monitor>("/api/v1/monitor", body);
+
+  return JSON.stringify({
+    id: response.id,
+    name: response.name,
+    type: response.type,
+    message: "Monitor created successfully",
+  }, null, 2);
+}
+
+export const updateMonitorSchema = z.object({
+  monitorId: z.number().describe("The ID of the monitor to update"),
+  name: z.string().optional().describe("New name for the monitor"),
+  query: z.string().optional().describe("New query for the monitor"),
+  message: z.string().optional().describe("New message for notifications"),
+  tags: z.array(z.string()).optional().describe("New tags for the monitor"),
+  priority: z.number().optional().describe("New priority (1-5)"),
+  options: z.object({
+    thresholds: z.object({
+      critical: z.number().optional(),
+      warning: z.number().optional(),
+      ok: z.number().optional(),
+    }).optional(),
+    notifyNoData: z.boolean().optional(),
+    noDataTimeframe: z.number().optional(),
+    renotifyInterval: z.number().optional(),
+  }).optional().describe("Updated monitor options"),
+});
+
+export type UpdateMonitorInput = z.infer<typeof updateMonitorSchema>;
+
+export async function updateMonitor(input: UpdateMonitorInput): Promise<string> {
+  const client = getClient();
+
+  const body: Record<string, unknown> = {};
+  if (input.name) body.name = input.name;
+  if (input.query) body.query = input.query;
+  if (input.message) body.message = input.message;
+  if (input.tags) body.tags = input.tags;
+  if (input.priority) body.priority = input.priority;
+  if (input.options) {
+    body.options = {
+      thresholds: input.options.thresholds,
+      notify_no_data: input.options.notifyNoData,
+      no_data_timeframe: input.options.noDataTimeframe,
+      renotify_interval: input.options.renotifyInterval,
+    };
+  }
+
+  const response = await client.put<Monitor>(
+    `/api/v1/monitor/${input.monitorId}`,
+    body
+  );
+
+  return JSON.stringify({
+    id: response.id,
+    name: response.name,
+    message: "Monitor updated successfully",
+  }, null, 2);
+}
+
+export const deleteMonitorSchema = z.object({
+  monitorId: z.number().describe("The ID of the monitor to delete"),
+});
+
+export type DeleteMonitorInput = z.infer<typeof deleteMonitorSchema>;
+
+export async function deleteMonitor(input: DeleteMonitorInput): Promise<string> {
+  const client = getClient();
+  await client.delete(`/api/v1/monitor/${input.monitorId}`);
+
+  return JSON.stringify({
+    monitorId: input.monitorId,
+    message: "Monitor deleted successfully",
+  }, null, 2);
+}
+
+export const muteMonitorSchema = z.object({
+  monitorId: z.number().describe("The ID of the monitor to mute"),
+  scope: z.string().optional().describe("Scope to apply the mute to (e.g., 'host:myhost')"),
+  end: z.number().optional().describe("POSIX timestamp when the mute should end"),
+});
+
+export type MuteMonitorInput = z.infer<typeof muteMonitorSchema>;
+
+export async function muteMonitor(input: MuteMonitorInput): Promise<string> {
+  const client = getClient();
+
+  const body: Record<string, unknown> = {};
+  if (input.scope) body.scope = input.scope;
+  if (input.end) body.end = input.end;
+
+  await client.post(`/api/v1/monitor/${input.monitorId}/mute`, body);
+
+  return JSON.stringify({
+    monitorId: input.monitorId,
+    message: "Monitor muted successfully",
+  }, null, 2);
+}
+
+export const unmuteMonitorSchema = z.object({
+  monitorId: z.number().describe("The ID of the monitor to unmute"),
+  scope: z.string().optional().describe("Scope to unmute (e.g., 'host:myhost')"),
+  allScopes: z.boolean().optional().describe("If true, unmute all scopes"),
+});
+
+export type UnmuteMonitorInput = z.infer<typeof unmuteMonitorSchema>;
+
+export async function unmuteMonitor(input: UnmuteMonitorInput): Promise<string> {
+  const client = getClient();
+
+  const params = new URLSearchParams();
+  if (input.scope) params.append("scope", input.scope);
+  if (input.allScopes) params.append("all_scopes", "true");
+
+  const queryString = params.toString();
+  const path = `/api/v1/monitor/${input.monitorId}/unmute${queryString ? `?${queryString}` : ""}`;
+
+  await client.post(path, {});
+
+  return JSON.stringify({
+    monitorId: input.monitorId,
+    message: "Monitor unmuted successfully",
+  }, null, 2);
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}