@expressots/core 3.0.0 → 4.0.0-preview.3

package/lib/esm/provider/logger/logger.provider.js

@@ -0,0 +1,797 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var Logger_1;
+import { provideSingleton } from "../../decorator/scope-binding.js";
+import { LogLevel, parseLogLevel, shouldLog, } from "./utils/log-levels.js";
+import { createLogEntry } from "./utils/log-entry.js";
+import { getDefaultLoggerConfig } from "./logger.config.js";
+import { ConsoleTransport } from "./transports/console.transport.js";
+import { formatDev, formatGroupedDev, formatGroupedProd, } from "./logger.formatter.js";
+import { ContextManager } from "./logger.context.js";
+import { Timer, PerformanceMetricsCollector, measurePerformance, measurePerformanceSync, } from "./logger.performance.js";
+import { LogGroupingManager } from "./logger.grouping.js";
+import { HealthMonitor, collectHealthStatus, } from "./logger.health.js";
+import { LogQueryManager, LogQuery, exportToMarkdown, } from "./logger.query.js";
+/**
+ * Enhanced Logger provider with structured logging, multiple levels, and pluggable transports.
+ * Features:
+ * - Automatic context detection (class/method names)
+ * - Request-scoped context via AsyncLocalStorage
+ * - Child logger creation with inherited context
+ * - Multiple log levels (ALL, DEBUG, INFO, WARN, ERROR, FATAL, SILENT)
+ * - Pluggable transports (console, file, HTTP)
+ * @public API
+ */
+let Logger = class Logger {
+    static { Logger_1 = this; }
+    pid;
+    config;
+    transports = [];
+    currentContext;
+    contextObject;
+    autoDetectContext = true;
+    groupingManager = null;
+    healthMonitor = null;
+    queryManager = null;
+    /**
+     * Module-level overrides applied by `Logger.configure(...)` on top of the
+     * built-in defaults. Used by the constructor of every future `Logger`
+     * instance so application-wide config (e.g. log level, transports) can be
+     * set once before bootstrap, before any DI container exists.
+     */
+    static defaultOverrides = {};
+    name = "Logger Provider";
+    version = "4.1.0";
+    author = "Richard Zampieri";
+    repo = "https://github.com/expressots/expressots";
+    constructor() {
+        this.pid = process.pid;
+        // Merge module-level overrides on top of the built-in defaults so values
+        // set via Logger.configure(...) before container creation propagate to
+        // every instance. Caller-supplied transports replace the defaults, level
+        // is forwarded to the auto-installed console transport below.
+        const baseConfig = getDefaultLoggerConfig();
+        this.config = {
+            ...baseConfig,
+            ...Logger_1.defaultOverrides,
+        };
+        // Initialize with default console transport if none provided.
+        // Aligning the transport's level with the resolved logger level
+        // (which already honours `process.env.LOG_LEVEL`) keeps both
+        // filters consistent for messages emitted before any explicit
+        // `logger.configure({ level })` call.
+        if (this.config.transports.length === 0) {
+            const isDevelopment = process.env.NODE_ENV !== "production";
+            const transport = isDevelopment
+                ? ConsoleTransport.forDevelopment()
+                : ConsoleTransport.forProduction();
+            transport.level = parseLogLevel(this.config.level);
+            this.config.transports = [transport];
+        }
+        this.transports = this.config.transports;
+        // Initialize grouping manager with default config
+        this.groupingManager = new LogGroupingManager(this.config.grouping);
+        // Initialize query manager with default config
+        this.queryManager = new LogQueryManager(this.config.query);
+    }
+    /**
+     * Configure the default LoggerConfig used by every future `Logger`
+     * instance constructed in this process.
+     *
+     * Use this from application config files **before** bootstrap so the DI
+     * container's Logger picks up the correct level / transports / grouping /
+     * health / redaction settings without needing to inject and reconfigure it.
+     * Calls are merged: later calls override earlier ones, but unspecified
+     * keys keep their previously-set values.
+     *
+     * Already-constructed Logger instances are NOT mutated by this call —
+     * use the instance method `logger.configure(...)` to update a live one.
+     *
+     * @param config - Partial configuration to merge with the defaults.
+     * @public API
+     */
+    static configure(config) {
+        Logger_1.defaultOverrides = {
+            ...Logger_1.defaultOverrides,
+            ...config,
+        };
+    }
+    /**
+     * Reset the module-level overrides set by `Logger.configure`. Useful in
+     * tests to undo cross-test pollution.
+     *
+     * @public API
+     */
+    static resetConfigure() {
+        Logger_1.defaultOverrides = {};
+    }
+    /**
+     * Configure the logger.
+     * @param config - Partial configuration to merge with defaults
+     * @public API
+     */
+    configure(config) {
+        // Merge with existing config
+        this.config = {
+            ...this.config,
+            ...config,
+        };
+        // Update level if provided
+        if (config.level !== undefined) {
+            const newLevel = parseLogLevel(config.level);
+            this.config.level = newLevel;
+            // Update all existing transports to use the new level
+            // This ensures transports respect the logger's configured level
+            // Only update transports that were created with default levels (DEBUG/INFO)
+            // to avoid overriding explicit transport configurations
+            for (const transport of this.transports) {
+                const currentLevel = transport.level;
+                // Update if it's a default level (DEBUG for dev, INFO for prod)
+                // This allows dynamic level changes while preserving custom transport configs
+                if (currentLevel === LogLevel.DEBUG || currentLevel === LogLevel.INFO) {
+                    transport.level = newLevel;
+                }
+            }
+        }
+        // Update transports if provided
+        if (config.transports !== undefined) {
+            this.transports = config.transports;
+            this.config.transports = config.transports;
+        }
+        // Initialize or update health monitor if health config is provided
+        if (config.health !== undefined) {
+            if (this.healthMonitor) {
+                // Stop existing monitor
+                this.healthMonitor.stop();
+            }
+            // Create new monitor with updated config
+            this.healthMonitor = new HealthMonitor(this, config.health);
+            // Start monitoring if enabled
+            if (config.health.enabled !== false) {
+                this.healthMonitor.start();
+            }
+        }
+        // Initialize or update query manager if query config is provided
+        if (config.query !== undefined) {
+            if (this.queryManager) {
+                this.queryManager.configure(config.query);
+            }
+            else {
+                this.queryManager = new LogQueryManager(config.query);
+            }
+        }
+    }
+    /**
+     * Get the current logger configuration.
+     * @returns Current logger configuration
+     * @public API
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Log a trace message (ultra-detailed diagnostic).
+     * @param message - The message to log
+     * @param data - Optional structured data
+     * @public API
+     */
+    trace(message, data) {
+        this.log(LogLevel.ALL, message, { data });
+    }
+    /**
+     * Log a debug message (detailed diagnostic).
+     * @param message - The message to log
+     * @param data - Optional structured data
+     * @public API
+     */
+    debug(message, data) {
+        this.log(LogLevel.DEBUG, message, { data });
+    }
+    /**
+     * Log an informational message.
+     * @param message - The message to log
+     * @param module - Optional module/context name (legacy API)
+     * @param data - Optional structured data (new API)
+     * @public API
+     */
+    info(message, module, data) {
+        // Support both legacy (module) and new (data) API
+        if (module && typeof module === "string" && data === undefined) {
+            // Legacy API: info(message, module)
+            this.log(LogLevel.INFO, message, { context: module });
+        }
+        else {
+            // New API: info(message, data) or info(message, module, data)
+            const context = typeof module === "string" ? module : this.currentContext;
+            this.log(LogLevel.INFO, message, {
+                context,
+                data: typeof module === "object" ? module : data,
+            });
+        }
+    }
+    /**
+     * Log a warning message.
+     * @param message - The message to log
+     * @param module - Optional module/context name (legacy API)
+     * @param data - Optional structured data (new API)
+     * @public API
+     */
+    warn(message, module, data) {
+        // Support both legacy (module) and new (data) API
+        if (module && typeof module === "string" && data === undefined) {
+            // Legacy API: warn(message, module)
+            this.log(LogLevel.WARN, message, { context: module });
+        }
+        else {
+            // New API: warn(message, data) or warn(message, module, data)
+            const context = typeof module === "string" ? module : this.currentContext;
+            this.log(LogLevel.WARN, message, {
+                context,
+                data: typeof module === "object" ? module : data,
+            });
+        }
+    }
+    /**
+     * Log an error message.
+     * @param message - The message to log
+     * @param module - Optional module/context name (legacy API)
+     * @param error - Optional error object (new API)
+     * @public API
+     */
+    error(message, module, error) {
+        // Support both legacy (module) and new (error) API
+        if (module && typeof module === "string" && error === undefined) {
+            // Legacy API: error(message, module)
+            this.log(LogLevel.ERROR, message, { context: module });
+        }
+        else {
+            // New API: error(message, error) or error(message, module, error)
+            // Handle case where module might be an Error object (new API: error(message, error))
+            let context;
+            let errorObj;
+            if (typeof module === "string") {
+                // module is a string, error is the error object
+                context = module;
+                errorObj = error;
+            }
+            else if (module && typeof module === "object" && module !== null) {
+                // module is actually an error object (new API: error(message, error))
+                context = this.currentContext;
+                errorObj = module;
+            }
+            else {
+                // module is undefined, use current context
+                context = this.currentContext;
+                errorObj = error;
+            }
+            this.log(LogLevel.ERROR, message, {
+                context,
+                error: errorObj,
+            });
+        }
+    }
+    /**
+     * Log a fatal error message.
+     * @param message - The message to log
+     * @param error - Optional error object
+     * @public API
+     */
+    fatal(message, error) {
+        this.log(LogLevel.FATAL, message, { error });
+    }
+    /**
+     * Log a generic message (legacy API - maps to INFO).
+     * @param message - The message to log
+     * @param module - Optional module name
+     * @public API
+     */
+    msg(message, module) {
+        this.log(LogLevel.INFO, message, { context: module });
+    }
+    /**
+     * Create a child logger with inherited context.
+     * @param context - Context name for the child logger
+     * @returns New Logger instance with context
+     * @public API
+     */
+    child(context) {
+        const childLogger = new Logger_1();
+        childLogger.configure(this.config);
+        childLogger.currentContext = context;
+        childLogger.contextObject = { ...this.contextObject, label: context };
+        childLogger.autoDetectContext = this.autoDetectContext;
+        return childLogger;
+    }
+    /**
+     * Set context for subsequent logs.
+     * @param context - Context name, object, or LogContext
+     * @returns Logger instance for chaining
+     * @public API
+     *
+     * @example
+     * // String context
+     * logger.withContext("UserService").info("User created");
+     *
+     * @example
+     * // Object context
+     * logger.withContext({ className: "UserService", methodName: "create" }).info("User created");
+     *
+     * @example
+     * // Request context (typically set by middleware)
+     * logger.withContext({ requestId: "req_123", userId: "user_456" }).info("Processing request");
+     */
+    withContext(context) {
+        // Create a new logger instance to avoid mutating the original
+        const contextLogger = new Logger_1();
+        contextLogger.configure(this.config);
+        contextLogger.transports = this.transports;
+        contextLogger.autoDetectContext = this.autoDetectContext;
+        if (typeof context === "string") {
+            contextLogger.currentContext = context;
+            contextLogger.contextObject = { ...this.contextObject, label: context };
+        }
+        else {
+            // Merge context objects
+            contextLogger.contextObject = { ...this.contextObject, ...context };
+            contextLogger.currentContext =
+                context.className || context.label || this.currentContext;
+        }
+        return contextLogger;
+    }
+    /**
+     * Disable automatic context detection for this logger.
+     * @returns Logger instance for chaining
+     * @public API
+     */
+    noAutoContext() {
+        this.autoDetectContext = false;
+        return this;
+    }
+    /**
+     * Enable automatic context detection for this logger.
+     * @returns Logger instance for chaining
+     * @public API
+     */
+    enableAutoContext() {
+        this.autoDetectContext = true;
+        return this;
+    }
+    /**
+     * Run a function with request-scoped context.
+     * All logs within the function (including async operations) will include this context.
+     * @param context - Context to use for the duration of the function
+     * @param fn - Function to run
+     * @returns Result of the function
+     * @public API
+     *
+     * @example
+     * await logger.runWithContext({ requestId: "req_123" }, async () => {
+     *   logger.info("Processing..."); // Will include requestId
+     *   await someAsyncOperation(); // Nested logs also include requestId
+     * });
+     */
+    runWithContext(context, fn) {
+        const fullContext = { ...this.contextObject, ...context };
+        return ContextManager.runWithContext(fullContext, fn);
+    }
+    /**
+     * Core logging method.
+     * Supports automatic context detection, request-scoped context, and manual context.
+     * @param level - Log level
+     * @param message - Log message
+     * @param options - Additional options
+     */
+    log(level, message, options) {
+        const configuredLevel = parseLogLevel(this.config.level);
+        if (!shouldLog(level, configuredLevel)) {
+            return;
+        }
+        // Build context from multiple sources (in priority order):
+        // 1. Explicit context in options (highest priority)
+        // 2. Manual context set via withContext()
+        // 3. Request-scoped context from AsyncLocalStorage
+        // 4. Auto-detected context from call stack (lowest priority)
+        let finalContext = options?.context || this.currentContext;
+        // Get request-scoped context if available
+        const requestContext = ContextManager.getCurrentContext();
+        let mergedContextObject = { ...this.contextObject };
+        if (requestContext) {
+            mergedContextObject = { ...mergedContextObject, ...requestContext };
+            if (!finalContext && requestContext.className) {
+                finalContext = requestContext.className;
+            }
+        }
+        // Auto-detect context if enabled and no manual context is set
+        if (this.autoDetectContext && !finalContext) {
+            const autoContext = ContextManager.autoDetectContext();
+            if (autoContext.className) {
+                finalContext = autoContext.className;
+                mergedContextObject = { ...mergedContextObject, ...autoContext };
+            }
+        }
+        // Apply filters
+        if (this.config.filters && finalContext) {
+            if (this.config.filters.exclude?.includes(finalContext)) {
+                return;
+            }
+            if (this.config.filters.include &&
+                this.config.filters.include.length > 0) {
+                if (!this.config.filters.include.includes(finalContext)) {
+                    return;
+                }
+            }
+        }
+        // Extract flow from data if present (for backward compatibility)
+        let flowData = options?.flow;
+        let dataWithoutFlow = options?.data;
+        if (!flowData &&
+            typeof options?.data === "object" &&
+            options.data !== null &&
+            !Array.isArray(options.data) &&
+            "flow" in options.data) {
+            // Extract flow from data object
+            const dataObj = options.data;
+            flowData = dataObj.flow;
+            // Remove flow from data object
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { flow: _, ...rest } = dataObj;
+            dataWithoutFlow = Object.keys(rest).length > 0 ? rest : undefined;
+        }
+        // Merge all data sources
+        // Preserve arrays as arrays, don't convert to objects
+        let finalData = dataWithoutFlow;
+        if (Array.isArray(dataWithoutFlow)) {
+            // Keep arrays as arrays
+            finalData = dataWithoutFlow;
+        }
+        else if (dataWithoutFlow || Object.keys(mergedContextObject).length > 0) {
+            finalData = {
+                ...(typeof dataWithoutFlow === "object" && dataWithoutFlow !== null
+                    ? dataWithoutFlow
+                    : {}),
+                // Include request context metadata if present
+                ...(mergedContextObject.requestId
+                    ? { requestId: mergedContextObject.requestId }
+                    : {}),
+                ...(mergedContextObject.userId
+                    ? { userId: mergedContextObject.userId }
+                    : {}),
+                ...(mergedContextObject.tenantId
+                    ? { tenantId: mergedContextObject.tenantId }
+                    : {}),
+                ...(mergedContextObject.correlationId
+                    ? { correlationId: mergedContextObject.correlationId }
+                    : {}),
+            };
+            // Only use merged object if it has keys
+            if (Object.keys(finalData).length === 0) {
+                finalData = undefined;
+            }
+        }
+        const entry = createLogEntry(level, message, {
+            context: finalContext,
+            data: finalData,
+            error: options?.error,
+            trace: options?.trace,
+            performance: options?.performance,
+            flow: flowData,
+            pid: this.pid,
+        });
+        // Add entry to query buffer BEFORE grouping (so all entries are captured)
+        if (this.queryManager) {
+            this.queryManager.addEntry(entry);
+        }
+        // Process through grouping manager if enabled
+        if (this.groupingManager) {
+            const processed = this.groupingManager.processEntry(entry);
+            // If it's a grouped entry, format and send it
+            if (this.isGroupedLogEntry(processed)) {
+                this.sendGroupedEntry(processed);
+                return; // Don't send individual entry
+            }
+            // If it's not grouped yet (count < minOccurrences), send as normal
+            // The grouping manager will track it and group it later
+        }
+        // Send to all enabled transports
+        this.sendEntry(entry);
+    }
+    /**
+     * Check if a log entry is a grouped entry.
+     * @param entry - Log entry or grouped entry
+     * @returns True if grouped entry
+     */
+    isGroupedLogEntry(entry) {
+        return (typeof entry === "object" &&
+            entry !== null &&
+            "count" in entry &&
+            "representative" in entry &&
+            "firstOccurrence" in entry &&
+            "lastOccurrence" in entry);
+    }
+    /**
+     * Send a grouped log entry to transports.
+     * Formats grouped entries and writes them directly to stdout/stderr.
+     * @param groupedEntry - Grouped log entry
+     */
+    sendGroupedEntry(groupedEntry) {
+        const isStructured = this.config.structured ?? process.env.NODE_ENV === "production";
+        const formatOptions = {
+            redact: this.config.redaction?.enabled ?? process.env.NODE_ENV === "production",
+        };
+        const formatted = isStructured
+            ? formatGroupedProd(groupedEntry, formatOptions)
+            : formatGroupedDev(groupedEntry, formatOptions);
+        // Write formatted grouped entry directly to stdout/stderr
+        // This bypasses normal transport formatting since grouped entries are already formatted
+        const stream = groupedEntry.representative.level >= LogLevel.ERROR
+            ? process.stderr
+            : process.stdout;
+        stream.write(formatted);
+    }
+    /**
+     * Send a regular log entry to transports.
+     * @param entry - Log entry
+     */
+    sendEntry(entry) {
+        // Note: Entry is already added to query buffer before grouping
+        // This method only sends to transports
+        for (const transport of this.transports) {
+            if (transport.enabled) {
+                try {
+                    const result = transport.log(entry);
+                    if (result instanceof Promise) {
+                        // Fire and forget for async transports
+                        result.catch((err) => {
+                            // Silently fail to avoid log loops
+                            console.error(`[Logger] Transport ${transport.name} failed:`, err);
+                        });
+                    }
+                }
+                catch (err) {
+                    // Silently fail to avoid log loops
+                    console.error(`[Logger] Transport ${transport.name} failed:`, err);
+                }
+            }
+        }
+    }
+    /**
+     * Start a high-resolution timer.
+     * @param label - Label for this timer
+     * @param logLevel - Log level when timer ends (default: "debug")
+     * @returns Timer object with end() method
+     * @public API
+     *
+     * @example
+     * ```typescript
+     * const timer = logger.startTimer("database-query");
+     * // ... do work ...
+     * timer.end(); // Logs: "Timer 'database-query' completed in 45.23ms"
+     * ```
+     */
+    startTimer(label, logLevel = "debug") {
+        return new Timer(label, this, logLevel);
+    }
+    /**
+     * Get a metrics collector for tracking multiple operations.
+     * @returns PerformanceMetricsCollector instance
+     * @public API
+     *
+     * @example
+     * ```typescript
+     * const metrics = logger.metrics();
+     * metrics.start("db-query").end("db-query");
+     * metrics.start("api-call").end("api-call");
+     * metrics.summary(); // Logs detailed breakdown
+     * ```
+     */
+    metrics() {
+        return new PerformanceMetricsCollector(this);
+    }
+    /**
+     * Measure performance of an async function.
+     * @param fn - Async function to measure
+     * @param label - Label for this measurement
+     * @returns Promise with result and performance data
+     * @public API
+     *
+     * @example
+     * ```typescript
+     * const { result, performance } = await logger.measure(
+     *   async () => await fetchData(),
+     *   "fetch-data"
+     * );
+     * // Logs: "fetch-data took 123.45ms"
+     * ```
+     */
+    async measure(fn, label) {
+        return measurePerformance(fn, label, this);
+    }
+    /**
+     * Measure performance of a synchronous function.
+     * @param fn - Function to measure
+     * @param label - Label for this measurement
+     * @returns Result and performance data
+     * @public API
+     *
+     * @example
+     * ```typescript
+     * const { result, performance } = logger.measureSync(
+     *   () => processData(),
+     *   "process-data"
+     * );
+     * ```
+     */
+    measureSync(fn, label) {
+        return measurePerformanceSync(fn, label, this);
+    }
+    /**
+     * Flush all transports.
+     * @returns Promise that resolves when all transports are flushed
+     * @public API
+     */
+    async flush() {
+        const flushPromises = this.transports.map((transport) => {
+            if (transport.enabled && transport.flush) {
+                return transport.flush();
+            }
+            return Promise.resolve();
+        });
+        await Promise.all(flushPromises);
+    }
+    /**
+     * Close all transports.
+     * @returns Promise that resolves when all transports are closed
+     * @public API
+     */
+    async close() {
+        // Stop health monitoring
+        if (this.healthMonitor) {
+            this.healthMonitor.stop();
+            this.healthMonitor = null;
+        }
+        const closePromises = this.transports.map((transport) => {
+            if (transport.enabled && transport.close) {
+                return transport.close();
+            }
+            return Promise.resolve();
+        });
+        await Promise.all(closePromises);
+    }
+    /**
+     * Get current health status.
+     * @returns Current health status
+     * @public API
+     */
+    async getHealth() {
+        if (this.healthMonitor) {
+            return await this.healthMonitor.getCurrentHealth();
+        }
+        // If health monitor not initialized, collect status directly
+        return await collectHealthStatus();
+    }
+    /**
+     * Query logs from the in-memory buffer.
+     * @param options - Query options
+     * @returns Array of matching log entries
+     * @public API
+     */
+    queryLogs(options = {}) {
+        if (!this.queryManager) {
+            return [];
+        }
+        return this.queryManager.query(options);
+    }
+    /**
+     * Create a chainable query builder for logs.
+     * @returns LogQuery instance
+     * @public API
+     */
+    query() {
+        if (!this.queryManager) {
+            // Return empty query if query manager not enabled
+            return new LogQuery([]);
+        }
+        return this.queryManager.createQuery();
+    }
+    /**
+     * Get all logs from the buffer.
+     * @returns Array of all log entries
+     * @public API
+     */
+    getAllLogs() {
+        if (!this.queryManager) {
+            return [];
+        }
+        return this.queryManager.getAll();
+    }
+    /**
+     * Get statistics about logs in the buffer.
+     * @returns Log statistics
+     * @public API
+     */
+    getLogStats() {
+        if (!this.queryManager) {
+            return {
+                total: 0,
+                byLevel: {},
+                byContext: {},
+                oldest: null,
+                newest: null,
+            };
+        }
+        return this.queryManager.getStats();
+    }
+    /**
+     * Clear all logs from the query buffer.
+     * @public API
+     */
+    clearLogs() {
+        if (this.queryManager) {
+            this.queryManager.clear();
+        }
+    }
+    /**
+     * Export logs to markdown format.
+     * @param options - Export options
+     * @returns Markdown string
+     * @public API
+     */
+    exportLogsToMarkdown(options = {}) {
+        const entries = options.query
+            ? this.queryLogs(options.query)
+            : this.getAllLogs();
+        return exportToMarkdown(entries, {
+            title: options.title,
+            includeStats: options.includeStats,
+            groupBy: options.groupBy,
+        });
+    }
+    /**
+     * Start health monitoring (if configured).
+     * @public API
+     */
+    startHealthMonitoring() {
+        if (this.healthMonitor) {
+            this.healthMonitor.start();
+        }
+    }
+    /**
+     * Stop health monitoring.
+     * @public API
+     */
+    stopHealthMonitoring() {
+        if (this.healthMonitor) {
+            this.healthMonitor.stop();
+            this.healthMonitor = null;
+        }
+    }
+    /**
+     * Legacy formatMessage method for backward compatibility.
+     * @deprecated Use the new structured logging API instead
+     * @param logLevel - The level of the log
+     * @param message - The main log message
+     * @param module - Optional module name
+     * @returns The formatted log message
+     */
+    formatMessage(logLevel = "NONE", message, module) {
+        const level = parseLogLevel(logLevel);
+        const entry = createLogEntry(level, message, {
+            context: module,
+            pid: this.pid,
+        });
+        // Use dev formatter for legacy format
+        return formatDev(entry);
+    }
+};
+Logger = Logger_1 = __decorate([
+    provideSingleton(Logger, "builtin"),
+    __metadata("design:paramtypes", [])
+], Logger);
+export { Logger };