ntlogger 2.10.0 → 4.0.0

package/lib/logObserver.js

@@ -0,0 +1,55 @@
+'use strict';
+const { AsyncLocalStorage } = require('node:async_hooks');
+const { withTimeout } = require('./lifecycle');
+
+// Counts represent serialized records, not confirmed delivery to any destination.
+function createLogObserver({ onLog, otel, onLogMaxPending = 100 } = {}) {
+    if (onLog !== undefined && typeof onLog !== 'function') throw new TypeError('onLog must be a function');
+    if (!Number.isSafeInteger(onLogMaxPending) || onLogMaxPending < 0) throw new TypeError('onLogMaxPending must be a nonnegative safe integer');
+    const scope = new AsyncLocalStorage();
+    const pending = new Set();
+    const counts = Object.fromEntries(['trace', 'debug', 'info', 'warn', 'error', 'fatal', 'internal'].map(k => [k, 0]));
+    let hookErrors = 0;
+    let dropped = 0;
+    const bridge = otel ? require('./pinoOtel').createOtelBridge(otel) : null;
+    const levelNames = { 10: 'trace', 20: 'debug', 30: 'info', 40: 'warn', 50: 'error', 60: 'fatal' };
+    function failure() { hookErrors++; }
+    function observe(record) {
+        const level = typeof record.level === 'number' ? levelNames[record.level] : record.level;
+        if (Object.hasOwn(counts, level)) counts[level]++;
+        // Suppress observers for logs made by an observer, including async descendants.
+        if (scope.getStore()) return;
+        scope.run(true, () => {
+            if (bridge) {
+                try { bridge.emit(record); } catch (_) { failure(); }
+            }
+            if (onLog) {
+                // In-flight promises cannot be cancelled: drop the newest callback only.
+                if (pending.size >= onLogMaxPending) { dropped++; return; }
+                try {
+                    // Mutation of the callback record cannot change output or OTel data.
+                    const result = onLog(JSON.parse(JSON.stringify(record)));
+                    if (result && typeof result.then === 'function') {
+                        const task = Promise.resolve(result).catch(failure);
+                        pending.add(task);
+                        task.finally(() => pending.delete(task));
+                    }
+                } catch (_) { failure(); }
+            }
+        });
+    }
+    return {
+        context: () => bridge ? bridge.context() : {},
+        observe,
+        streamWrite(line) { observe(JSON.parse(line)); return line; },
+        stats: () => ({ levels: { ...counts }, hookErrors, onLog: { pending: pending.size, dropped, limit: onLogMaxPending } }),
+        reset() { for (const key of Object.keys(counts)) counts[key] = 0; hookErrors = 0; dropped = 0; },
+        async flush(timeout = 5000) {
+            await withTimeout((async () => {
+                while (pending.size) await Promise.all([...pending]);
+                if (bridge) await bridge.flush();
+            })(), timeout, 'Log observers flush');
+        },
+    };
+}
+module.exports = { createLogObserver };

package/lib/logger.js

@@ -11,6 +11,7 @@
 
 const winston = require('winston');
 const crypto = require('crypto');
+const { withTimeout, drain, trackClose } = require('./lifecycle');
 
 const { setupSignalHandlers } = require('./signalHandler');
 const { initPlugins } = require('../plugins/index');
@@ -26,8 +27,7 @@ const levels = require('./levels');
 // Define a map to hold the logger instances by their location
 const loggerInstances = new Map();
 
-// Call the signal handler setup function
-setupSignalHandlers(loggerInstances);
+const activeLoggers = new Set();
 
 const customSettings = {
     levels: levels,
@@ -116,7 +116,7 @@ const consoleFormatter = (config) => winston.format.combine(
 
         // Apply the color to the padded level and the session ID
         // Note: The session ID color remains based on the 'color' variable (pre-calculated)
-        return `${timestamp} [${levelColor}${paddedLevel}${resetCode}] [${colorAnsiCode}ID: ${shortSessionId}${resetCode}] [${locationStr}]: ${levelColor}${message}${resetCode}`;
+        return `${config.timestamp === false ? "" : timestamp + " "}[${levelColor}${paddedLevel}${resetCode}] [${colorAnsiCode}ID: ${shortSessionId}${resetCode}] [${locationStr}]: ${levelColor}${message}${resetCode}`;
     }),
 );
 
