@buenojs/bueno 0.8.10 → 0.8.11

package/dist/logger/transports/index.js

@@ -0,0 +1,740 @@
+/**
+ * Log Transport System
+ *
+ * Provides transport implementations for external log aggregation services
+ * like Datadog, generic HTTP webhooks, and console output.
+ */
+/**
+ * Generic HTTP webhook transport for sending logs to any HTTP endpoint
+ */
+export class HTTPWebhookTransport {
+    name = "HTTPWebhookTransport";
+    url;
+    headers;
+    batchSize;
+    flushInterval;
+    retryOptions;
+    onError;
+    timeout;
+    queue = [];
+    flushTimer = null;
+    isFlushing = false;
+    isClosed = false;
+    constructor(options) {
+        this.url = options.url;
+        this.headers = options.headers ?? {};
+        this.batchSize = options.batchSize ?? 100;
+        this.flushInterval = options.flushInterval ?? 5000;
+        this.timeout = options.timeout ?? 30000;
+        this.retryOptions = {
+            maxRetries: 3,
+            initialDelay: 100,
+            maxDelay: 10000,
+            backoffMultiplier: 2,
+            ...options.retries,
+        };
+        this.onError = options.onError;
+        this.startFlushTimer();
+    }
+    /**
+     * Start the flush timer
+     */
+    startFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        this.flushTimer = setInterval(() => {
+            this.flush().catch((err) => this.handleError(err));
+        }, this.flushInterval);
+    }
+    /**
+     * Send a single log entry
+     */
+    async send(entry) {
+        if (this.isClosed)
+            return;
+        this.queue.push(entry);
+        if (this.queue.length >= this.batchSize) {
+            await this.flush();
+        }
+    }
+    /**
+     * Send multiple log entries
+     */
+    async sendBatch(entries) {
+        if (this.isClosed)
+            return;
+        this.queue.push(...entries);
+        if (this.queue.length >= this.batchSize) {
+            await this.flush();
+        }
+    }
+    /**
+     * Flush pending logs
+     */
+    async flush() {
+        if (this.isFlushing || this.queue.length === 0 || this.isClosed)
+            return;
+        this.isFlushing = true;
+        const entriesToSend = [...this.queue];
+        this.queue = [];
+        try {
+            await this.sendWithRetry(entriesToSend);
+        }
+        catch (error) {
+            // Re-add entries to queue on failure
+            this.queue.unshift(...entriesToSend);
+            throw error;
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    /**
+     * Send entries with retry logic
+     */
+    async sendWithRetry(entries) {
+        let lastError = null;
+        let delay = this.retryOptions.initialDelay;
+        for (let attempt = 0; attempt <= this.retryOptions.maxRetries; attempt++) {
+            try {
+                await this.makeRequest(entries);
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < this.retryOptions.maxRetries) {
+                    await this.sleep(delay);
+                    delay = Math.min(delay * this.retryOptions.backoffMultiplier, this.retryOptions.maxDelay);
+                }
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Make HTTP request
+     */
+    async makeRequest(entries) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(this.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    ...this.headers,
+                },
+                body: JSON.stringify(entries),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Handle errors
+     */
+    handleError(error) {
+        if (this.onError) {
+            this.onError(error, this);
+        }
+    }
+    /**
+     * Close the transport
+     */
+    async close() {
+        this.isClosed = true;
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        // Flush remaining entries
+        if (this.queue.length > 0) {
+            try {
+                await this.flush();
+            }
+            catch (error) {
+                this.handleError(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+}
+/**
+ * Datadog Logs API transport
+ */
+export class DatadogTransport {
+    name = "DatadogTransport";
+    apiKey;
+    service;
+    env;
+    hostname;
+    tags;
+    endpoint;
+    batchSize;
+    flushInterval;
+    retryOptions;
+    onError;
+    timeout;
+    queue = [];
+    flushTimer = null;
+    isFlushing = false;
+    isClosed = false;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.service = options.service;
+        this.env = options.env ?? process.env.NODE_ENV ?? "development";
+        this.hostname = options.hostname ?? this.getDefaultHostname();
+        this.tags = options.tags ?? [];
+        this.endpoint =
+            options.endpoint ?? "https://http-intake.logs.datadoghq.com/v1/input";
+        this.batchSize = options.batchSize ?? 100;
+        this.flushInterval = options.flushInterval ?? 5000;
+        this.timeout = options.timeout ?? 30000;
+        this.retryOptions = {
+            maxRetries: 3,
+            initialDelay: 100,
+            maxDelay: 10000,
+            backoffMultiplier: 2,
+            ...options.retries,
+        };
+        this.onError = options.onError;
+        this.startFlushTimer();
+    }
+    /**
+     * Get default hostname
+     */
+    getDefaultHostname() {
+        try {
+            return process.env.HOSTNAME ?? process.env.COMPUTERNAME ?? "unknown";
+        }
+        catch {
+            return "unknown";
+        }
+    }
+    /**
+     * Start the flush timer
+     */
+    startFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        this.flushTimer = setInterval(() => {
+            this.flush().catch((err) => this.handleError(err));
+        }, this.flushInterval);
+    }
+    /**
+     * Convert log level to Datadog status
+     */
+    toDatadogStatus(level) {
+        const statusMap = {
+            debug: "debug",
+            info: "info",
+            warn: "warn",
+            error: "error",
+            fatal: "emerg",
+        };
+        return statusMap[level];
+    }
+    /**
+     * Convert LogEntry to Datadog format
+     */
+    toDatadogFormat(entry) {
+        const allTags = [...this.tags];
+        // Add environment tag
+        if (this.env) {
+            allTags.push(`env:${this.env}`);
+        }
+        // Add context as tags
+        if (entry.context) {
+            for (const [key, value] of Object.entries(entry.context)) {
+                if (typeof value === "string" ||
+                    typeof value === "number" ||
+                    typeof value === "boolean") {
+                    allTags.push(`${key}:${value}`);
+                }
+            }
+        }
+        const datadogEntry = {
+            ddsource: "bueno",
+            ddsourcecategory: "framework",
+            ddtags: allTags.join(","),
+            hostname: this.hostname,
+            service: this.service,
+            status: this.toDatadogStatus(entry.level),
+            message: entry.message,
+            timestamp: entry.timestamp,
+        };
+        // Add error details
+        if (entry.error) {
+            datadogEntry.error = {
+                kind: entry.error.name,
+                message: entry.error.message,
+                stack: entry.error.stack,
+            };
+        }
+        // Add duration if present
+        if (entry.duration !== undefined) {
+            datadogEntry.duration = entry.duration;
+        }
+        // Add any additional fields from the entry
+        for (const [key, value] of Object.entries(entry)) {
+            if (![
+                "level",
+                "message",
+                "timestamp",
+                "context",
+                "error",
+                "duration",
+            ].includes(key)) {
+                datadogEntry[key] = value;
+            }
+        }
+        return datadogEntry;
+    }
+    /**
+     * Send a single log entry
+     */
+    async send(entry) {
+        if (this.isClosed)
+            return;
+        this.queue.push(entry);
+        if (this.queue.length >= this.batchSize) {
+            await this.flush();
+        }
+    }
+    /**
+     * Send multiple log entries
+     */
+    async sendBatch(entries) {
+        if (this.isClosed)
+            return;
+        this.queue.push(...entries);
+        if (this.queue.length >= this.batchSize) {
+            await this.flush();
+        }
+    }
+    /**
+     * Flush pending logs
+     */
+    async flush() {
+        if (this.isFlushing || this.queue.length === 0 || this.isClosed)
+            return;
+        this.isFlushing = true;
+        const entriesToSend = [...this.queue];
+        this.queue = [];
+        try {
+            await this.sendWithRetry(entriesToSend);
+        }
+        catch (error) {
+            // Re-add entries to queue on failure
+            this.queue.unshift(...entriesToSend);
+            throw error;
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    /**
+     * Send entries with retry logic
+     */
+    async sendWithRetry(entries) {
+        let lastError = null;
+        let delay = this.retryOptions.initialDelay;
+        for (let attempt = 0; attempt <= this.retryOptions.maxRetries; attempt++) {
+            try {
+                await this.makeRequest(entries);
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < this.retryOptions.maxRetries) {
+                    await this.sleep(delay);
+                    delay = Math.min(delay * this.retryOptions.backoffMultiplier, this.retryOptions.maxDelay);
+                }
+            }
+        }
+        throw lastError;
+    }
+    /**
+     * Make HTTP request to Datadog
+     */
+    async makeRequest(entries) {
+        const datadogEntries = entries.map((e) => this.toDatadogFormat(e));
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(this.endpoint, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "DD-API-KEY": this.apiKey,
+                },
+                body: datadogEntries.map((e) => JSON.stringify(e)).join("\n"),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new Error(`Datadog API error: HTTP ${response.status}: ${response.statusText}`);
+            }
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Sleep utility
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Handle errors
+     */
+    handleError(error) {
+        if (this.onError) {
+            this.onError(error, this);
+        }
+    }
+    /**
+     * Close the transport
+     */
+    async close() {
+        this.isClosed = true;
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        // Flush remaining entries
+        if (this.queue.length > 0) {
+            try {
+                await this.flush();
+            }
+            catch (error) {
+                this.handleError(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+}
+/**
+ * Enhanced console transport for local development
+ */
+export class ConsoleTransport {
+    name = "ConsoleTransport";
+    pretty;
+    stream;
+    onError;
+    constructor(options = {}) {
+        this.pretty = options.pretty ?? process.env.NODE_ENV !== "production";
+        this.stream = options.stream ?? "stdout";
+        this.onError = options.onError;
+    }
+    /**
+     * Get level color for pretty printing
+     */
+    getLevelColor(level) {
+        const colors = {
+            debug: "\x1b[36m", // cyan
+            info: "\x1b[32m", // green
+            warn: "\x1b[33m", // yellow
+            error: "\x1b[31m", // red
+            fatal: "\x1b[35m", // magenta
+        };
+        return colors[level];
+    }
+    /**
+     * Format log entry for console output
+     */
+    formatEntry(entry) {
+        if (this.pretty) {
+            const color = this.getLevelColor(entry.level);
+            const reset = "\x1b[0m";
+            let output = `${entry.timestamp} ${color}[${entry.level.toUpperCase()}]${reset} ${entry.message}`;
+            if (entry.context && Object.keys(entry.context).length > 0) {
+                output += ` ${reset}\x1b[90m${JSON.stringify(entry.context)}\x1b[0m`;
+            }
+            if (entry.duration !== undefined) {
+                output += ` \x1b[90m(${entry.duration}ms)\x1b[0m`;
+            }
+            if (entry.error) {
+                output += `\n  \x1b[31m${entry.error.name}: ${entry.error.message}\x1b[0m`;
+                if (entry.error.stack) {
+                    output += `\n  \x1b[90m${entry.error.stack}\x1b[0m`;
+                }
+            }
+            return output;
+        }
+        return JSON.stringify(entry);
+    }
+    /**
+     * Output to console
+     */
+    output(formatted, level) {
+        if (this.stream === "stderr" || level === "error" || level === "fatal") {
+            console.error(formatted);
+        }
+        else if (level === "warn") {
+            console.warn(formatted);
+        }
+        else {
+            console.log(formatted);
+        }
+    }
+    /**
+     * Send a single log entry
+     */
+    async send(entry) {
+        try {
+            const formatted = this.formatEntry(entry);
+            this.output(formatted, entry.level);
+        }
+        catch (error) {
+            if (this.onError) {
+                this.onError(error instanceof Error ? error : new Error(String(error)), this);
+            }
+        }
+    }
+    /**
+     * Send multiple log entries
+     */
+    async sendBatch(entries) {
+        for (const entry of entries) {
+            await this.send(entry);
+        }
+    }
+    /**
+     * Flush (no-op for console)
+     */
+    async flush() {
+        // Console transport doesn't buffer
+    }
+    /**
+     * Close (no-op for console)
+     */
+    async close() {
+        // Console transport doesn't need cleanup
+    }
+}
+// ============= Transport Manager =============
+/**
+ * Manages multiple log transports
+ */
+export class TransportManager {
+    transports = new Set();
+    onError;
+    constructor(options) {
+        this.onError = options?.onError;
+    }
+    /**
+     * Add a transport
+     */
+    addTransport(transport) {
+        this.transports.add(transport);
+    }
+    /**
+     * Remove a transport
+     */
+    removeTransport(transport) {
+        return this.transports.delete(transport);
+    }
+    /**
+     * Get all transports
+     */
+    getTransports() {
+        return [...this.transports];
+    }
+    /**
+     * Check if a transport is registered
+     */
+    hasTransport(transport) {
+        return this.transports.has(transport);
+    }
+    /**
+     * Clear all transports
+     */
+    clearTransports() {
+        this.transports.clear();
+    }
+    /**
+     * Broadcast a log entry to all transports
+     */
+    async broadcast(entry) {
+        const promises = [...this.transports].map(async (transport) => {
+            try {
+                await transport.send(entry);
+            }
+            catch (error) {
+                if (this.onError) {
+                    this.onError(error instanceof Error ? error : new Error(String(error)), transport);
+                }
+            }
+        });
+        await Promise.allSettled(promises);
+    }
+    /**
+     * Broadcast multiple entries to all transports
+     */
+    async broadcastBatch(entries) {
+        const promises = [...this.transports].map(async (transport) => {
+            try {
+                await transport.sendBatch(entries);
+            }
+            catch (error) {
+                if (this.onError) {
+                    this.onError(error instanceof Error ? error : new Error(String(error)), transport);
+                }
+            }
+        });
+        await Promise.allSettled(promises);
+    }
+    /**
+     * Flush all transports
+     */
+    async flushAll() {
+        const promises = [...this.transports].map(async (transport) => {
+            if (transport.flush) {
+                try {
+                    await transport.flush();
+                }
+                catch (error) {
+                    if (this.onError) {
+                        this.onError(error instanceof Error ? error : new Error(String(error)), transport);
+                    }
+                }
+            }
+        });
+        await Promise.allSettled(promises);
+    }
+    /**
+     * Close all transports
+     */
+    async closeAll() {
+        const promises = [...this.transports].map(async (transport) => {
+            if (transport.close) {
+                try {
+                    await transport.close();
+                }
+                catch (error) {
+                    if (this.onError) {
+                        this.onError(error instanceof Error ? error : new Error(String(error)), transport);
+                    }
+                }
+            }
+        });
+        await Promise.allSettled(promises);
+        this.transports.clear();
+    }
+}
+// ============= Logger Integration =============
+import { Logger } from "../index";
+/**
+ * Logger with transport support
+ */
+export class LoggerWithTransports extends Logger {
+    transportManager;
+    constructor(config = {}) {
+        const { transports, onTransportError, ...loggerConfig } = config;
+        // Create transport manager
+        const transportManager = new TransportManager({
+            onError: onTransportError,
+        });
+        // Add transports
+        if (transports) {
+            for (const transport of transports) {
+                transportManager.addTransport(transport);
+            }
+        }
+        // Create output function that broadcasts to transports
+        const originalOutput = loggerConfig.output;
+        const outputFn = (entry) => {
+            // Call original output if specified
+            if (originalOutput) {
+                if (typeof originalOutput === "function") {
+                    originalOutput(entry);
+                }
+            }
+            else {
+                // Default console output
+                console.log(JSON.stringify(entry));
+            }
+            // Broadcast to transports (async, fire-and-forget)
+            transportManager.broadcast(entry).catch(() => {
+                // Errors are handled by the transport manager
+            });
+        };
+        super({
+            ...loggerConfig,
+            output: outputFn,
+        });
+        this.transportManager = transportManager;
+    }
+    /**
+     * Add a transport
+     */
+    addTransport(transport) {
+        this.transportManager.addTransport(transport);
+    }
+    /**
+     * Remove a transport
+     */
+    removeTransport(transport) {
+        return this.transportManager.removeTransport(transport);
+    }
+    /**
+     * Get all transports
+     */
+    getTransports() {
+        return this.transportManager.getTransports();
+    }
+    /**
+     * Flush all transports
+     */
+    async flushTransports() {
+        await this.transportManager.flushAll();
+    }
+    /**
+     * Close all transports
+     */
+    async closeTransports() {
+        await this.transportManager.closeAll();
+    }
+}
+/**
+ * Create a logger with transports
+ */
+export function createLoggerWithTransports(config = {}) {
+    return new LoggerWithTransports(config);
+}
+/**
+ * Create a transport output function for use with existing Logger
+ */
+export function createTransportOutput(transports, options) {
+    const manager = new TransportManager({ onError: options?.onError });
+    for (const transport of transports) {
+        manager.addTransport(transport);
+    }
+    return (entry) => {
+        manager.broadcast(entry).catch(() => {
+            // Errors are handled by the transport manager
+        });
+    };
+}
+// ============= Exports =============
+export default {
+    HTTPWebhookTransport,
+    DatadogTransport,
+    ConsoleTransport,
+    TransportManager,
+    LoggerWithTransports,
+    createLoggerWithTransports,
+    createTransportOutput,
+};
+//# sourceMappingURL=index.js.map