@jaypie/mcp 0.4.1 → 0.6.0

package/dist/suites/datadog/datadog.js

@@ -0,0 +1,828 @@
+import * as https from 'node:https';
+
+/**
+ * Datadog API integration module
+ */
+const nullLogger = {
+    info: () => { },
+    error: () => { },
+};
+/**
+ * Get Datadog credentials from environment variables
+ */
+function getDatadogCredentials() {
+    const apiKey = process.env.DATADOG_API_KEY || process.env.DD_API_KEY;
+    const appKey = process.env.DATADOG_APP_KEY ||
+        process.env.DATADOG_APPLICATION_KEY ||
+        process.env.DD_APP_KEY ||
+        process.env.DD_APPLICATION_KEY;
+    if (!apiKey || !appKey) {
+        return null;
+    }
+    return { apiKey, appKey };
+}
+/**
+ * Validate Datadog API credentials
+ */
+async function validateDatadogCredentials(credentials) {
+    return new Promise((resolve) => {
+        const options = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v1/validate",
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(options, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                if (res.statusCode === 200) {
+                    resolve({ valid: true });
+                }
+                else {
+                    resolve({
+                        valid: false,
+                        error: `Datadog API returned status ${res.statusCode}: ${data}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            resolve({ valid: false, error: error.message });
+        });
+        req.end();
+    });
+}
+/**
+ * Build query string from environment variables and options
+ */
+function buildDatadogQuery(options) {
+    const ddEnv = process.env.DD_ENV;
+    const ddService = process.env.DD_SERVICE;
+    const ddSource = process.env.DD_SOURCE;
+    const ddQuery = process.env.DD_QUERY;
+    const queryParts = [];
+    // Add source (parameter > env var > default 'lambda')
+    const effectiveSource = options.source || ddSource || "lambda";
+    queryParts.push(`source:${effectiveSource}`);
+    // Add env (parameter > env var)
+    const effectiveEnv = options.env || ddEnv;
+    if (effectiveEnv) {
+        queryParts.push(`env:${effectiveEnv}`);
+    }
+    // Add service (parameter > env var)
+    const effectiveService = options.service || ddService;
+    if (effectiveService) {
+        queryParts.push(`service:${effectiveService}`);
+    }
+    // Add base query from DD_QUERY if available
+    if (ddQuery) {
+        queryParts.push(ddQuery);
+    }
+    // Add user-provided query terms
+    if (options.query) {
+        queryParts.push(options.query);
+    }
+    return queryParts.join(" ");
+}
+/**
+ * Search Datadog logs
+ */
+async function searchDatadogLogs(credentials, options = {}, logger = nullLogger) {
+    const effectiveQuery = buildDatadogQuery(options);
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const effectiveLimit = Math.min(options.limit || 50, 1000);
+    const effectiveSort = options.sort || "-timestamp";
+    logger.info(`Effective query: ${effectiveQuery}`);
+    logger.info(`Search params: from=${effectiveFrom}, to=${effectiveTo}, limit=${effectiveLimit}, sort=${effectiveSort}`);
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        page: {
+            limit: effectiveLimit,
+        },
+        sort: effectiveSort,
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/logs/events/search",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid query syntax. Check your query: "${effectiveQuery}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have logs_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const logs = (response.data || []).map((log) => {
+                        const attrs = log.attributes || {};
+                        return {
+                            id: log.id,
+                            timestamp: attrs.timestamp,
+                            status: attrs.status,
+                            service: attrs.service,
+                            message: attrs.message,
+                            attributes: attrs.attributes,
+                        };
+                    });
+                    logger.info(`Retrieved ${logs.length} log entries`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                logs: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+/**
+ * Aggregate Datadog logs using the Analytics API
+ * Groups logs by specified fields and computes aggregations
+ */
+async function aggregateDatadogLogs(credentials, options, logger = nullLogger) {
+    const effectiveQuery = buildDatadogQuery(options);
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const groupBy = options.groupBy;
+    const compute = options.compute || [{ aggregation: "count" }];
+    logger.info(`Analytics query: ${effectiveQuery}`);
+    logger.info(`Group by: ${groupBy.join(", ")}`);
+    logger.info(`Time range: ${effectiveFrom} to ${effectiveTo}`);
+    // Build compute array - each item needs aggregation and type
+    const computeItems = compute.map((c) => {
+        const item = {
+            aggregation: c.aggregation,
+            type: "total",
+        };
+        if (c.metric) {
+            item.metric = c.metric;
+        }
+        return item;
+    });
+    // Build group_by with proper sort configuration
+    const groupByItems = groupBy.map((field) => {
+        const item = {
+            facet: field,
+            limit: 100,
+            sort: {
+                type: "measure",
+                order: "desc",
+                aggregation: compute[0]?.aggregation || "count",
+            },
+        };
+        return item;
+    });
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        group_by: groupByItems,
+        compute: computeItems,
+        page: {
+            limit: 100,
+        },
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/logs/analytics/aggregate",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Analytics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid query or groupBy fields. Verify facet names exist: ${groupBy.join(", ")}. Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have logs_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const buckets = (response.data?.buckets || []).map((bucket) => ({
+                        by: bucket.by || {},
+                        computes: bucket.computes || {},
+                    }));
+                    logger.info(`Retrieved ${buckets.length} aggregation buckets`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog analytics response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                groupBy,
+                buckets: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+/**
+ * List Datadog monitors with optional filtering
+ */
+async function listDatadogMonitors(credentials, options = {}, logger = nullLogger) {
+    logger.info("Fetching Datadog monitors");
+    const queryParams = new URLSearchParams();
+    if (options.tags && options.tags.length > 0) {
+        queryParams.set("tags", options.tags.join(","));
+    }
+    if (options.monitorTags && options.monitorTags.length > 0) {
+        queryParams.set("monitor_tags", options.monitorTags.join(","));
+    }
+    if (options.name) {
+        queryParams.set("name", options.name);
+    }
+    const queryString = queryParams.toString();
+    const path = `/api/v1/monitor${queryString ? `?${queryString}` : ""}`;
+    logger.info(`Request path: ${path}`);
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Monitors API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have monitors_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        monitors: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    let monitors = response.map((monitor) => ({
+                        id: monitor.id,
+                        name: monitor.name,
+                        type: monitor.type,
+                        status: monitor.overall_state || "Unknown",
+                        message: monitor.message,
+                        tags: monitor.tags || [],
+                        priority: monitor.priority,
+                        query: monitor.query,
+                        overallState: monitor.overall_state,
+                    }));
+                    // Filter by status if specified
+                    if (options.status && options.status.length > 0) {
+                        monitors = monitors.filter((m) => options.status.includes(m.status));
+                    }
+                    logger.info(`Retrieved ${monitors.length} monitors`);
+                    resolve({
+                        success: true,
+                        monitors,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog monitors response:", parseError);
+                    resolve({
+                        success: false,
+                        monitors: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                monitors: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * List Datadog Synthetic tests
+ */
+async function listDatadogSynthetics(credentials, options = {}, logger = nullLogger) {
+    logger.info("Fetching Datadog Synthetic tests");
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v1/synthetics/tests",
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Synthetics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have synthetics_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        tests: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    let tests = (response.tests || []).map((test) => ({
+                        publicId: test.public_id,
+                        name: test.name,
+                        type: test.type,
+                        status: test.status,
+                        tags: test.tags || [],
+                        locations: test.locations || [],
+                        message: test.message,
+                    }));
+                    // Filter by type if specified
+                    if (options.type) {
+                        tests = tests.filter((t) => t.type === options.type);
+                    }
+                    // Filter by tags if specified
+                    if (options.tags && options.tags.length > 0) {
+                        tests = tests.filter((t) => options.tags.some((tag) => t.tags.includes(tag)));
+                    }
+                    logger.info(`Retrieved ${tests.length} synthetic tests`);
+                    resolve({
+                        success: true,
+                        tests,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog synthetics response:", parseError);
+                    resolve({
+                        success: false,
+                        tests: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                tests: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Get recent results for a specific Synthetic test
+ */
+async function getDatadogSyntheticResults(credentials, publicId, logger = nullLogger) {
+    logger.info(`Fetching results for Synthetic test: ${publicId}`);
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: `/api/v1/synthetics/tests/${publicId}/results`,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Synthetics Results API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have synthetics_read permission.";
+                    }
+                    else if (res.statusCode === 404) {
+                        errorMessage = `Synthetic test '${publicId}' not found. Use datadog_synthetics (without testId) to list available tests.`;
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        publicId,
+                        results: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const results = (response.results || []).map((result) => ({
+                        publicId,
+                        resultId: result.result_id,
+                        status: result.status,
+                        checkTime: result.check_time,
+                        passed: result.result?.passed ?? result.status === 0,
+                        location: result.dc_id?.toString(),
+                    }));
+                    logger.info(`Retrieved ${results.length} synthetic results`);
+                    resolve({
+                        success: true,
+                        publicId,
+                        results,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog synthetic results:", parseError);
+                    resolve({
+                        success: false,
+                        publicId,
+                        results: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                publicId,
+                results: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Query Datadog metrics
+ */
+async function queryDatadogMetrics(credentials, options, logger = nullLogger) {
+    logger.info(`Querying metrics: ${options.query}`);
+    logger.info(`Time range: ${options.from} to ${options.to}`);
+    const queryParams = new URLSearchParams({
+        query: options.query,
+        from: options.from.toString(),
+        to: options.to.toString(),
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: `/api/v1/query?${queryParams.toString()}`,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Metrics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid metric query. Check format: 'aggregation:metric.name{tags}'. Query: "${options.query}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have metrics_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your time range.";
+                    }
+                    resolve({
+                        success: false,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const series = (response.series || []).map((s) => ({
+                        metric: s.metric,
+                        scope: s.scope,
+                        pointlist: s.pointlist,
+                        unit: s.unit?.[0]?.name,
+                    }));
+                    logger.info(`Retrieved ${series.length} metric series`);
+                    resolve({
+                        success: true,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog metrics response:", parseError);
+                    resolve({
+                        success: false,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: options.query,
+                timeRange: { from: options.from, to: options.to },
+                series: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Search Datadog RUM events
+ */
+async function searchDatadogRum(credentials, options = {}, logger = nullLogger) {
+    const effectiveQuery = options.query || "*";
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const effectiveLimit = Math.min(options.limit || 50, 1000);
+    const effectiveSort = options.sort || "-timestamp";
+    logger.info(`RUM query: ${effectiveQuery}`);
+    logger.info(`Time range: ${effectiveFrom} to ${effectiveTo}`);
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        page: {
+            limit: effectiveLimit,
+        },
+        sort: effectiveSort,
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/rum/events/search",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog RUM API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    // Check for specific "No valid indexes" error which means no RUM app is configured
+                    if (data.includes("No valid indexes")) {
+                        errorMessage =
+                            "No RUM application found. Ensure you have a RUM application configured in Datadog and it has collected data. " +
+                                "You can create a RUM application at https://app.datadoghq.com/rum/list";
+                    }
+                    else if (res.statusCode === 400) {
+                        errorMessage = `Invalid RUM query. Check syntax: "${effectiveQuery}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have rum_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const events = (response.data || []).map((event) => {
+                        const attrs = event.attributes?.attributes || {};
+                        return {
+                            id: event.id,
+                            type: event.type,
+                            timestamp: event.attributes?.timestamp,
+                            sessionId: attrs.session?.id,
+                            viewUrl: attrs.view?.url,
+                            viewName: attrs.view?.name,
+                            errorMessage: attrs.error?.message,
+                            errorType: attrs.error?.type,
+                            attributes: attrs,
+                        };
+                    });
+                    logger.info(`Retrieved ${events.length} RUM events`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog RUM response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                events: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+
+export { aggregateDatadogLogs, buildDatadogQuery, getDatadogCredentials, getDatadogSyntheticResults, listDatadogMonitors, listDatadogSynthetics, queryDatadogMetrics, searchDatadogLogs, searchDatadogRum, validateDatadogCredentials };
+//# sourceMappingURL=datadog.js.map