@@ -136,7 +136,7 @@ const fileFormatter = (config) => winston.format.combine(
 
         // Include all metadata in JSON (filePath is already shown in locationStr but kept in JSON for structured data)
         const metaKeys = Object.keys(meta);
-        return `${timestamp} [${paddedLevel}] [ID: ${sessionId}] [${locationStr}]: ${message}${
+        return `${config.timestamp === false ? "" : timestamp + " "}[${paddedLevel}] [ID: ${sessionId}] [${locationStr}]: ${message}${
             metaKeys.length ? ' ' + JSON.stringify(meta, null, 2) : ''
         }`;
     }),
@@ -157,15 +157,20 @@ function wrapLoggerMethod(originalMethod, options = {}) {
         childContext = null,
         loggerInstance = null,
         level = 'info',
+        state,
     } = options;
 
     return function(...args) {
+        const target = loggerInstance || this;
+        if (state.closing) throw new Error('Logger is closed');
+        if (!target.isLevelEnabled(level) || target.transports.length === 0) return;
+        const eventTimestamp = new Date().toISOString();
         // Capture stack trace BEFORE setImmediate to get the actual call site
         let capturedCallSite = null;
         let capturedCallerOfCaller = null;
         if (reportPathEnabled) {
+            const originalPrepareStackTrace = Error.prepareStackTrace;
             try {
-                const originalPrepareStackTrace = Error.prepareStackTrace;
                 Error.prepareStackTrace = (_, stack) => stack;
 
                 const err = new Error();
@@ -215,28 +220,30 @@ function wrapLoggerMethod(originalMethod, options = {}) {
                     }
                 }
             } catch (err) {
-                // Silently fail
+                // Path reporting is optional.
+            } finally {
+                Error.prepareStackTrace = originalPrepareStackTrace;
             }
         }
 
-        // Use setImmediate to make this non-blocking
+        state.pending++;
         setImmediate(() => {
             const startTime = performanceTracker?.enabled ? performance.now() : null;
 
             try {
                 // Extract message and metadata (Winston format: method(message, meta) or method(message))
                 let message = args[0];
-                let meta = {};
+                let meta = { timestamp: eventTimestamp };
                 
                 if (args.length > 1 && typeof args[args.length - 1] === 'object' && args[args.length - 1] !== null && !Array.isArray(args[args.length - 1])) {
                     // Standard format: method(message, meta)
-                    meta = { ...args[args.length - 1] };
+                    meta = { ...args[args.length - 1], timestamp: eventTimestamp };
                     message = args[0];
                 } else if (args.length === 1) {
                     if (typeof args[0] === 'object' && args[0] !== null && !Array.isArray(args[0])) {
                         // Object format: method({ message: '...', ...other })
-                        message = args[0].message || JSON.stringify(args[0]);
-                        meta = { ...args[0] };
+                        message = args[0].message ?? JSON.stringify(args[0]);
+                        meta = { ...args[0], timestamp: eventTimestamp };
                         delete meta.message;
                     } else {
                         // Just a message string
@@ -244,6 +251,10 @@ function wrapLoggerMethod(originalMethod, options = {}) {
                     }
                 }
 
+                if (args[0] instanceof Error) {
+                    message = args[0].message;
+                    meta = { ...meta, name: args[0].name, stack: args[0].stack, cause: args[0].cause };
+                }
                 // Merge child context if available
                 if (childContext) {
                     meta = { ...childContext, ...meta };
@@ -303,7 +314,10 @@ function wrapLoggerMethod(originalMethod, options = {}) {
                     // Last resort - log to console
                     console.error('Logger wrapper error:', err);
                     console.error('Fallback also failed:', fallbackErr);
+                    state.error = fallbackErr;
                 }
+            } finally {
+                state.pending--;
             }
         });
     };
@@ -330,6 +344,8 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports, par
         statsInterval = 0,
     } = config;
 
+    const observer = require('./logObserver').createLogObserver(config);
+    const redactor = config.redact === false ? null : require('./secretRedaction').createRedactor(config.redact);
     let logTransport = [].filter(Boolean);
 
     if (console) {
@@ -352,7 +368,7 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports, par
         logTransport.push(
             new winston.transports.File({ filename: `${path}/fatal.log`, level: 'fatal', format: fileFormat, maxsize: maxSize, maxFiles: maxFiles }),
             new winston.transports.File({ filename: `${path}/error.log`, level: 'error', format: fileFormat, maxsize: maxSize, maxFiles: maxFiles }),
-            new winston.transports.File({ filename: `${path}/combined.log`, format: fileFormat, maxsize: maxSize, maxFiles: maxFiles }),
+            new winston.transports.File({ filename: `${path}/${config.filename || "combined.log"}`, format: fileFormat, maxsize: maxSize, maxFiles: maxFiles }),
         );
     }
     if (transports) {logTransport = logTransport.concat
@@ -362,6 +378,13 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports, par
     const logger = winston.createLogger({
         level: level,
         levels: customSettings.levels,
+        format: winston.format(info => {
+            const safe = redactor ? redactor.redactObject(info) : { ...info };
+            Object.assign(safe, observer.context());
+            Object.assign(info, safe);
+            observer.observe(safe);
+            return info;
+        })(),
         transports: logTransport,
         defaultMeta: {
             location,
@@ -370,6 +393,12 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports, par
         }
     });
 
+    const state = { pending: 0, closing: false, error: null };
+    logger.on('error', error => { state.error = error; });
+    logger.transports.forEach(trackClose);
+    const add = logger.add.bind(logger);
+    logger.add = transport => { trackClose(transport); return add(transport); };
+
     // Initialize feature modules
     const sampler = (Object.keys(sampling).length > 0 || Object.keys(rateLimit).length > 0) 
         ? new LogSampler({ sampling, rateLimit }) 
@@ -392,6 +421,7 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports, par
         performanceTracker: perfTracker,
         childContext,
         loggerInstance: logger,
+        state,
     };
 
     const boundLogger = logger;
@@ -403,15 +433,30 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports, par
     logger.fatal = wrapLoggerMethod(boundLogger.fatal.bind(boundLogger), { ...wrapOptions, level: 'fatal' });
     logger.internal = wrapLoggerMethod(boundLogger.internal.bind(boundLogger), { ...wrapOptions, level: 'internal' });
 
-    // Add child logger method
-    logger.child = function(context) {
-        const mergedContext = childContext ? { ...childContext, ...context } : context;
-        // Use skipCache for child loggers to avoid cache conflicts
-        const childConfig = { ...config, skipCache: true };
-        // Generate unique location for child logger
-        const childLocation = `${location}:child:${Date.now()}:${Math.random().toString(36).substring(7)}`;
-        return createLoggerInstance(childLocation, childConfig, transports, mergedContext);
+    // Children share the root stream and transports, but never own their shutdown.
+    const makeChild = (context = {}) => {
+        const child = Object.create(logger);
+        const frozen = Object.freeze({ ...context });
+        let closed = false;
+        for (const name of Object.keys(levels)) {
+            child[name] = (...args) => {
+                if (closed) throw new Error('Child logger is closed');
+                let message = args[0];
+                let meta = { ...frozen, ...(args[1] || {}) };
+                if (message && typeof message === 'object' && !(message instanceof Error)) {
+                    meta = { ...frozen, ...message };
+                    message = message.message ?? JSON.stringify(message);
+                    delete meta.message;
+                }
+                return logger[name](message, meta);
+            };
+        }
+        child.child = extra => makeChild({ ...frozen, ...extra });
+        child.flush = () => logger.flush();
+        child.close = () => { closed = true; return logger.flush(); };
+        return child;
     };
+    logger.child = makeChild;
 
     // Add performance tracking methods
     if (perfTracker) {
@@ -433,52 +478,64 @@ const createLoggerInstance = (location = "Unknown", config = {}, transports, par
             sampling: sampler ? sampler.getStats() : null,
             deduplication: deduplicator ? deduplicator.getStats() : null,
             performance: perfTracker ? perfTracker.getStats() : null,
+            ...observer.stats(),
         };
         return stats;
     };
 
-    // Add flush method (non-blocking, returns Promise)
-    logger.flush = function() {
-        return new Promise((resolve) => {
-            setImmediate(() => {
-                // Flush all transports that support it
-                const flushPromises = logger.transports.map(transport => {
-                    if (transport.flush && typeof transport.flush === 'function') {
-                        return Promise.resolve(transport.flush());
-                    }
-                    return Promise.resolve();
-                });
-                Promise.all(flushPromises).then(() => resolve());
-            });
-        });
+    logger.resetStats = () => {
+        sampler?.resetStats();
+        deduplicator?.resetStats();
+        observer.reset();
     };
 
-    // Add close method (graceful shutdown)
-    logger.close = function() {
-        return new Promise((resolve) => {
-            setImmediate(() => {
-                // Destroy feature modules
-                if (sampler) sampler.destroy();
-                if (deduplicator) deduplicator.destroy();
-                
-                // Close all transports
-                logger.end(() => {
-                    resolve();
-                });
-            });
+    const timeout = config.shutdownTimeout ?? 30000;
+    if (!Number.isFinite(timeout) || timeout <= 0) throw new Error('Invalid shutdownTimeout');
+    let closePromise;
+    let statsTimer;
+    logger.flush = () => withTimeout((async () => {
+        await drain(logger, state, timeout);
+        await Promise.all(logger.transports.map(t => t.flush?.()));
+        await observer.flush(timeout);
+        await drain(logger, state, timeout);
+    })(), timeout, 'Logger flush');
+
+    logger.close = () => {
+        if (closePromise) return closePromise;
+        state.closing = true;
+        clearInterval(statsTimer);
+        if (loggerInstances.get(location) === logger) loggerInstances.delete(location);
+        const owned = logger.transports.slice();
+        closePromise = withTimeout((async () => {
+            let failure;
+            try { await logger.flush(); } catch (error) { failure = error; }
+            try {
+                await withTimeout(new Promise((resolve, reject) => {
+                    if (logger._writableState.finished) return resolve();
+                    const onError = error => { logger.removeListener('finish', onFinish); reject(error); };
+                    const onFinish = () => { logger.removeListener('error', onError); resolve(); };
+                    logger.once('error', onError);
+                    logger.once('finish', onFinish);
+                    logger.end();
+                }), timeout, 'Logger stream close');
+            } catch (error) { failure ||= error; }
+            const results = await Promise.allSettled(owned.map(t => t._ntlClose()));
+            failure ||= results.find(result => result.status === 'rejected')?.reason;
+            if (failure) throw failure;
+        })(), timeout * 2, 'Logger close').finally(() => {
+            if (sampler) sampler.destroy();
+            if (deduplicator) deduplicator.destroy();
+            activeLoggers.delete(logger);
         });
+        return closePromise;
     };
 
-    // Statistics reporting interval
     if (statsInterval > 0 && (sampler || deduplicator)) {
-        setInterval(() => {
-            const stats = logger.getStats();
-            logger.internal('Logger Statistics:', stats);
-        }, statsInterval);
+        statsTimer = setInterval(() => logger.internal('Logger Statistics:', logger.getStats()), statsInterval);
+        statsTimer.unref();
     }
-
-    // Cache the newly created logger instance
-    loggerInstances.set(location, logger);
+    if (!skipCache) loggerInstances.set(location, logger);
+    activeLoggers.add(logger);
 
     if (debug === true) {
         // Use pre-calculated color values
@@ -524,6 +581,7 @@ const logger = (location = "Unknown", config = {}) => {
             // If cached logger doesn't have the features but config requests them, recreate
             if (!cachedHasFeatures) {
                 // Remove from cache and recreate with new config
+                cachedLogger.close().catch(error => global.console.error('Logger replacement cleanup failed:', error));
                 loggerInstances.delete(location);
             } else {
                 // Cached logger has features, return it
@@ -547,5 +605,7 @@ const logger = (location = "Unknown", config = {}) => {
     return createLoggerInstance(location, config, transports);
 };
 
+logger.setupSignalHandlers = options => setupSignalHandlers(activeLoggers, options);
+
 // Export a function to create or return the existing logger instance
 module.exports = logger;