@wgtechlabs/log-engine 2.1.0 → 2.2.0

package/dist/esm/logger/config.js

@@ -0,0 +1,101 @@
+/**
+ * Logger configuration management
+ * Handles logger settings and configuration updates
+ */
+import { LogLevel, LogMode } from '../types/index.js';
+import { EnvironmentDetector } from './environment.js';
+/**
+ * Configuration manager for logger settings
+ * Handles configuration validation, updates, and backward compatibility
+ */
+export class LoggerConfigManager {
+    constructor() {
+        // Set initial configuration with environment-based auto-configuration
+        this.config = {
+            mode: EnvironmentDetector.getEnvironmentMode()
+        };
+    }
+    /**
+       * Get current configuration
+       * @returns Current logger configuration
+       */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+       * Updates logger configuration with new settings
+       * Merges provided config with existing settings (partial update)
+       * Supports backwards compatibility by mapping level to mode with deprecation warnings
+       * @param config - Partial configuration object to apply
+       */
+    updateConfig(config) {
+        // Handle backwards compatibility - if level is provided but mode is not
+        if (config.level !== undefined && config.mode === undefined) {
+            this.handleLegacyLevelConfig(config);
+        }
+        else {
+            // Normal configuration update
+            // If mode is present, remove legacy level property to avoid conflicts
+            if (config.mode !== undefined && config.level !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { level, ...configWithoutLevel } = config;
+                this.config = { ...this.config, ...configWithoutLevel };
+            }
+            else {
+                this.config = { ...this.config, ...config };
+            }
+        }
+    }
+    /**
+       * Handle legacy level-based configuration with deprecation warnings
+       * @param config - Configuration containing legacy level property
+       */
+    handleLegacyLevelConfig(config) {
+        // Map legacy level values to new LogMode values and validate first
+        const levelValue = config.level;
+        const mappedMode = this.mapLevelToMode(levelValue);
+        // Fail fast if the level value is invalid
+        if (mappedMode === undefined) {
+            throw new Error(`Invalid LogLevel value: ${config.level}. Valid values are: DEBUG(0), INFO(1), WARN(2), ERROR(3), LOG(99), or use LogMode instead.`);
+        }
+        // Only show deprecation warning after confirming the level is valid and in non-test environments
+        if (!EnvironmentDetector.isTestEnvironment()) {
+            this.createDeprecationWarning();
+        }
+        // Merge existing config with all keys from the passed config, and override mode with mapped value
+        // Remove the legacy 'level' property to avoid conflicts with the new 'mode' property
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { level, ...configWithoutLevel } = config;
+        this.config = { ...this.config, ...configWithoutLevel, mode: mappedMode };
+    }
+    /**
+       * Map legacy LogLevel values to LogMode values
+       * @param levelValue - Legacy level value
+       * @returns Corresponding LogMode or undefined if invalid
+       */
+    mapLevelToMode(levelValue) {
+        // Use switch statement to avoid object injection
+        switch (levelValue) {
+            case LogLevel.DEBUG: return LogMode.DEBUG; // 0 -> 0
+            case LogLevel.INFO: return LogMode.INFO; // 1 -> 1
+            case LogLevel.WARN: return LogMode.WARN; // 2 -> 2
+            case LogLevel.ERROR: return LogMode.ERROR; // 3 -> 3
+            case LogLevel.LOG: return LogMode.SILENT; // 99 -> 4 (preserves critical-only behavior)
+            case 4: return LogMode.SILENT; // Legacy SILENT -> 4
+            case 5: return LogMode.OFF; // Legacy OFF -> 5
+            default: return undefined;
+        }
+    }
+    /**
+       * Create deprecation warning message using LogFormatter
+       * Outputs formatted deprecation warning messages to console
+       */
+    createDeprecationWarning() {
+        // Import LogFormatter to format system messages properly
+        const { LogFormatter } = require('../formatter');
+        console.warn(LogFormatter.formatSystemMessage('⚠️  DEPRECATION WARNING: The "level" configuration is deprecated and will be removed in v3.0.0. Please use "mode" instead.'));
+        console.warn(LogFormatter.formatSystemMessage('   Migration: LogEngine.configure({ level: LogLevel.DEBUG }) → LogEngine.configure({ mode: LogMode.DEBUG })'));
+        console.warn(LogFormatter.formatSystemMessage('   See: https://github.com/wgtechlabs/log-engine#migration-guide-loglevel--logmode'));
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/esm/logger/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/logger/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAgB,QAAQ,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEpD;;;GAGG;AACH,MAAM,OAAO,mBAAmB;IAG9B;QACE,sEAAsE;QACtE,IAAI,CAAC,MAAM,GAAG;YACZ,IAAI,EAAE,mBAAmB,CAAC,kBAAkB,EAAE;SAC/C,CAAC;IACJ,CAAC;IAED;;;SAGK;IACL,SAAS;QACP,OAAO,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;IAC5B,CAAC;IAED;;;;;SAKK;IACL,YAAY,CAAC,MAA6B;QACxC,wEAAwE;QACxE,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC5D,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;QACvC,CAAC;aAAM,CAAC;YACN,8BAA8B;YAC9B,sEAAsE;YACtE,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC5D,6DAA6D;gBAC7D,MAAM,EAAE,KAAK,EAAE,GAAG,kBAAkB,EAAE,GAAG,MAAM,CAAC;gBAChD,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,kBAAkB,EAAE,CAAC;YAC1D,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;YAC9C,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;SAGK;IACG,uBAAuB,CAAC,MAA6B;QAC3D,mEAAmE;QACnE,MAAM,UAAU,GAAG,MAAM,CAAC,KAAe,CAAC;QAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;QAEnD,0CAA0C;QAC1C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,2BAA2B,MAAM,CAAC,KAAK,4FAA4F,CAAC,CAAC;QACvJ,CAAC;QAED,iGAAiG;QACjG,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,EAAE,EAAE,CAAC;YAC7C,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAClC,CAAC;QAED,kGAAkG;QAClG,qFAAqF;QACrF,6DAA6D;QAC7D,MAAM,EAAE,KAAK,EAAE,GAAG,kBAAkB,EAAE,GAAG,MAAM,CAAC;QAChD,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,kBAAkB,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;IAC5E,CAAC;IAED;;;;SAIK;IACG,cAAc,CAAC,UAAkB;QACvC,iDAAiD;QACjD,QAAQ,UAAU,EAAE,CAAC;YACrB,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,OAAO,CAAC,KAAK,CAAC,CAAM,SAAS;YACzD,KAAK,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,OAAO,CAAC,IAAI,CAAC,CAAQ,SAAS;YACzD,KAAK,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,OAAO,CAAC,IAAI,CAAC,CAAQ,SAAS;YACzD,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,OAAO,CAAC,KAAK,CAAC,CAAM,SAAS;YACzD,KAAK,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAO,6CAA6C;YAC7F,KAAK,CAAC,CAAC,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAkB,qBAAqB;YACrE,KAAK,CAAC,CAAC,CAAC,OAAO,OAAO,CAAC,GAAG,CAAC,CAAqB,kBAAkB;YAClE,OAAO,CAAC,CAAC,OAAO,SAAS,CAAC;QAC1B,CAAC;IACH,CAAC;IAED;;;SAGK;IACG,wBAAwB;QAC9B,yDAAyD;QACzD,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;QAEjD,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,4HAA4H,CAAC,CAAC,CAAC;QAC7K,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,6GAA6G,CAAC,CAAC,CAAC;QAC9J,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,oFAAoF,CAAC,CAAC,CAAC;IACvI,CAAC;CACF"}

package/dist/esm/logger/core.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Core Logger class that handles log message output with configurable levels
+ * Supports DEBUG, INFO, WARN, ERROR, and LOG levels with intelligent filtering
+ * LOG level always outputs regardless of configuration
+ * Uses colorized console output with timestamps for better readability
+ * Includes automatic data redaction for sensitive information
+ */
+import { LoggerConfig, LogData } from '../types';
+/**
+ * Logger class responsible for managing log output and configuration
+ * Provides mode-based filtering and formatted console output
+ */
+export declare class Logger {
+    private configManager;
+    private cachedConfig;
+    /**
+       * Logger constructor - sets up environment-based auto-configuration
+       */
+    constructor();
+    /**
+     * Get cached configuration or refresh cache if needed
+     * This avoids repeated getConfig() calls for better performance
+     */
+    private getCachedConfig;
+    /**
+     * Invalidate the configuration cache when configuration changes
+     */
+    private invalidateConfigCache;
+    /**
+     * Helper method to format log messages with cached configuration
+     * Reduces code duplication across all log methods
+     * @param level - The log level to format for
+     * @param message - The message content to format
+     * @param data - Optional data object to include in the log output
+     * @returns Formatted string with appropriate configuration applied
+     */
+    private formatMessage;
+    /**
+       * Built-in output handlers for common use cases
+       */
+    private getBuiltInHandler;
+    /**
+       * Process a single output target with error handling
+       * @param output - Single output target to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       * @param isEnhanced - Whether this is an enhanced output (supports configured handler objects)
+       */
+    private processSingleOutput;
+    /**
+       * Process multiple output targets
+       * @param outputs - Array of output targets to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       */
+    private processOutputs;
+    /**
+       * Process enhanced output targets
+       * @param enhancedOutputs - Array of enhanced output targets to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       */
+    private processEnhancedOutputs;
+    /**
+       * Updates logger configuration with new settings
+       * Also updates redaction configuration based on environment
+       * @param config - Partial configuration object to apply
+       */
+    configure(config: Partial<LoggerConfig>): void;
+    /**
+       * Get current logger configuration
+       * @returns Current logger configuration
+       */
+    getConfig(): LoggerConfig;
+    /**
+       * Determines if a message should be logged based on current log mode
+       * @param level - The log level of the message to check
+       * @returns true if message should be logged, false otherwise
+       */
+    private shouldLog;
+    /**
+       * Writes log output using configured output handler or default console methods
+       * Supports single output handler, multiple outputs, and enhanced outputs
+       * Priority: outputs > enhancedOutputs > outputHandler > default console
+       * @param level - The log level as a string
+       * @param rawMessage - The original unformatted message
+       * @param formattedMessage - The pre-formatted message to output
+       * @param data - Optional data object that was logged
+       * @param isError - Whether this is an error level message (for console.error)
+       * @param isWarn - Whether this is a warning level message (for console.warn)
+       */
+    private writeToOutput;
+    /**
+       * Log a debug message with DEBUG level formatting
+       * Uses console.log for output with purple/magenta coloring
+       * Automatically redacts sensitive data when provided
+       * @param message - The debug message to log
+       * @param data - Optional data object to log (will be redacted)
+       */
+    debug(message: string, data?: LogData): void;
+    /**
+       * Log an informational message with INFO level formatting
+       * Uses console.log for output with blue coloring
+       * Automatically redacts sensitive data when provided
+       * @param message - The info message to log
+       * @param data - Optional data object to log (will be redacted)
+       */
+    info(message: string, data?: LogData): void;
+    /**
+       * Log a warning message with WARN level formatting
+       * Uses console.warn for output with yellow coloring
+       * Automatically redacts sensitive data when provided
+       * @param message - The warning message to log
+       * @param data - Optional data object to log (will be redacted)
+       */
+    warn(message: string, data?: LogData): void;
+    /**
+       * Log an error message with ERROR level formatting
+       * Uses console.error for output with red coloring
+       * Automatically redacts sensitive data when provided
+       * @param message - The error message to log
+       * @param data - Optional data object to log (will be redacted)
+       */
+    error(message: string, data?: LogData): void;
+    /**
+       * Log a message with LOG level formatting (always outputs unless mode is OFF)
+       * Uses console.log for output with green coloring
+       * LOG level bypasses normal filtering and always outputs (except when OFF is set)
+       * Automatically redacts sensitive data when provided
+       * @param message - The log message to output
+       * @param data - Optional data object to log (will be redacted)
+       */
+    log(message: string, data?: LogData): void;
+    /**
+       * Log a debug message without data redaction
+       * @param message - The debug message to log
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    debugRaw(message: string, data?: LogData): void;
+    /**
+       * Log an info message without data redaction
+       * @param message - The info message to log
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    infoRaw(message: string, data?: LogData): void;
+    /**
+       * Log a warning message without data redaction
+       * @param message - The warning message to log
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    warnRaw(message: string, data?: LogData): void;
+    /**
+       * Log an error message without data redaction
+       * @param message - The error message to log
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    errorRaw(message: string, data?: LogData): void;
+    /**
+       * Log a message without data redaction (always outputs unless mode is OFF)
+       * @param message - The log message to output
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    logRaw(message: string, data?: LogData): void;
+}
+//# sourceMappingURL=core.d.ts.map

package/dist/esm/logger/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../src/logger/core.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAqB,YAAY,EAAwD,OAAO,EAAE,MAAM,UAAU,CAAC;AAO1H;;;GAGG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,YAAY,CAA6B;IAEjD;;SAEK;;IAKL;;;OAGG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAKrB;;SAEK;IAEL,OAAO,CAAC,iBAAiB;IAsCzB;;;;;;;;SAQK;IACL,OAAO,CAAC,mBAAmB;IA6C3B;;;;;;;SAOK;IACL,OAAO,CAAC,cAAc;IAMtB;;;;;;;SAOK;IACL,OAAO,CAAC,sBAAsB;IAM9B;;;;SAIK;IACL,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAa9C;;;SAGK;IACL,SAAS,IAAI,YAAY;IAIzB;;;;SAIK;IACL,OAAO,CAAC,SAAS;IAMjB;;;;;;;;;;SAUK;IACL,OAAO,CAAC,aAAa;IAkDrB;;;;;;SAMK;IACL,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAQ5C;;;;;;SAMK;IACL,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAQ3C;;;;;;SAMK;IACL,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAQ3C;;;;;;SAMK;IACL,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAQ5C;;;;;;;SAOK;IACL,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAS1C;;;;SAIK;IACL,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAO/C;;;;SAIK;IACL,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAO9C;;;;SAIK;IACL,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAO9C;;;;SAIK;IACL,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAO/C;;;;SAIK;IACL,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;CAM9C"}

package/dist/esm/logger/core.js

@@ -0,0 +1,398 @@
+/**
+ * Core Logger class that handles log message output with configurable levels
+ * Supports DEBUG, INFO, WARN, ERROR, and LOG levels with intelligent filtering
+ * LOG level always outputs regardless of configuration
+ * Uses colorized console output with timestamps for better readability
+ * Includes automatic data redaction for sensitive information
+ */
+import { LogLevel, LogMode } from '../types/index.js';
+import { LogFormatter } from '../formatter/index.js';
+import { DataRedactor, RedactionController, defaultRedactionConfig } from '../redaction/index.js';
+import { LoggerConfigManager } from './config.js';
+import { LogFilter } from './filtering.js';
+import { createBuiltInHandler } from './advanced-outputs.js';
+/**
+ * Logger class responsible for managing log output and configuration
+ * Provides mode-based filtering and formatted console output
+ */
+export class Logger {
+    /**
+       * Logger constructor - sets up environment-based auto-configuration
+       */
+    constructor() {
+        this.cachedConfig = null;
+        this.configManager = new LoggerConfigManager();
+    }
+    /**
+     * Get cached configuration or refresh cache if needed
+     * This avoids repeated getConfig() calls for better performance
+     */
+    getCachedConfig() {
+        if (this.cachedConfig === null) {
+            this.cachedConfig = this.configManager.getConfig();
+        }
+        return this.cachedConfig;
+    }
+    /**
+     * Invalidate the configuration cache when configuration changes
+     */
+    invalidateConfigCache() {
+        this.cachedConfig = null;
+    }
+    /**
+     * Helper method to format log messages with cached configuration
+     * Reduces code duplication across all log methods
+     * @param level - The log level to format for
+     * @param message - The message content to format
+     * @param data - Optional data object to include in the log output
+     * @returns Formatted string with appropriate configuration applied
+     */
+    formatMessage(level, message, data) {
+        const cachedConfig = this.getCachedConfig();
+        return LogFormatter.format(level, message, data, cachedConfig.format);
+    }
+    /**
+       * Built-in output handlers for common use cases
+       */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getBuiltInHandler(type, config) {
+        switch (type) {
+            case 'console':
+                return (level, message, data) => {
+                    // Use appropriate console method based on level
+                    if (level === 'error') {
+                        if (data !== undefined) {
+                            console.error(message, data);
+                        }
+                        else {
+                            console.error(message);
+                        }
+                    }
+                    else if (level === 'warn') {
+                        if (data !== undefined) {
+                            console.warn(message, data);
+                        }
+                        else {
+                            console.warn(message);
+                        }
+                    }
+                    else {
+                        if (data !== undefined) {
+                            console.log(message, data);
+                        }
+                        else {
+                            console.log(message);
+                        }
+                    }
+                };
+            case 'silent':
+                return () => {
+                    // Do nothing - silent output
+                };
+            case 'file':
+            case 'http':
+                // Use advanced output handlers for file and http
+                return createBuiltInHandler(type, config);
+            default:
+                return null;
+        }
+    }
+    /**
+       * Process a single output target with error handling
+       * @param output - Single output target to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       * @param isEnhanced - Whether this is an enhanced output (supports configured handler objects)
+       */
+    processSingleOutput(output, level, rawMessage, formattedMessage, data, isEnhanced = false) {
+        const config = this.configManager.getConfig();
+        try {
+            if (typeof output === 'string') {
+                // Built-in handler - get config if available
+                const outputConfig = config.advancedOutputConfig?.[output];
+                const handler = this.getBuiltInHandler(output, outputConfig);
+                if (handler) {
+                    // Advanced handlers (file, http) get raw message, console gets formatted
+                    const messageToUse = (output === 'file' || output === 'http') ? rawMessage : formattedMessage;
+                    handler(level, messageToUse, data);
+                }
+                else {
+                    console.error('[LogEngine] Unknown built-in output handler:', JSON.stringify(output));
+                }
+            }
+            else if (typeof output === 'function') {
+                // Custom function handler gets formatted message for backward compatibility
+                output(level, formattedMessage, data);
+            }
+            else if (isEnhanced && typeof output === 'object' && output.type && output.config) {
+                // Configured handler object (only available for enhanced outputs)
+                const handler = this.getBuiltInHandler(output.type, output.config);
+                if (handler) {
+                    // Advanced configured handlers get raw message
+                    handler(level, rawMessage, data);
+                }
+                else {
+                    console.error('[LogEngine] Unknown enhanced output handler type:', JSON.stringify(output));
+                }
+            }
+            else {
+                const outputType = isEnhanced ? 'enhanced output target' : 'output target';
+                console.error(`[LogEngine] Invalid ${outputType}:`, output);
+            }
+        }
+        catch (error) {
+            // Continue processing other outputs even if one fails
+            const handlerType = isEnhanced ? 'Enhanced output' : 'Output';
+            console.error(`[LogEngine] ${handlerType} handler failed: ${error}`);
+        }
+    }
+    /**
+       * Process multiple output targets
+       * @param outputs - Array of output targets to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       */
+    processOutputs(outputs, level, rawMessage, formattedMessage, data) {
+        for (const output of outputs) {
+            this.processSingleOutput(output, level, rawMessage, formattedMessage, data, false);
+        }
+    }
+    /**
+       * Process enhanced output targets
+       * @param enhancedOutputs - Array of enhanced output targets to process
+       * @param level - Log level
+       * @param rawMessage - Original unformatted message
+       * @param formattedMessage - Formatted message for console-based outputs
+       * @param data - Optional data
+       */
+    processEnhancedOutputs(enhancedOutputs, level, rawMessage, formattedMessage, data) {
+        for (const output of enhancedOutputs) {
+            this.processSingleOutput(output, level, rawMessage, formattedMessage, data, true);
+        }
+    }
+    /**
+       * Updates logger configuration with new settings
+       * Also updates redaction configuration based on environment
+       * @param config - Partial configuration object to apply
+       */
+    configure(config) {
+        this.configManager.updateConfig(config);
+        // Invalidate configuration cache since config has changed
+        this.invalidateConfigCache();
+        // Update redaction configuration based on current environment
+        DataRedactor.updateConfig({
+            ...defaultRedactionConfig,
+            ...RedactionController.getEnvironmentConfig()
+        });
+    }
+    /**
+       * Get current logger configuration
+       * @returns Current logger configuration
+       */
+    getConfig() {
+        return this.configManager.getConfig();
+    }
+    /**
+       * Determines if a message should be logged based on current log mode
+       * @param level - The log level of the message to check
+       * @returns true if message should be logged, false otherwise
+       */
+    shouldLog(level) {
+        const currentConfig = this.configManager.getConfig();
+        const currentMode = currentConfig.mode !== undefined ? currentConfig.mode : LogMode.INFO;
+        return LogFilter.shouldLog(level, currentMode);
+    }
+    /**
+       * Writes log output using configured output handler or default console methods
+       * Supports single output handler, multiple outputs, and enhanced outputs
+       * Priority: outputs > enhancedOutputs > outputHandler > default console
+       * @param level - The log level as a string
+       * @param rawMessage - The original unformatted message
+       * @param formattedMessage - The pre-formatted message to output
+       * @param data - Optional data object that was logged
+       * @param isError - Whether this is an error level message (for console.error)
+       * @param isWarn - Whether this is a warning level message (for console.warn)
+       */
+    writeToOutput(level, rawMessage, formattedMessage, data, isError = false, isWarn = false) {
+        const config = this.configManager.getConfig();
+        // Multiple outputs support (highest priority - newer API)
+        if (config.outputs !== undefined) {
+            if (config.outputs.length > 0) {
+                // Process outputs array when it has actual outputs
+                this.processOutputs(config.outputs, level, rawMessage, formattedMessage, data);
+            }
+            // If outputs is explicitly set to empty array, disable all logging
+            return;
+        }
+        // Enhanced outputs with advanced configuration (second priority)
+        if (config.enhancedOutputs !== undefined && config.enhancedOutputs.length > 0) {
+            this.processEnhancedOutputs(config.enhancedOutputs, level, rawMessage, formattedMessage, data);
+            return;
+        }
+        // Single output handler (third priority - legacy compatibility)
+        if (config.outputHandler) {
+            try {
+                config.outputHandler(level, formattedMessage, data);
+            }
+            catch (error) {
+                // Fallback to console if custom handler fails
+                console.error(`[LogEngine] Output handler failed: ${error}. Falling back to console.`);
+                if (isError) {
+                    console.error(formattedMessage);
+                }
+                else if (isWarn) {
+                    console.warn(formattedMessage);
+                }
+                else {
+                    console.log(formattedMessage);
+                }
+            }
+            return;
+        }
+        // Default: Console output (unless suppressed)
+        if (!config.suppressConsoleOutput) {
+            if (isError) {
+                console.error(formattedMessage);
+            }
+            else if (isWarn) {
+                console.warn(formattedMessage);
+            }
+            else {
+                console.log(formattedMessage);
+            }
+        }
+        // If suppressConsoleOutput is true and no outputHandler/outputs, do nothing (silent)
+    }
+    /**
+       * Log a debug message with DEBUG level formatting
+       * Uses console.log for output with purple/magenta coloring
+       * Automatically redacts sensitive data when provided
+       * @param message - The debug message to log
+       * @param data - Optional data object to log (will be redacted)
+       */
+    debug(message, data) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            const processedData = DataRedactor.redactData(data);
+            const formatted = this.formatMessage(LogLevel.DEBUG, message, processedData);
+            this.writeToOutput('debug', message, formatted, processedData);
+        }
+    }
+    /**
+       * Log an informational message with INFO level formatting
+       * Uses console.log for output with blue coloring
+       * Automatically redacts sensitive data when provided
+       * @param message - The info message to log
+       * @param data - Optional data object to log (will be redacted)
+       */
+    info(message, data) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            const processedData = DataRedactor.redactData(data);
+            const formatted = this.formatMessage(LogLevel.INFO, message, processedData);
+            this.writeToOutput('info', message, formatted, processedData);
+        }
+    }
+    /**
+       * Log a warning message with WARN level formatting
+       * Uses console.warn for output with yellow coloring
+       * Automatically redacts sensitive data when provided
+       * @param message - The warning message to log
+       * @param data - Optional data object to log (will be redacted)
+       */
+    warn(message, data) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            const processedData = DataRedactor.redactData(data);
+            const formatted = this.formatMessage(LogLevel.WARN, message, processedData);
+            this.writeToOutput('warn', message, formatted, processedData, false, true);
+        }
+    }
+    /**
+       * Log an error message with ERROR level formatting
+       * Uses console.error for output with red coloring
+       * Automatically redacts sensitive data when provided
+       * @param message - The error message to log
+       * @param data - Optional data object to log (will be redacted)
+       */
+    error(message, data) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            const processedData = DataRedactor.redactData(data);
+            const formatted = this.formatMessage(LogLevel.ERROR, message, processedData);
+            this.writeToOutput('error', message, formatted, processedData, true, false);
+        }
+    }
+    /**
+       * Log a message with LOG level formatting (always outputs unless mode is OFF)
+       * Uses console.log for output with green coloring
+       * LOG level bypasses normal filtering and always outputs (except when OFF is set)
+       * Automatically redacts sensitive data when provided
+       * @param message - The log message to output
+       * @param data - Optional data object to log (will be redacted)
+       */
+    log(message, data) {
+        if (this.shouldLog(LogLevel.LOG)) {
+            const processedData = DataRedactor.redactData(data);
+            const formatted = this.formatMessage(LogLevel.LOG, message, processedData);
+            this.writeToOutput('log', message, formatted, processedData);
+        }
+    }
+    // Raw logging methods (bypass redaction for debugging)
+    /**
+       * Log a debug message without data redaction
+       * @param message - The debug message to log
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    debugRaw(message, data) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            const formatted = this.formatMessage(LogLevel.DEBUG, message, data);
+            this.writeToOutput('debug', message, formatted, data);
+        }
+    }
+    /**
+       * Log an info message without data redaction
+       * @param message - The info message to log
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    infoRaw(message, data) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            const formatted = this.formatMessage(LogLevel.INFO, message, data);
+            this.writeToOutput('info', message, formatted, data);
+        }
+    }
+    /**
+       * Log a warning message without data redaction
+       * @param message - The warning message to log
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    warnRaw(message, data) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            const formatted = this.formatMessage(LogLevel.WARN, message, data);
+            this.writeToOutput('warn', message, formatted, data, false, true);
+        }
+    }
+    /**
+       * Log an error message without data redaction
+       * @param message - The error message to log
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    errorRaw(message, data) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            const formatted = this.formatMessage(LogLevel.ERROR, message, data);
+            this.writeToOutput('error', message, formatted, data, true, false);
+        }
+    }
+    /**
+       * Log a message without data redaction (always outputs unless mode is OFF)
+       * @param message - The log message to output
+       * @param data - Optional data object to log (no redaction applied)
+       */
+    logRaw(message, data) {
+        if (this.shouldLog(LogLevel.LOG)) {
+            const formatted = this.formatMessage(LogLevel.LOG, message, data);
+            this.writeToOutput('log', message, formatted, data);
+        }
+    }
+}
+//# sourceMappingURL=core.js.map