strogger/dist/transports/datadog-transport.js

📊 A modern structured logging library with functional programming, duck-typing, and comprehensive third-party integrations

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.createDataDogTransport = void 0;
const types_1 = require("../types");
const errors_1 = require("../utils/errors");
const base_transport_1 = require("./base-transport");
const createDataDogTransport = (options = {}) => {
    const transportName = "DataDog";
    try {
        let minLevel = options.level ?? types_1.LogLevel.INFO;
        // Note: formatter is available for custom formatting
        // const formatter = options.formatter || {
        //   format: (entry: LogEntry) => JSON.stringify(entry),
        // };
        const apiKey = options.apiKey || process.env.DATADOG_API_KEY;
        const serviceName = options.serviceName || process.env.DD_SERVICE || process.env.SERVICE_NAME;
        const source = options.source || "nodejs";
        const tags = options.tags || [];
        const batchSize = options.batchSize || 10;
        const flushInterval = options.flushInterval || 5000;
        const region = options.region || process.env.DD_SITE || "us";
        // Validate required configuration
        (0, errors_1.validateEnvironmentVariable)("DATADOG_API_KEY", apiKey, true);
        // Validate transport configuration
        (0, errors_1.validateTransportConfig)(transportName, { apiKey }, ["apiKey"]);
        // Build tags string
        const defaultTags = [
            `env:${process.env.NODE_ENV || "dev"}`,
            `service:${serviceName || "unknown"}`,
            `source:${source}`,
        ];
        const allTags = [...defaultTags, ...tags].join(",");
        let batch = [];
        let flushTimer = null;
        const sendToDataDog = async (entries) => {
            try {
                const url = `https://http-intake.logs.${region === "eu" ? "eu." : ""}datadoghq.com/api/v2/logs`;
                const payload = entries.map((entry) => ({
                    message: entry.message,
                    level: getDataDogLevel(entry.level),
                    timestamp: new Date(entry.timestamp).getTime(),
                    ddsource: source,
                    ddtags: allTags,
                    service: serviceName,
                    ...entry.context,
                    ...(entry.error && {
                        error_name: entry.error.name,
                        error_message: entry.error.message,
                        error_stack: entry.error.stack,
                    }),
                    ...(entry.metadata && { metadata: entry.metadata }),
                }));
                const response = await fetch(url, {
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json",
                        "DD-API-KEY": apiKey,
                    },
                    body: JSON.stringify(payload),
                });
                if (!response.ok) {
                    throw (0, errors_1.createDetailedError)("DATADOG_API_ERROR", transportName, {
                        status: response.status,
                        statusText: response.statusText,
                        url,
                        responseBody: await response
                            .text()
                            .catch(() => "Unable to read response body"),
                    });
                }
            }
            catch (error) {
                (0, errors_1.handleTransportError)(error, transportName, true);
            }
        };
        const getDataDogLevel = (level) => {
            switch (level) {
                case types_1.LogLevel.DEBUG:
                    return "debug";
                case types_1.LogLevel.INFO:
                    return "info";
                case types_1.LogLevel.WARN:
                    return "warning";
                case types_1.LogLevel.ERROR:
                    return "error";
                case types_1.LogLevel.FATAL:
                    return "critical";
                default:
                    return "info";
            }
        };
        const flush = async () => {
            if (batch.length === 0)
                return;
            const entriesToSend = [...batch];
            batch = [];
            await sendToDataDog(entriesToSend);
        };
        const startFlushTimer = () => {
            if (flushTimer)
                return;
            flushTimer = setInterval(() => {
                flush().catch((error) => {
                    (0, errors_1.handleTransportError)(error, transportName, true);
                });
            }, flushInterval);
        };
        // Start the flush timer
        startFlushTimer();
        return {
            log: async (entry) => {
                if (!(0, base_transport_1.shouldLog)(entry.level, minLevel))
                    return;
                batch.push(entry);
                if (batch.length >= batchSize) {
                    await flush();
                }
            },
            setLevel: (level) => {
                minLevel = level;
            },
            getLevel: () => minLevel,
            // DataDog specific methods
            flush: async () => {
                await flush();
            },
            close: async () => {
                if (flushTimer) {
                    clearInterval(flushTimer);
                    flushTimer = null;
                }
                await flush();
            },
            // Add tags dynamically
            addTags: (newTags) => {
                tags.push(...newTags);
            },
            // Get current configuration
            getConfig: () => ({
                serviceName,
                source,
                tags: [...tags],
                region,
                batchSize,
                flushInterval,
            }),
        };
    }
    catch (error) {
        (0, errors_1.handleTransportError)(error, transportName, false);
        throw error; // Re-throw for proper error handling
    }
};
exports.createDataDogTransport = createDataDogTransport;
//# sourceMappingURL=datadog-transport.js.map