@morojs/moro 1.5.2 → 1.5.4

package/dist/core/logger/logger.js

@@ -24,6 +24,31 @@ class MoroLogger {
     contextPrefix;
     contextMetadata;
     parent; // Reference to parent logger for level inheritance
+    // Performance optimizations
+    historyIndex = 0;
+    historySize = 0;
+    lastMemoryCheck = 0;
+    memoryCheckInterval = 5000; // 5 seconds
+    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
+    outputBuffer = [];
+    bufferSize = 0;
+    maxBufferSize = 1000;
+    flushTimeout = null;
+    flushInterval = 1; // 1ms micro-batching
+    // Buffer overflow protection
+    bufferOverflowThreshold;
+    emergencyFlushInProgress = false;
+    // High-performance output methods
     static LEVELS = {
         debug: 0,
         info: 1,
@@ -41,11 +66,20 @@ 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.options = this.validateOptions({
             level: 'info',
             enableColors: true,
             enableTimestamp: true,
@@ -56,9 +90,14 @@ 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',
@@ -69,6 +108,52 @@ 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);
     }
@@ -128,8 +213,44 @@ class MoroLogger {
         this.filters.delete(name);
     }
     getHistory(count) {
-        const entries = [...this.history];
-        return count ? entries.slice(-count) : entries;
+        if (this.historySize === 0)
+            return [];
+        if (this.historySize < (this.options.maxEntries || 1000)) {
+            // History not full yet, return all entries
+            const entries = this.history.slice(0, this.historySize);
+            return count ? entries.slice(-count) : entries;
+        }
+        else {
+            // History is full, use circular buffer logic
+            const entries = [];
+            const maxEntries = this.options.maxEntries || 1000;
+            for (let i = 0; i < maxEntries; i++) {
+                const index = (this.historyIndex + i) % maxEntries;
+                if (this.history[index]) {
+                    entries.push(this.history[index]);
+                }
+            }
+            return count ? entries.slice(-count) : entries;
+        }
+    }
+    // Cached timestamp formatting to avoid repeated string operations
+    getCachedTimestamp(timestamp) {
+        const now = timestamp.getTime();
+        if (now - this.lastTimestamp > this.timestampCacheInterval) {
+            this.lastTimestamp = now;
+            this.cachedTimestamp = timestamp.toISOString().replace('T', ' ').slice(0, 19);
+        }
+        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();
@@ -155,72 +276,184 @@ class MoroLogger {
             memoryUsage: 0,
         };
     }
+    // Optimized logging method
     log(level, message, context, metadata) {
-        // Check level threshold - use parent level if available (for child loggers)
+        // 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;
         }
-        // Create log entry
-        const entry = {
-            timestamp: new Date(),
-            level,
-            message,
-            context: this.contextPrefix
-                ? context
-                    ? `${this.contextPrefix}:${context}`
-                    : this.contextPrefix
-                : context,
-            metadata: { ...this.contextMetadata, ...metadata },
-            performance: this.options.enablePerformance
-                ? {
-                    memory: process.memoryUsage().heapUsed / 1024 / 1024,
+        // Absolute minimal path for simple logs - pure speed
+        if (!metadata && !context && !this.contextPrefix && !this.contextMetadata) {
+            const logStr = level.toUpperCase() + ' ' + message + '\n';
+            if (level === 'error' || level === 'fatal') {
+                process.stderr.write(logStr);
+            }
+            else {
+                process.stdout.write(logStr);
+            }
+            return;
+        }
+        // Minimal path for logs with context but no metadata
+        if (!metadata && !this.contextMetadata) {
+            const contextStr = context ? '[' + context + '] ' : '';
+            const logStr = level.toUpperCase() + ' ' + contextStr + message + '\n';
+            if (level === 'error' || level === 'fatal') {
+                process.stderr.write(logStr);
+            }
+            else {
+                process.stdout.write(logStr);
+            }
+            return;
+        }
+        // Path for complex logs
+        if (metadata && Object.keys(metadata).length > 0) {
+            this.complexLog(level, message, context, metadata);
+            return;
+        }
+        // Full logging path for complex logs
+        this.fullLog(level, message, context, metadata);
+    }
+    // Full logging with all features
+    fullLog(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;
+        // Apply filters with early return optimization
+        if (this.filters.size > 0) {
+            for (const filter of this.filters.values()) {
+                if (!filter.filter(entry)) {
+                    MoroLogger.returnPooledEntry(entry);
+                    return;
                 }
-                : undefined,
-        };
-        // Apply filters
-        for (const filter of this.filters.values()) {
-            if (!filter.filter(entry)) {
-                return;
             }
         }
         // Update metrics
         this.updateMetrics(entry);
-        // Store in history
-        this.history.push(entry);
-        if (this.history.length > (this.options.maxEntries || 1000)) {
-            this.history.shift();
+        // Store in history with circular buffer optimization
+        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) {
+        // Build string directly - no array, no try-catch, no metrics
+        let logStr = this.getFastCachedTimestamp() + ' ' + level.toUpperCase().padEnd(5);
+        if (context) {
+            logStr += '[' + context + '] ';
+        }
+        else if (this.contextPrefix) {
+            logStr += '[' + this.contextPrefix + '] ';
+        }
+        logStr += message;
+        if (metadata && Object.keys(metadata).length > 0) {
+            logStr += ' ' + this.safeStringify(metadata);
+        }
+        if (this.contextMetadata && Object.keys(this.contextMetadata).length > 0) {
+            logStr += ' ' + this.safeStringify(this.contextMetadata);
+        }
+        logStr += '\n';
+        // Direct write - no error handling, no buffering
+        if (level === 'error' || level === 'fatal') {
+            process.stderr.write(logStr);
+        }
+        else {
+            process.stdout.write(logStr);
+        }
+    }
+    updateMetrics(entry) {
+        this.metrics.totalLogs++;
+        this.metrics.logsByLevel[entry.level]++;
+        if (entry.context) {
+            this.metrics.logsByContext[entry.context] =
+                (this.metrics.logsByContext[entry.context] || 0) + 1;
+        }
+    }
+    // Optimized metadata creation to avoid unnecessary object spreading
+    createMetadata(metadata) {
+        if (!metadata && !this.contextMetadata) {
+            return {};
         }
-        // Write to outputs
+        if (!metadata) {
+            return { ...this.contextMetadata };
+        }
+        if (!this.contextMetadata) {
+            return { ...metadata };
+        }
+        return { ...this.contextMetadata, ...metadata };
+    }
+    // Optimized performance data with caching
+    getPerformanceData(now) {
+        if (now - this.lastMemoryCheck > this.memoryCheckInterval) {
+            this.lastMemoryCheck = now;
+            this.metrics.memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024;
+        }
+        return { memory: this.metrics.memoryUsage };
+    }
+    // Circular buffer implementation for history (O(1) instead of O(n))
+    addToHistory(entry) {
+        const maxEntries = this.options.maxEntries || 1000;
+        if (this.historySize < maxEntries) {
+            this.history[this.historySize] = entry;
+            this.historySize++;
+        }
+        else {
+            // Circular buffer: overwrite oldest entry
+            this.history[this.historyIndex] = entry;
+            this.historyIndex = (this.historyIndex + 1) % maxEntries;
+        }
+    }
+    // Optimized output writing with batching
+    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) {
-                    console.error('Logger output error:', error);
+                    errors.push({ outputName: output.name, error });
+                    this.handleOutputError(output.name, error);
                 }
             }
         }
-    }
-    updateMetrics(entry) {
-        this.metrics.totalLogs++;
-        this.metrics.logsByLevel[entry.level]++;
-        if (entry.context) {
-            this.metrics.logsByContext[entry.context] =
-                (this.metrics.logsByContext[entry.context] || 0) + 1;
+        // 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') {
-            console.log(JSON.stringify(entry));
+            this.output(`${this.safeStringify(entry)}\n`, entry.level);
             return;
         }
         if (format === 'compact') {
             const level = entry.level.toUpperCase().padEnd(5);
             const context = entry.context ? `[${entry.context}] ` : '';
-            console.log(`${level} ${context}${entry.message}`);
+            this.output(`${level} ${context}${entry.message}\n`, entry.level);
             return;
         }
         // Pretty format (default)
@@ -228,24 +461,47 @@ class MoroLogger {
     }
     writePrettyLog(entry) {
         const colors = this.options.enableColors !== false;
-        const parts = [];
-        // Timestamp
+        const levelReset = colors ? MoroLogger.RESET : '';
+        MoroLogger.resetStringBuilder();
+        // Timestamp with caching optimization
         if (this.options.enableTimestamp !== false) {
-            const timestamp = entry.timestamp.toISOString().replace('T', ' ').slice(0, 19);
-            parts.push(colors ? `${MoroLogger.COLORS.timestamp}${timestamp}${MoroLogger.RESET}` : timestamp);
+            const timestamp = this.getCachedTimestamp(entry.timestamp);
+            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[entry.level];
+        if (colors) {
+            MoroLogger.appendToBuilder(MoroLogger.COLORS[entry.level]);
+            MoroLogger.appendToBuilder(MoroLogger.BOLD);
+            MoroLogger.appendToBuilder(levelStr);
+            MoroLogger.appendToBuilder(levelReset);
+        }
+        else {
+            MoroLogger.appendToBuilder(levelStr);
         }
-        // Level with color (remove icons)
-        const levelColor = colors ? MoroLogger.COLORS[entry.level] : '';
-        const levelReset = colors ? MoroLogger.RESET : '';
-        const levelText = entry.level.toUpperCase();
-        parts.push(`${levelColor}${MoroLogger.BOLD}${levelText}${levelReset}`);
         // Context
         if (entry.context && this.options.enableContext !== false) {
-            const contextColor = colors ? MoroLogger.COLORS.context : '';
-            parts.push(`${contextColor}[${entry.context}]${levelReset}`);
+            MoroLogger.appendToBuilder(' ');
+            if (colors) {
+                MoroLogger.appendToBuilder(MoroLogger.COLORS.context);
+                MoroLogger.appendToBuilder(`[${entry.context}]`);
+                MoroLogger.appendToBuilder(levelReset);
+            }
+            else {
+                MoroLogger.appendToBuilder(`[${entry.context}]`);
+            }
         }
         // Message
-        parts.push(entry.message);
+        MoroLogger.appendToBuilder(' ');
+        MoroLogger.appendToBuilder(entry.message);
         // Performance info
         if (entry.performance && this.options.enablePerformance !== false) {
             const perfColor = colors ? MoroLogger.COLORS.performance : '';
@@ -257,26 +513,248 @@ class MoroLogger {
                 perfParts.push(`${Math.round(entry.performance.memory)}MB`);
             }
             if (perfParts.length > 0) {
-                parts.push(`${perfColor}(${perfParts.join(', ')})${levelReset}`);
+                MoroLogger.appendToBuilder(' ');
+                if (colors) {
+                    MoroLogger.appendToBuilder(perfColor);
+                    MoroLogger.appendToBuilder(`(${perfParts.join(', ')})`);
+                    MoroLogger.appendToBuilder(levelReset);
+                }
+                else {
+                    MoroLogger.appendToBuilder(`(${perfParts.join(', ')})`);
+                }
             }
         }
-        // Metadata
+        // Metadata with optimized JSON stringify
         if (entry.metadata &&
             Object.keys(entry.metadata).length > 0 &&
             this.options.enableMetadata !== false) {
             const metaColor = colors ? MoroLogger.COLORS.metadata : '';
-            const cleanMetadata = { ...entry.metadata };
-            delete cleanMetadata.stack; // Handle stack separately
+            const cleanMetadata = this.cleanMetadata(entry.metadata);
             if (Object.keys(cleanMetadata).length > 0) {
-                parts.push(`${metaColor}${JSON.stringify(cleanMetadata)}${levelReset}`);
+                MoroLogger.appendToBuilder(' ');
+                if (colors) {
+                    MoroLogger.appendToBuilder(metaColor);
+                    MoroLogger.appendToBuilder(this.safeStringify(cleanMetadata));
+                    MoroLogger.appendToBuilder(levelReset);
+                }
+                else {
+                    MoroLogger.appendToBuilder(this.safeStringify(cleanMetadata));
+                }
             }
         }
-        // Output main log line
-        console.log(parts.join(' '));
+        // Output main log line with high-performance method
+        const finalMessage = MoroLogger.buildString();
+        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 : '';
-            console.log(`${stackColor}${entry.metadata.stack}${levelReset}`);
+            this.output(`${stackColor}${entry.metadata.stack}${levelReset}\n`, entry.level);
+        }
+    }
+    // Optimized metadata cleaning to avoid unnecessary object operations
+    cleanMetadata(metadata) {
+        const clean = {};
+        for (const [key, value] of Object.entries(metadata)) {
+            if (key !== 'stack') {
+                clean[key] = value;
+            }
+        }
+        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;
+        }
+        this.outputBuffer.push(message);
+        this.bufferSize++;
+        // Immediate flush for critical levels or full buffer
+        if (level === 'fatal' || level === 'error' || this.bufferSize >= this.maxBufferSize) {
+            this.flushBuffer();
+        }
+        else {
+            this.scheduleFlush();
+        }
+    }
+    scheduleFlush() {
+        if (this.flushTimeout) {
+            return; // Already scheduled
+        }
+        this.flushTimeout = setTimeout(() => {
+            this.flushBuffer();
+        }, this.flushInterval);
+    }
+    flushBuffer() {
+        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) {
+                process.stdout.write(stdoutMessages.join(''));
+            }
+            if (stderrMessages.length > 0 && process.stderr.writable) {
+                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;
+                }
+            }
+        }
+        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);
+                }
+            }
+            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
+        }
+    }
+    // Force flush streams (useful for shutdown)
+    flush() {
+        // Clear any pending flush timeout
+        if (this.flushTimeout) {
+            clearTimeout(this.flushTimeout);
+            this.flushTimeout = null;
+        }
+        // Flush any remaining buffer
+        this.flushBuffer();
+        try {
+            // Force flush streams without ending them
+            if (process.stdout.writable) {
+                process.stdout.write(''); // Force flush without ending
+            }
+            if (process.stderr.writable) {
+                process.stderr.write(''); // Force flush without ending
+            }
+        }
+        catch {
+            // Ignore flush errors
         }
     }
 }
@@ -325,4 +803,16 @@ 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', () => {
+    exports.logger.flush();
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    exports.logger.flush();
+    process.exit(0);
+});
+process.on('beforeExit', () => {
+    exports.logger.flush();
+});
 //# sourceMappingURL=logger.js.map