@morojs/moro 1.6.0 → 1.6.1

package/dist/core/logger/logger.js

@@ -1,6 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFrameworkLogger = exports.logger = exports.MoroLogger = void 0;
+exports.configureGlobalLogger = configureGlobalLogger;
+exports.applyLoggingConfiguration = applyLoggingConfiguration;
 // Moro Logger - Beautiful, Fast, Feature-Rich
-import { performance } from 'perf_hooks';
-export class MoroLogger {
+const perf_hooks_1 = require("perf_hooks");
+class MoroLogger {
     level = 'info';
     options;
     outputs = new Map();
@@ -27,23 +32,12 @@ export class MoroLogger {
     cachedTimestamp = '';
     lastTimestamp = 0;
     timestampCacheInterval = 100; // 100ms for better precision
-    // Object pooling for LogEntry objects (Pino's technique)
-    static ENTRY_POOL = [];
-    static MAX_POOL_SIZE = 100;
-    static poolIndex = 0;
-    // String builder for efficient concatenation
-    static stringBuilder = [];
-    static stringBuilderIndex = 0;
-    // Buffered output for performance
+    // Buffered output for micro-batching
     outputBuffer = [];
     bufferSize = 0;
-    maxBufferSize = 1000;
+    maxBufferSize = 1024; // 1KB buffer
     flushTimeout = null;
     flushInterval = 1; // 1ms micro-batching
-    // Buffer overflow protection
-    bufferOverflowThreshold;
-    emergencyFlushInProgress = false;
-    isDestroyed = false;
     // High-performance output methods
     static LEVELS = {
         debug: 0,
@@ -52,6 +46,76 @@ export class MoroLogger {
         error: 3,
         fatal: 4,
     };
+    // Static pre-allocated strings for maximum performance
+    static LEVEL_STRINGS = {
+        debug: 'DEBUG',
+        info: 'INFO',
+        warn: 'WARN',
+        error: 'ERROR',
+        fatal: 'FATAL',
+    };
+    // Pre-allocated ANSI color codes
+    static ANSI_COLORS = {
+        reset: '\x1b[0m',
+        bold: '\x1b[1m',
+        dim: '\x1b[2m',
+        red: '\x1b[31m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        magenta: '\x1b[35m',
+        cyan: '\x1b[36m',
+        white: '\x1b[37m',
+        gray: '\x1b[90m',
+    };
+    // Object pool for LogEntry reuse
+    static ENTRY_POOL = [];
+    static MAX_POOL_SIZE = 100;
+    static poolIndex = 0;
+    // Object pool management
+    static getPooledEntry() {
+        if (MoroLogger.poolIndex > 0) {
+            return MoroLogger.ENTRY_POOL[--MoroLogger.poolIndex];
+        }
+        return {
+            timestamp: new Date(),
+            level: 'info',
+            message: '',
+            context: undefined,
+            metadata: undefined,
+        };
+    }
+    static returnPooledEntry(entry) {
+        if (MoroLogger.poolIndex < MoroLogger.MAX_POOL_SIZE) {
+            // Reset the entry
+            entry.timestamp = new Date();
+            entry.level = 'info';
+            entry.message = '';
+            entry.context = undefined;
+            entry.metadata = undefined;
+            MoroLogger.ENTRY_POOL[MoroLogger.poolIndex++] = entry;
+        }
+    }
+    // String builder for efficient concatenation
+    static stringBuilder = [];
+    static stringBuilderIndex = 0;
+    static resetStringBuilder() {
+        MoroLogger.stringBuilderIndex = 0;
+    }
+    static appendToBuilder(str) {
+        if (MoroLogger.stringBuilderIndex < MoroLogger.stringBuilder.length) {
+            MoroLogger.stringBuilder[MoroLogger.stringBuilderIndex++] = str;
+        }
+        else {
+            MoroLogger.stringBuilder.push(str);
+            MoroLogger.stringBuilderIndex++;
+        }
+    }
+    static buildString() {
+        const result = MoroLogger.stringBuilder.slice(0, MoroLogger.stringBuilderIndex).join('');
+        MoroLogger.resetStringBuilder();
+        return result;
+    }
     static COLORS = {
         debug: '\x1b[36m', // Cyan
         info: '\x1b[32m', // Green
@@ -62,20 +126,11 @@ export class MoroLogger {
         context: '\x1b[34m', // Blue
         metadata: '\x1b[37m', // White
         performance: '\x1b[36m', // Cyan
-        reset: '\x1b[0m', // Reset
     };
     static RESET = '\x1b[0m';
     static BOLD = '\x1b[1m';
-    // Static pre-allocated strings for performance
-    static LEVEL_STRINGS = {
-        debug: 'DEBUG',
-        info: 'INFO ',
-        warn: 'WARN ',
-        error: 'ERROR',
-        fatal: 'FATAL',
-    };
     constructor(options = {}) {
-        this.options = this.validateOptions({
+        this.options = {
             level: 'info',
             enableColors: true,
             enableTimestamp: true,
@@ -86,14 +141,9 @@ export class MoroLogger {
             outputs: [],
             filters: [],
             maxEntries: 1000,
-            maxBufferSize: 1000,
             ...options,
-        });
+        };
         this.level = this.options.level || 'info';
-        // Initialize buffer size from options
-        this.maxBufferSize = this.options.maxBufferSize || 1000;
-        // Initialize buffer overflow protection
-        this.bufferOverflowThreshold = this.maxBufferSize * 2;
         // Add default console output
         this.addOutput({
             name: 'console',
@@ -104,52 +154,6 @@ export class MoroLogger {
         this.options.outputs?.forEach(output => this.addOutput(output));
         this.options.filters?.forEach(filter => this.addFilter(filter));
     }
-    // Object pooling methods
-    static getPooledEntry() {
-        if (MoroLogger.ENTRY_POOL.length > 0) {
-            const entry = MoroLogger.ENTRY_POOL.pop();
-            // Properly reset ALL properties to prevent memory leaks
-            entry.timestamp = new Date();
-            entry.level = 'info';
-            entry.message = '';
-            entry.context = undefined;
-            entry.metadata = undefined;
-            entry.performance = undefined;
-            entry.moduleId = undefined;
-            return entry;
-        }
-        return MoroLogger.createFreshEntry();
-    }
-    // ADD this new method:
-    static createFreshEntry() {
-        return {
-            timestamp: new Date(),
-            level: 'info',
-            message: '',
-            context: undefined,
-            metadata: undefined,
-            performance: undefined,
-            moduleId: undefined,
-        };
-    }
-    static returnPooledEntry(entry) {
-        if (MoroLogger.ENTRY_POOL.length < MoroLogger.MAX_POOL_SIZE) {
-            MoroLogger.ENTRY_POOL.push(entry);
-        }
-    }
-    // String builder methods
-    static resetStringBuilder() {
-        MoroLogger.stringBuilder.length = 0;
-        MoroLogger.stringBuilderIndex = 0;
-    }
-    static appendToBuilder(str) {
-        MoroLogger.stringBuilder[MoroLogger.stringBuilderIndex++] = str;
-    }
-    static buildString() {
-        const result = MoroLogger.stringBuilder.join('');
-        MoroLogger.resetStringBuilder();
-        return result;
-    }
     debug(message, context, metadata) {
         this.log('debug', message, context, metadata);
     }
@@ -170,12 +174,12 @@ export class MoroLogger {
         this.log('fatal', msg, context, { ...metadata, stack });
     }
     time(label) {
-        this.timers.set(label, performance.now());
+        this.timers.set(label, perf_hooks_1.performance.now());
     }
     timeEnd(label, context, metadata) {
         const startTime = this.timers.get(label);
         if (startTime !== undefined) {
-            const duration = performance.now() - startTime;
+            const duration = perf_hooks_1.performance.now() - startTime;
             this.timers.delete(label);
             this.log('info', `Timer: ${label}`, context, {
                 ...metadata,
@@ -184,9 +188,7 @@ export class MoroLogger {
         }
     }
     child(context, metadata) {
-        // Create child logger with current parent level (not original options level)
-        const childOptions = { ...this.options, level: this.level };
-        const childLogger = new MoroLogger(childOptions);
+        const childLogger = new MoroLogger(this.options);
         childLogger.contextPrefix = this.contextPrefix ? `${this.contextPrefix}:${context}` : context;
         childLogger.contextMetadata = { ...this.contextMetadata, ...metadata };
         childLogger.outputs = this.outputs;
@@ -198,9 +200,6 @@ export class MoroLogger {
     setLevel(level) {
         this.level = level;
     }
-    getLevel() {
-        return this.level;
-    }
     addOutput(output) {
         this.outputs.set(output.name, output);
     }
@@ -243,16 +242,6 @@ export class MoroLogger {
         }
         return this.cachedTimestamp;
     }
-    // Cached timestamp generation (updates once per second)
-    getFastCachedTimestamp() {
-        const now = Date.now();
-        if (now - this.lastTimestamp > 1000) {
-            // Update every second
-            this.lastTimestamp = now;
-            this.cachedTimestamp = new Date(now).toISOString().slice(0, 19).replace('T', ' ');
-        }
-        return this.cachedTimestamp;
-    }
     getMetrics() {
         const now = Date.now();
         const uptime = (now - this.startTime) / 1000; // seconds
@@ -277,38 +266,47 @@ export class MoroLogger {
             memoryUsage: 0,
         };
     }
-    // Optimized logging method
+    // Optimized logging method with aggressive level checking
     log(level, message, context, metadata) {
-        // Prevent logging after destroy() is called (important for test cleanup)
-        if (this.isDestroyed) {
-            return;
-        }
-        // Quick level check - use parent level if available (for child loggers)
-        const effectiveLevel = this.parent ? this.parent.level : this.level;
-        if (MoroLogger.LEVELS[level] < MoroLogger.LEVELS[effectiveLevel]) {
-            return;
-        }
-        // Absolute minimal path for simple logs - pure speed
+        // AGGRESSIVE LEVEL CHECK - numeric comparison for maximum speed
+        const levelNum = MoroLogger.LEVELS[level];
+        const effectiveLevelNum = this.parent
+            ? MoroLogger.LEVELS[this.parent.level]
+            : MoroLogger.LEVELS[this.level];
+        if (levelNum < effectiveLevelNum) {
+            return; // Exit immediately if level is too low
+        }
+        // ULTRA-FAST PATH: Just message, no context, no metadata
         if (!metadata && !context && !this.contextPrefix && !this.contextMetadata) {
-            this.writeSimpleLog(level, message);
+            const levelStr = MoroLogger.LEVEL_STRINGS[level];
+            this.output(`${levelStr} ${message}\n`, level);
             return;
         }
-        // Minimal path for logs with context but no metadata
+        // FAST PATH: Message + context, no metadata
         if (!metadata && !this.contextMetadata) {
-            this.writeSimpleLog(level, message, context);
+            const levelStr = MoroLogger.LEVEL_STRINGS[level];
+            if (context) {
+                this.output(`${levelStr} [${context}] ${message}\n`, level);
+            }
+            else {
+                this.output(`${levelStr} ${message}\n`, level);
+            }
             return;
         }
-        // Path for complex logs
-        if (metadata && Object.keys(metadata).length > 0) {
-            this.complexLog(level, message, context, metadata);
+        // MEDIUM PATH: Message + context + simple metadata
+        if (metadata && Object.keys(metadata).length <= 3 && !this.contextMetadata) {
+            const levelStr = MoroLogger.LEVEL_STRINGS[level];
+            const contextStr = context ? `[${context}] ` : '';
+            const metaStr = this.stringify(metadata);
+            this.output(`${levelStr} ${contextStr}${message} ${metaStr}\n`, level);
             return;
         }
-        // Full logging path for complex logs
+        // FULL PATH: All features enabled
         this.fullLog(level, message, context, metadata);
     }
-    // Full logging with all features
+    // Full logging with all features using object pooling
     fullLog(level, message, context, metadata) {
-        // Use object pooling for LogEntry (Pino's technique)
+        // Get pooled entry to avoid allocation
         const entry = MoroLogger.getPooledEntry();
         const now = Date.now();
         entry.timestamp = new Date(now);
@@ -325,7 +323,6 @@ export class MoroLogger {
         if (this.filters.size > 0) {
             for (const filter of this.filters.values()) {
                 if (!filter.filter(entry)) {
-                    MoroLogger.returnPooledEntry(entry);
                     return;
                 }
             }
@@ -336,76 +333,8 @@ export class MoroLogger {
         this.addToHistory(entry);
         // Write to outputs with batched processing
         this.writeToOutputs(entry, level);
-        // Return entry to pool
-        MoroLogger.returnPooledEntry(entry);
-    }
-    // Absolute minimal logging - pure speed, no overhead
-    complexLog(level, message, context, metadata) {
-        // Use object pooling for LogEntry (Pino's technique)
-        const entry = MoroLogger.getPooledEntry();
-        const now = Date.now();
-        entry.timestamp = new Date(now);
-        entry.level = level;
-        entry.message = message;
-        entry.context = this.contextPrefix
-            ? context
-                ? `${this.contextPrefix}:${context}`
-                : this.contextPrefix
-            : context;
-        entry.metadata = this.createMetadata(metadata);
-        entry.performance = this.options.enablePerformance ? this.getPerformanceData(now) : undefined;
-        // Write to outputs with batched processing
-        this.writeToOutputs(entry, level);
-        // Return entry to pool
-        MoroLogger.returnPooledEntry(entry);
-    }
-    // Simple log writer with colors for minimal overhead cases
-    writeSimpleLog(level, message, context) {
-        const colors = this.options.enableColors !== false;
-        const levelReset = colors ? MoroLogger.RESET : '';
-        MoroLogger.resetStringBuilder();
-        // Timestamp with caching optimization
-        if (this.options.enableTimestamp !== false) {
-            const timestamp = this.getFastCachedTimestamp();
-            if (colors) {
-                MoroLogger.appendToBuilder(MoroLogger.COLORS.timestamp);
-                MoroLogger.appendToBuilder(timestamp);
-                MoroLogger.appendToBuilder(levelReset);
-            }
-            else {
-                MoroLogger.appendToBuilder(timestamp);
-            }
-            MoroLogger.appendToBuilder(' ');
-        }
-        // Level with pre-allocated strings
-        const levelStr = MoroLogger.LEVEL_STRINGS[level];
-        if (colors) {
-            MoroLogger.appendToBuilder(MoroLogger.COLORS[level]);
-            MoroLogger.appendToBuilder(MoroLogger.BOLD);
-            MoroLogger.appendToBuilder(levelStr);
-            MoroLogger.appendToBuilder(levelReset);
-        }
-        else {
-            MoroLogger.appendToBuilder(levelStr);
-        }
-        // Context
-        if (context && this.options.enableContext !== false) {
-            MoroLogger.appendToBuilder(' ');
-            if (colors) {
-                MoroLogger.appendToBuilder(MoroLogger.COLORS.context);
-                MoroLogger.appendToBuilder(`[${context}]`);
-                MoroLogger.appendToBuilder(levelReset);
-            }
-            else {
-                MoroLogger.appendToBuilder(`[${context}]`);
-            }
-        }
-        // Message
-        MoroLogger.appendToBuilder(' ');
-        MoroLogger.appendToBuilder(message);
-        // Output main log line with high-performance method
-        const finalMessage = MoroLogger.buildString();
-        this.output(`${finalMessage}\n`, level);
+        // Return entry to pool after a short delay to allow async operations
+        setTimeout(() => MoroLogger.returnPooledEntry(entry), 0);
     }
     updateMetrics(entry) {
         this.metrics.totalLogs++;
@@ -453,35 +382,23 @@ export class MoroLogger {
     writeToOutputs(entry, level) {
         if (this.outputs.size === 0)
             return;
-        let successCount = 0;
-        const errors = [];
         for (const output of this.outputs.values()) {
             if (!output.level || MoroLogger.LEVELS[level] >= MoroLogger.LEVELS[output.level]) {
                 try {
                     output.write(entry);
-                    successCount++;
                 }
                 catch (error) {
-                    errors.push({ outputName: output.name, error });
-                    this.handleOutputError(output.name, error);
+                    // Fallback to console.error for logger errors
+                    // eslint-disable-next-line no-console
+                    console.error('Logger output error:', error);
                 }
             }
         }
-        // If all outputs fail, use emergency console
-        if (successCount === 0 && this.outputs.size > 0) {
-            this.emergencyConsoleWrite(entry);
-        }
-        // Log output errors (but avoid infinite loops)
-        if (errors.length > 0 && level !== 'error') {
-            this.error(`Logger output errors: ${errors.length} failed`, 'MoroLogger', {
-                errors: errors.map(e => e.outputName),
-            });
-        }
     }
     writeToConsole(entry) {
         const format = this.options.format || 'pretty';
         if (format === 'json') {
-            this.output(`${this.safeStringify(entry)}\n`, entry.level);
+            this.output(JSON.stringify(entry) + '\n', entry.level);
             return;
         }
         if (format === 'compact') {
@@ -495,7 +412,6 @@ export class MoroLogger {
     }
     writePrettyLog(entry) {
         const colors = this.options.enableColors !== false;
-        const levelReset = colors ? MoroLogger.RESET : '';
         MoroLogger.resetStringBuilder();
         // Timestamp with caching optimization
         if (this.options.enableTimestamp !== false) {
@@ -503,29 +419,35 @@ export class MoroLogger {
             if (colors) {
                 MoroLogger.appendToBuilder(MoroLogger.COLORS.timestamp);
                 MoroLogger.appendToBuilder(timestamp);
-                MoroLogger.appendToBuilder(levelReset);
+                MoroLogger.appendToBuilder(MoroLogger.RESET);
             }
             else {
                 MoroLogger.appendToBuilder(timestamp);
             }
+        }
+        // Level with color using pre-allocated strings
+        const levelColor = colors ? MoroLogger.COLORS[entry.level] : '';
+        const levelReset = colors ? MoroLogger.RESET : '';
+        const levelText = MoroLogger.LEVEL_STRINGS[entry.level];
+        // Add space after timestamp if present
+        if (this.options.enableTimestamp !== false) {
             MoroLogger.appendToBuilder(' ');
         }
-        // Level with pre-allocated strings
-        const levelStr = MoroLogger.LEVEL_STRINGS[entry.level];
         if (colors) {
-            MoroLogger.appendToBuilder(MoroLogger.COLORS[entry.level]);
+            MoroLogger.appendToBuilder(levelColor);
             MoroLogger.appendToBuilder(MoroLogger.BOLD);
-            MoroLogger.appendToBuilder(levelStr);
+            MoroLogger.appendToBuilder(levelText);
             MoroLogger.appendToBuilder(levelReset);
         }
         else {
-            MoroLogger.appendToBuilder(levelStr);
+            MoroLogger.appendToBuilder(levelText);
         }
         // Context
         if (entry.context && this.options.enableContext !== false) {
-            MoroLogger.appendToBuilder(' ');
+            const contextColor = colors ? MoroLogger.COLORS.context : '';
+            MoroLogger.appendToBuilder(' '); // Space before context
             if (colors) {
-                MoroLogger.appendToBuilder(MoroLogger.COLORS.context);
+                MoroLogger.appendToBuilder(contextColor);
                 MoroLogger.appendToBuilder(`[${entry.context}]`);
                 MoroLogger.appendToBuilder(levelReset);
             }
@@ -534,7 +456,7 @@ export class MoroLogger {
             }
         }
         // Message
-        MoroLogger.appendToBuilder(' ');
+        MoroLogger.appendToBuilder(' '); // Space before message
         MoroLogger.appendToBuilder(entry.message);
         // Performance info
         if (entry.performance && this.options.enablePerformance !== false) {
@@ -547,7 +469,7 @@ export class MoroLogger {
                 perfParts.push(`${Math.round(entry.performance.memory)}MB`);
             }
             if (perfParts.length > 0) {
-                MoroLogger.appendToBuilder(' ');
+                MoroLogger.appendToBuilder(' '); // Space before performance info
                 if (colors) {
                     MoroLogger.appendToBuilder(perfColor);
                     MoroLogger.appendToBuilder(`(${perfParts.join(', ')})`);
@@ -565,20 +487,19 @@ export class MoroLogger {
             const metaColor = colors ? MoroLogger.COLORS.metadata : '';
             const cleanMetadata = this.cleanMetadata(entry.metadata);
             if (Object.keys(cleanMetadata).length > 0) {
-                MoroLogger.appendToBuilder(' ');
                 if (colors) {
                     MoroLogger.appendToBuilder(metaColor);
-                    MoroLogger.appendToBuilder(this.safeStringify(cleanMetadata));
+                    MoroLogger.appendToBuilder(this.stringify(cleanMetadata));
                     MoroLogger.appendToBuilder(levelReset);
                 }
                 else {
-                    MoroLogger.appendToBuilder(this.safeStringify(cleanMetadata));
+                    MoroLogger.appendToBuilder(this.stringify(cleanMetadata));
                 }
             }
         }
         // Output main log line with high-performance method
         const finalMessage = MoroLogger.buildString();
-        this.output(`${finalMessage}\n`, entry.level);
+        this.output(finalMessage + '\n', entry.level);
         // Stack trace for errors
         if (entry.metadata?.stack && (entry.level === 'error' || entry.level === 'fatal')) {
             const stackColor = colors ? MoroLogger.COLORS.error : '';
@@ -595,181 +516,77 @@ export class MoroLogger {
         }
         return clean;
     }
-    // High-performance output with buffering
-    output(message, level = 'info') {
-        // Prevent memory exhaustion
-        if (this.outputBuffer.length >= this.bufferOverflowThreshold &&
-            !this.emergencyFlushInProgress) {
-            this.emergencyFlushInProgress = true;
-            this.forceFlushBuffer();
-            this.emergencyFlushInProgress = false;
+    // Fast JSON stringify with error handling
+    stringify(obj) {
+        try {
+            return JSON.stringify(obj);
         }
+        catch {
+            return '[Circular Reference]';
+        }
+    }
+    // High-performance output with micro-batching
+    output(message, level = 'info') {
+        // Add to buffer
         this.outputBuffer.push(message);
-        this.bufferSize++;
-        // Immediate flush for critical levels or full buffer
-        if (level === 'fatal' || level === 'error' || this.bufferSize >= this.maxBufferSize) {
+        this.bufferSize += message.length;
+        // Flush immediately if buffer is full or for errors
+        if (this.bufferSize >= this.maxBufferSize || level === 'error' || level === 'fatal') {
             this.flushBuffer();
         }
         else {
+            // Schedule flush with micro-batching
             this.scheduleFlush();
         }
     }
     scheduleFlush() {
-        if (this.flushTimeout || this.isDestroyed) {
-            return; // Already scheduled or destroyed
-        }
+        if (this.flushTimeout)
+            return; // Already scheduled
         this.flushTimeout = setTimeout(() => {
             this.flushBuffer();
+            this.flushTimeout = null;
         }, this.flushInterval);
-        // Unref the timeout so it doesn't prevent process exit (important for tests)
-        this.flushTimeout.unref();
     }
     flushBuffer() {
-        if (this.outputBuffer.length === 0) {
+        if (this.outputBuffer.length === 0)
             return;
-        }
-        // Group messages by stream type
-        const stdoutMessages = [];
-        const stderrMessages = [];
-        for (const message of this.outputBuffer) {
-            // Determine stream based on message content or level
-            if (message.includes('ERROR') || message.includes('FATAL')) {
-                stderrMessages.push(message);
-            }
-            else {
-                stdoutMessages.push(message);
-            }
-        }
-        // Write to appropriate streams with error handling
         try {
-            if (stdoutMessages.length > 0 && process.stdout.writable) {
+            // Group by stream type for efficiency
+            const stdoutMessages = [];
+            const stderrMessages = [];
+            for (const message of this.outputBuffer) {
+                // Determine stream based on message content (simple heuristic)
+                if (message.includes('ERROR') || message.includes('FATAL')) {
+                    stderrMessages.push(message);
+                }
+                else {
+                    stdoutMessages.push(message);
+                }
+            }
+            // Write to streams
+            if (stdoutMessages.length > 0) {
                 process.stdout.write(stdoutMessages.join(''));
             }
-            if (stderrMessages.length > 0 && process.stderr.writable) {
+            if (stderrMessages.length > 0) {
                 process.stderr.write(stderrMessages.join(''));
             }
         }
         catch {
-            // Fallback to console if streams fail
-            try {
-                // eslint-disable-next-line no-console
-                console.log(this.outputBuffer.join(''));
-            }
-            catch {
-                // If even console.log fails, just ignore
-            }
-        }
-        // Clear buffer
-        this.outputBuffer.length = 0;
-        this.bufferSize = 0;
-        // Clear timeout
-        if (this.flushTimeout) {
-            clearTimeout(this.flushTimeout);
-            this.flushTimeout = null;
-        }
-    }
-    // Emergency flush for buffer overflow protection
-    forceFlushBuffer() {
-        if (this.outputBuffer.length === 0)
-            return;
-        try {
-            const message = this.outputBuffer.join('');
-            process.stdout.write(message);
-        }
-        catch (error) {
-            // Emergency fallback - write individual messages
-            for (const msg of this.outputBuffer) {
-                try {
-                    process.stdout.write(msg);
-                }
-                catch {
-                    // If even this fails, give up on this batch
-                    break;
+            // Fallback to console methods if stream write fails
+            for (const message of this.outputBuffer) {
+                if (message.includes('ERROR') || message.includes('FATAL')) {
+                    // eslint-disable-next-line no-console
+                    console.error(message.trim());
                 }
-            }
-        }
-        finally {
-            this.outputBuffer.length = 0;
-            this.bufferSize = 0;
-        }
-    }
-    // Safe stringify with circular reference detection
-    safeStringify(obj, maxDepth = 3) {
-        const seen = new WeakSet();
-        const stringify = (value, depth) => {
-            if (depth > maxDepth)
-                return '[Max Depth Reached]';
-            if (value === null || typeof value !== 'object')
-                return value;
-            if (seen.has(value))
-                return '[Circular Reference]';
-            seen.add(value);
-            if (Array.isArray(value)) {
-                return value.map(item => stringify(item, depth + 1));
-            }
-            const result = {};
-            for (const [key, val] of Object.entries(value)) {
-                if (typeof val !== 'function') {
-                    // Skip functions
-                    result[key] = stringify(val, depth + 1);
+                else {
+                    // eslint-disable-next-line no-console
+                    console.log(message.trim());
                 }
             }
-            return result;
-        };
-        try {
-            return JSON.stringify(stringify(obj, 0));
-        }
-        catch (error) {
-            return '[Stringify Error]';
-        }
-    }
-    // Configuration validation
-    validateOptions(options) {
-        const validated = { ...options };
-        // Validate log level
-        const validLevels = ['debug', 'info', 'warn', 'error', 'fatal'];
-        if (validated.level && !validLevels.includes(validated.level)) {
-            console.warn(`[MoroLogger] Invalid log level: ${validated.level}, defaulting to 'info'`);
-            validated.level = 'info';
-        }
-        // Validate max entries
-        if (validated.maxEntries !== undefined) {
-            if (validated.maxEntries < 1 || validated.maxEntries > 100000) {
-                console.warn(`[MoroLogger] Invalid maxEntries: ${validated.maxEntries}, defaulting to 1000`);
-                validated.maxEntries = 1000;
-            }
-        }
-        // Validate buffer size
-        if (validated.maxBufferSize !== undefined) {
-            if (validated.maxBufferSize < 10 || validated.maxBufferSize > 10000) {
-                console.warn(`[MoroLogger] Invalid maxBufferSize: ${validated.maxBufferSize}, defaulting to 1000`);
-                validated.maxBufferSize = 1000;
-            }
-        }
-        return validated;
-    }
-    // Error handling methods
-    handleOutputError(outputName, error) {
-        // Could implement output retry logic, circuit breaker, etc.
-        // For now, just track the error
-        if (!this.metrics.outputErrors) {
-            this.metrics.outputErrors = {};
-        }
-        this.metrics.outputErrors[outputName] = (this.metrics.outputErrors[outputName] || 0) + 1;
-    }
-    emergencyConsoleWrite(entry) {
-        const message = `${entry.timestamp.toISOString()} ${entry.level.toUpperCase()} ${entry.message}`;
-        try {
-            if (entry.level === 'error' || entry.level === 'fatal') {
-                process.stderr.write(`[EMERGENCY] ${message}\n`);
-            }
-            else {
-                process.stdout.write(`[EMERGENCY] ${message}\n`);
-            }
-        }
-        catch {
-            // If even emergency write fails, there's nothing more we can do
         }
+        // Reset buffer
+        this.outputBuffer.length = 0;
+        this.bufferSize = 0;
     }
     // Force flush streams (useful for shutdown)
     flush() {
@@ -781,69 +598,76 @@ export class MoroLogger {
         // Flush any remaining buffer
         this.flushBuffer();
         try {
-            // Force flush streams without ending them
+            // Force flush streams
             if (process.stdout.writable) {
-                process.stdout.write(''); // Force flush without ending
+                process.stdout.end();
             }
             if (process.stderr.writable) {
-                process.stderr.write(''); // Force flush without ending
+                process.stderr.end();
             }
         }
         catch {
             // Ignore flush errors
         }
     }
-    // Destroy logger and clean up all resources (for testing)
-    destroy() {
-        // Mark as destroyed to prevent new timeouts
-        this.isDestroyed = true;
-        // Clear any remaining timeouts
+    // Cleanup method to clear all timeouts and handles
+    cleanup() {
+        // Clear any pending flush timeout
         if (this.flushTimeout) {
             clearTimeout(this.flushTimeout);
             this.flushTimeout = null;
         }
-        // Flush any remaining buffer
+        // Flush any remaining output
         this.flushBuffer();
-        // Clear outputs and filters
-        this.outputs.clear();
-        this.filters.clear();
-        // Clear history
-        this.history.length = 0;
-        this.historyIndex = 0;
-        this.historySize = 0;
     }
 }
+exports.MoroLogger = MoroLogger;
 // Global logger instance
 const initialLogLevel = process.env.LOG_LEVEL ||
     process.env.MORO_LOG_LEVEL ||
     (process.env.NODE_ENV === 'production' ? 'warn' : 'debug');
-export const logger = new MoroLogger({
+exports.logger = new MoroLogger({
     level: initialLogLevel,
     enableColors: !process.env.NO_COLOR,
     format: process.env.LOG_FORMAT || 'pretty',
 });
+// Add cleanup handlers for Jest and other test runners
+if (typeof process !== 'undefined') {
+    // Cleanup on process exit
+    process.on('beforeExit', () => {
+        exports.logger.cleanup();
+    });
+    process.on('SIGINT', () => {
+        exports.logger.cleanup();
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        exports.logger.cleanup();
+        process.exit(0);
+    });
+    // For Jest and other test runners - cleanup on uncaught exceptions
+    process.on('uncaughtException', () => {
+        exports.logger.cleanup();
+    });
+    process.on('unhandledRejection', () => {
+        exports.logger.cleanup();
+    });
+}
 /**
  * Configure the global logger with new settings
  * This allows runtime configuration of the logger
  */
-export function configureGlobalLogger(options) {
+function configureGlobalLogger(options) {
     if (options.level) {
-        logger.setLevel(options.level);
+        exports.logger.setLevel(options.level);
     }
     // Additional configuration options can be added here as needed
     // For now, focusing on level which is the most critical
 }
-/**
- * Destroy the global logger and clean up resources (for testing)
- * @internal
- */
-export function destroyGlobalLogger() {
-    logger.destroy();
-}
 /**
  * Apply logging configuration from the config system and/or createApp options
  */
-export function applyLoggingConfiguration(configLogging, appOptions) {
+function applyLoggingConfiguration(configLogging, appOptions) {
     // First apply config system settings (from environment variables)
     if (configLogging?.level) {
         configureGlobalLogger({ level: configLogging.level });
@@ -860,19 +684,20 @@ export function applyLoggingConfiguration(configLogging, appOptions) {
     }
 }
 // Framework-specific logger
-export const createFrameworkLogger = (context) => {
-    return logger.child('Moro', { framework: 'moro', context });
+const createFrameworkLogger = (context) => {
+    return exports.logger.child('Moro', { framework: 'moro', context });
 };
+exports.createFrameworkLogger = createFrameworkLogger;
 // Graceful shutdown handler to flush any pending logs
 process.on('SIGINT', () => {
-    logger.flush();
+    exports.logger.flush();
     process.exit(0);
 });
 process.on('SIGTERM', () => {
-    logger.flush();
+    exports.logger.flush();
     process.exit(0);
 });
 process.on('beforeExit', () => {
-    logger.flush();
+    exports.logger.flush();
 });
 //# sourceMappingURL=logger.js.map