@jaypie/mcp 0.8.139 → 0.8.141

package/dist/suites/datadog/datadog.js

@@ -1,850 +0,0 @@
-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 setup without making API calls
- */
-function validateDatadogSetup() {
-    const apiKeySource = process.env.DATADOG_API_KEY
-        ? "DATADOG_API_KEY"
-        : process.env.DD_API_KEY
-            ? "DD_API_KEY"
-            : null;
-    const appKeySource = process.env.DATADOG_APP_KEY
-        ? "DATADOG_APP_KEY"
-        : process.env.DATADOG_APPLICATION_KEY
-            ? "DATADOG_APPLICATION_KEY"
-            : process.env.DD_APP_KEY
-                ? "DD_APP_KEY"
-                : process.env.DD_APPLICATION_KEY
-                    ? "DD_APPLICATION_KEY"
-                    : null;
-    return {
-        apiKey: { present: apiKeySource !== null, source: apiKeySource },
-        appKey: { present: appKeySource !== null, source: appKeySource },
-        success: apiKeySource !== null && appKeySource !== null,
-    };
-}
-/**
- * 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 ddQuery = process.env.DD_QUERY;
-    const queryParts = [];
-    // Add source (parameter only, no env var default)
-    if (options.source) {
-        queryParts.push(`source:${options.source}`);
-    }
-    // Add env (parameter > env var)
-    const effectiveEnv = options.env || ddEnv;
-    if (effectiveEnv) {
-        queryParts.push(`env:${effectiveEnv}`);
-    }
-    // Add service (parameter only, no env var default)
-    if (options.service) {
-        queryParts.push(`service:${options.service}`);
-    }
-    // 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, validateDatadogSetup };
-//# sourceMappingURL=datadog.js.map