@morojs/moro 1.6.0 → 1.6.1

package/src/core/logger/logger.ts

@@ -1,6 +1,6 @@
 // Moro Logger - Beautiful, Fast, Feature-Rich
 import { performance } from 'perf_hooks';
-
+// import { format } from 'util'; // Not currently used
 import {
   LogLevel,
   LogEntry,
@@ -10,7 +10,7 @@ import {
   LogFilter,
   LogMetrics,
   ColorScheme,
-} from '../../types/logger.js';
+} from '../../types/logger';
 
 export class MoroLogger implements Logger {
   private level: LogLevel = 'info';
@@ -41,27 +41,13 @@ export class MoroLogger implements Logger {
   private lastTimestamp = 0;
   private timestampCacheInterval = 100; // 100ms for better precision
 
-  // Object pooling for LogEntry objects (Pino's technique)
-  private static readonly ENTRY_POOL: LogEntry[] = [];
-  private static readonly MAX_POOL_SIZE = 100;
-  private static poolIndex = 0;
-
-  // String builder for efficient concatenation
-  private static stringBuilder: string[] = [];
-  private static stringBuilderIndex = 0;
-
-  // Buffered output for performance
+  // Buffered output for micro-batching
   private outputBuffer: string[] = [];
   private bufferSize = 0;
-  private maxBufferSize = 1000;
+  private maxBufferSize = 1024; // 1KB buffer
   private flushTimeout: NodeJS.Timeout | null = null;
   private flushInterval = 1; // 1ms micro-batching
 
-  // Buffer overflow protection
-  private bufferOverflowThreshold: number;
-  private emergencyFlushInProgress = false;
-  private isDestroyed = false;
-
   // High-performance output methods
 
   private static readonly LEVELS: Record<LogLevel, number> = {
@@ -72,6 +58,84 @@ export class MoroLogger implements Logger {
     fatal: 4,
   };
 
+  // Static pre-allocated strings for maximum performance
+  private static readonly LEVEL_STRINGS: Record<LogLevel, string> = {
+    debug: 'DEBUG',
+    info: 'INFO',
+    warn: 'WARN',
+    error: 'ERROR',
+    fatal: 'FATAL',
+  };
+
+  // Pre-allocated ANSI color codes
+  private static readonly 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
+  private static readonly ENTRY_POOL: LogEntry[] = [];
+  private static readonly MAX_POOL_SIZE = 100;
+  private static poolIndex = 0;
+
+  // Object pool management
+  private static getPooledEntry(): LogEntry {
+    if (MoroLogger.poolIndex > 0) {
+      return MoroLogger.ENTRY_POOL[--MoroLogger.poolIndex];
+    }
+    return {
+      timestamp: new Date(),
+      level: 'info',
+      message: '',
+      context: undefined,
+      metadata: undefined,
+    };
+  }
+
+  private static returnPooledEntry(entry: LogEntry): void {
+    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
+  private static stringBuilder: string[] = [];
+  private static stringBuilderIndex = 0;
+
+  private static resetStringBuilder(): void {
+    MoroLogger.stringBuilderIndex = 0;
+  }
+
+  private static appendToBuilder(str: string): void {
+    if (MoroLogger.stringBuilderIndex < MoroLogger.stringBuilder.length) {
+      MoroLogger.stringBuilder[MoroLogger.stringBuilderIndex++] = str;
+    } else {
+      MoroLogger.stringBuilder.push(str);
+      MoroLogger.stringBuilderIndex++;
+    }
+  }
+
+  private static buildString(): string {
+    const result = MoroLogger.stringBuilder.slice(0, MoroLogger.stringBuilderIndex).join('');
+    MoroLogger.resetStringBuilder();
+    return result;
+  }
+
   private static readonly COLORS: ColorScheme = {
     debug: '\x1b[36m', // Cyan
     info: '\x1b[32m', // Green
@@ -82,23 +146,13 @@ export class MoroLogger implements Logger {
     context: '\x1b[34m', // Blue
     metadata: '\x1b[37m', // White
     performance: '\x1b[36m', // Cyan
-    reset: '\x1b[0m', // Reset
   };
 
   private static readonly RESET = '\x1b[0m';
   private static readonly BOLD = '\x1b[1m';
 
-  // Static pre-allocated strings for performance
-  private static readonly LEVEL_STRINGS: Record<LogLevel, string> = {
-    debug: 'DEBUG',
-    info: 'INFO ',
-    warn: 'WARN ',
-    error: 'ERROR',
-    fatal: 'FATAL',
-  };
-
   constructor(options: LoggerOptions = {}) {
-    this.options = this.validateOptions({
+    this.options = {
       level: 'info',
       enableColors: true,
       enableTimestamp: true,
@@ -109,18 +163,11 @@ export class MoroLogger implements Logger {
       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',
@@ -133,58 +180,6 @@ export class MoroLogger implements Logger {
     this.options.filters?.forEach(filter => this.addFilter(filter));
   }
 
-  // Object pooling methods
-  private static getPooledEntry(): LogEntry {
-    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:
-  private static createFreshEntry(): LogEntry {
-    return {
-      timestamp: new Date(),
-      level: 'info',
-      message: '',
-      context: undefined,
-      metadata: undefined,
-      performance: undefined,
-      moduleId: undefined,
-    };
-  }
-
-  private static returnPooledEntry(entry: LogEntry): void {
-    if (MoroLogger.ENTRY_POOL.length < MoroLogger.MAX_POOL_SIZE) {
-      MoroLogger.ENTRY_POOL.push(entry);
-    }
-  }
-
-  // String builder methods
-  private static resetStringBuilder(): void {
-    MoroLogger.stringBuilder.length = 0;
-    MoroLogger.stringBuilderIndex = 0;
-  }
-
-  private static appendToBuilder(str: string): void {
-    MoroLogger.stringBuilder[MoroLogger.stringBuilderIndex++] = str;
-  }
-
-  private static buildString(): string {
-    const result = MoroLogger.stringBuilder.join('');
-    MoroLogger.resetStringBuilder();
-    return result;
-  }
-
   debug(message: string, context?: string, metadata?: Record<string, any>): void {
     this.log('debug', message, context, metadata);
   }
@@ -227,9 +222,7 @@ export class MoroLogger implements Logger {
   }
 
   child(context: string, metadata?: Record<string, any>): Logger {
-    // 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;
@@ -245,10 +238,6 @@ export class MoroLogger implements Logger {
     this.level = level;
   }
 
-  getLevel(): LogLevel {
-    return this.level;
-  }
-
   addOutput(output: LogOutput): void {
     this.outputs.set(output.name, output);
   }
@@ -298,17 +287,6 @@ export class MoroLogger implements Logger {
     return this.cachedTimestamp;
   }
 
-  // Cached timestamp generation (updates once per second)
-  private getFastCachedTimestamp(): string {
-    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(): LogMetrics {
     const now = Date.now();
     const uptime = (now - this.startTime) / 1000; // seconds
@@ -336,54 +314,62 @@ export class MoroLogger implements Logger {
     };
   }
 
-  // Optimized logging method
+  // Optimized logging method with aggressive level checking
   private log(
     level: LogLevel,
     message: string,
     context?: string,
     metadata?: Record<string, any>
   ): void {
-    // Prevent logging after destroy() is called (important for test cleanup)
-    if (this.isDestroyed) {
-      return;
-    }
+    // 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];
 
-    // 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 as LogLevel]) {
-      return;
+    if (levelNum < effectiveLevelNum) {
+      return; // Exit immediately if level is too low
     }
 
-    // Absolute minimal path for simple logs - pure speed
+    // 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
   private fullLog(
     level: LogLevel,
     message: string,
     context?: string,
     metadata?: Record<string, any>
   ): void {
-    // Use object pooling for LogEntry (Pino's technique)
+    // Get pooled entry to avoid allocation
     const entry = MoroLogger.getPooledEntry();
     const now = Date.now();
 
@@ -402,7 +388,6 @@ export class MoroLogger implements Logger {
     if (this.filters.size > 0) {
       for (const filter of this.filters.values()) {
         if (!filter.filter(entry)) {
-          MoroLogger.returnPooledEntry(entry);
           return;
         }
       }
@@ -417,89 +402,8 @@ export class MoroLogger implements Logger {
     // Write to outputs with batched processing
     this.writeToOutputs(entry, level);
 
-    // Return entry to pool
-    MoroLogger.returnPooledEntry(entry);
-  }
-
-  // Absolute minimal logging - pure speed, no overhead
-  private complexLog(
-    level: LogLevel,
-    message: string,
-    context?: string,
-    metadata?: Record<string, any>
-  ): void {
-    // 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
-  private writeSimpleLog(level: LogLevel, message: string, context?: string): void {
-    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);
   }
 
   private updateMetrics(entry: LogEntry): void {
@@ -553,39 +457,24 @@ export class MoroLogger implements Logger {
   private writeToOutputs(entry: LogEntry, level: LogLevel): void {
     if (this.outputs.size === 0) return;
 
-    let successCount = 0;
-    const errors: Array<{ outputName: string; error: any }> = [];
-
     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),
-      });
-    }
   }
 
   private writeToConsole(entry: LogEntry): void {
     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;
     }
 
@@ -602,8 +491,6 @@ export class MoroLogger implements Logger {
 
   private writePrettyLog(entry: LogEntry): void {
     const colors = this.options.enableColors !== false;
-    const levelReset = colors ? MoroLogger.RESET : '';
-
     MoroLogger.resetStringBuilder();
 
     // Timestamp with caching optimization
@@ -612,29 +499,37 @@ export class MoroLogger implements Logger {
       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);
       } else {
@@ -643,7 +538,7 @@ export class MoroLogger implements Logger {
     }
 
     // Message
-    MoroLogger.appendToBuilder(' ');
+    MoroLogger.appendToBuilder(' '); // Space before message
     MoroLogger.appendToBuilder(entry.message);
 
     // Performance info
@@ -659,7 +554,7 @@ export class MoroLogger implements Logger {
       }
 
       if (perfParts.length > 0) {
-        MoroLogger.appendToBuilder(' ');
+        MoroLogger.appendToBuilder(' '); // Space before performance info
         if (colors) {
           MoroLogger.appendToBuilder(perfColor);
           MoroLogger.appendToBuilder(`(${perfParts.join(', ')})`);
@@ -680,20 +575,19 @@ export class MoroLogger implements Logger {
       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')) {
@@ -713,199 +607,79 @@ export class MoroLogger implements Logger {
     return clean;
   }
 
-  // High-performance output with buffering
-  private output(message: string, level: LogLevel = 'info'): void {
-    // 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
+  private stringify(obj: any): string {
+    try {
+      return JSON.stringify(obj);
+    } catch {
+      return '[Circular Reference]';
     }
+  }
 
+  // High-performance output with micro-batching
+  private output(message: string, level: LogLevel = 'info'): void {
+    // Add to buffer
     this.outputBuffer.push(message);
-    this.bufferSize++;
+    this.bufferSize += message.length;
 
-    // Immediate flush for critical levels or full buffer
-    if (level === 'fatal' || level === 'error' || this.bufferSize >= this.maxBufferSize) {
+    // 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();
     }
   }
 
   private scheduleFlush(): void {
-    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();
   }
 
-  public flushBuffer(): void {
-    if (this.outputBuffer.length === 0) {
-      return;
-    }
-
-    // Group messages by stream type
-    const stdoutMessages: string[] = [];
-    const stderrMessages: string[] = [];
+  private flushBuffer(): void {
+    if (this.outputBuffer.length === 0) return;
 
-    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);
+    try {
+      // Group by stream type for efficiency
+      const stdoutMessages: string[] = [];
+      const stderrMessages: string[] = [];
+
+      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 appropriate streams with error handling
-    try {
-      if (stdoutMessages.length > 0 && process.stdout.writable) {
+      // 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
+      // 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());
+        } else {
+          // eslint-disable-next-line no-console
+          console.log(message.trim());
+        }
       }
     }
 
-    // Clear buffer
+    // Reset 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
-  private forceFlushBuffer(): void {
-    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;
-        }
-      }
-    } finally {
-      this.outputBuffer.length = 0;
-      this.bufferSize = 0;
-    }
-  }
-
-  // Safe stringify with circular reference detection
-  private safeStringify(obj: any, maxDepth = 3): string {
-    const seen = new WeakSet();
-
-    const stringify = (value: any, depth: number): any => {
-      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: any = {};
-      for (const [key, val] of Object.entries(value)) {
-        if (typeof val !== 'function') {
-          // Skip functions
-          result[key] = stringify(val, depth + 1);
-        }
-      }
-      return result;
-    };
-
-    try {
-      return JSON.stringify(stringify(obj, 0));
-    } catch (error) {
-      return '[Stringify Error]';
-    }
-  }
-
-  // Configuration validation
-  private validateOptions(options: LoggerOptions): LoggerOptions {
-    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
-  private handleOutputError(outputName: string, error: any): void {
-    // 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;
-  }
-
-  private emergencyConsoleWrite(entry: LogEntry): void {
-    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
-    }
   }
 
   // Force flush streams (useful for shutdown)
@@ -920,40 +694,28 @@ export class MoroLogger implements Logger {
     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)
-  public destroy(): void {
-    // Mark as destroyed to prevent new timeouts
-    this.isDestroyed = true;
-
-    // Clear any remaining timeouts
+  // Cleanup method to clear all timeouts and handles
+  public cleanup(): void {
+    // 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;
   }
 }
 
@@ -969,6 +731,33 @@ export const logger = new MoroLogger({
   format: (process.env.LOG_FORMAT as any) || 'pretty',
 });
 
+// Add cleanup handlers for Jest and other test runners
+if (typeof process !== 'undefined') {
+  // Cleanup on process exit
+  process.on('beforeExit', () => {
+    logger.cleanup();
+  });
+
+  process.on('SIGINT', () => {
+    logger.cleanup();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', () => {
+    logger.cleanup();
+    process.exit(0);
+  });
+
+  // For Jest and other test runners - cleanup on uncaught exceptions
+  process.on('uncaughtException', () => {
+    logger.cleanup();
+  });
+
+  process.on('unhandledRejection', () => {
+    logger.cleanup();
+  });
+}
+
 /**
  * Configure the global logger with new settings
  * This allows runtime configuration of the logger
@@ -981,14 +770,6 @@ export function configureGlobalLogger(options: Partial<LoggerOptions>): void {
   // For now, focusing on level which is the most critical
 }
 
-/**
- * Destroy the global logger and clean up resources (for testing)
- * @internal
- */
-export function destroyGlobalLogger(): void {
-  logger.destroy();
-}
-
 /**
  * Apply logging configuration from the config system and/or createApp options
  */