ntlogger 3.0.0 → 4.0.0

package/pino.js

@@ -80,7 +80,7 @@ function isPlainContainer(value) {
  * Precedence:
  *   1. `opts.silent` when it is a boolean
  *   2. `NTLOGGER_SILENT` env var (`1|true|yes` / `0|false|no`, case-insensitive)
- *   3. `NODE_ENV === 'test'`
+ *   3. `NODE_ENV === 'test'` or a nonempty `NODE_TEST_CONTEXT`
  *
  * Anything else (unset, or an unrecognised env value) falls through to the next step.
  *
@@ -97,7 +97,7 @@ function isSilent(opts = {}) {
     if (SILENT_FALSE.has(value)) return false;
   }
 
-  return process.env.NODE_ENV === 'test';
+  return process.env.NODE_ENV === 'test' || Boolean(process.env.NODE_TEST_CONTEXT);
 }
 
 /**
@@ -258,45 +258,62 @@ function composeLogMethod(redactor, features) {
  * @param {object} logger - Pino logger instance.
  * @param {object|null} features - Feature adapter from lib/pinoHooks.js.
  * @param {object|null} redactor - Redactor from lib/secretRedaction.js.
- * @returns {object} - The same logger, decorated.
+ * @param {object} observer - Emitted-record observer and counters.
+ * @returns {object} - Pino logger proxy enforcing lifecycle across level changes.
  */
-function decorateLogger(logger, features, redactor) {
-  const define = (name, value) => {
-    Object.defineProperty(logger, name, {
-      value,
-      writable: true,
-      configurable: true,
-      enumerable: false,
-    });
-  };
-
-  define('getStats', function getStats() {
-    return features ? features.getStats() : { sampling: null, deduplication: null };
+function decorateLogger(logger, features, redactor, observer) {
+  const states = new WeakMap();
+  const define = (name, value) => Object.defineProperty(logger, name, {
+    value, writable: true, configurable: true, enumerable: false,
   });
-
-  define('resetStats', function resetStats() {
-    if (features) features.resetStats();
+  define('getStats', () => ({
+    ...(features ? features.getStats() : { sampling: null, deduplication: null }),
+    ...observer.stats(),
+  }));
+  define('resetStats', () => { if (features) features.resetStats(); observer.reset(); });
+  define('close', function close(timeout = DEFAULT_CLOSE_TIMEOUT) {
+    const state = states.get(this);
+    if (state.promise) return state.promise;
+    state.closed = true;
+    if (!state.parent && features) features.destroy();
+    state.promise = (async () => {
+      const start = Date.now();
+      const result = await drainLogger(this, timeout);
+      try { await observer.flush(Math.max(1, timeout - (Date.now() - start))); }
+      catch (error) { return { drained: false, error }; }
+      return result;
+    })();
+    return state.promise;
   });
-
-  // Releases the sampler/deduplicator timers, then flushes whatever the
-  // destination still holds. Calling it on a child tears down the state shared
-  // with its parent — close the root logger.
-  define('close', function close(timeout) {
-    if (features) features.destroy();
-    return drainLogger(this, typeof timeout === 'number' ? timeout : DEFAULT_CLOSE_TIMEOUT);
+  const baseChild = logger.child;
+  define('child', function child(bindings, options) {
+    const safe = redactor && bindings && typeof bindings === 'object'
+      ? redactor.redactObject(bindings) : bindings;
+    return wrap(baseChild.call(this, safe, options), states.get(this));
   });
-
-  if (redactor) {
-    const baseChild = logger.child;
-    define('child', function child(bindings, options) {
-      const safe = bindings !== null && typeof bindings === 'object'
-        ? redactor.redactObject(bindings)
-        : bindings;
-      return baseChild.call(this, safe, options);
+  function wrap(target, parent = null) {
+    const state = { closed: false, parent, promise: null };
+    states.set(target, state);
+    const assertOpen = () => {
+      for (let current = state; current; current = current.parent) {
+        if (current.closed) throw new Error('Logger is closed');
+      }
+    };
+    const cache = new Map();
+    return new Proxy(target, {
+      get(raw, key) {
+        const value = Reflect.get(raw, key, raw);
+        if (typeof value !== 'function') return value;
+        const guarded = key === 'child' || key === 'silent' || Object.hasOwn(raw.levels.values, key);
+        // Pino regenerates methods on level changes. Cache only while unchanged.
+        if (cache.get(key)?.original === value) return cache.get(key).bound;
+        const bound = (...args) => { if (guarded) assertOpen(); return value.apply(raw, args); };
+        cache.set(key, { original: value, bound });
+        return bound;
+      },
     });
   }
-
-  return logger;
+  return wrap(logger);
 }
 
 /**
@@ -323,9 +340,8 @@ function decorateLogger(logger, features, redactor) {
  * @param {*} [opts.destination] - For tests/advanced use: a Pino destination stream. Replaces the NTL transport.
  * @returns {object} - Pino logger with `getStats()`, `resetStats()`, `close()` and (optionally) `uninstallProcessHandlers`.
  */
-function createLogger(opts = {}) {
+function buildPinoOptions(opts = {}) {
   const pino = require('pino');
-  const path = require('path');
   const os = require('os');
 
   const silent = isSilent(opts);
@@ -334,7 +350,8 @@ function createLogger(opts = {}) {
     ? 'silent'
     : (opts.level || process.env.LOG_LEVEL || (isDev ? 'debug' : 'info'));
 
-  const loggerOpts = { level };
+  const observer = require('./lib/logObserver').createLogObserver(opts);
+  const loggerOpts = { level, hooks: { streamWrite: observer.streamWrite } };
 
   // --- constant fields ---------------------------------------------------
   if (typeof opts.service === 'string' && opts.service.length > 0) {
@@ -345,6 +362,15 @@ function createLogger(opts = {}) {
   // --- redaction / features (skipped entirely in silent mode) ------------
   let redactor = null;
   let features = null;
+  const secretScope = require('./lib/secretScope');
+  loggerOpts.hooks.streamWrite = line => {
+    // Interpolation can stringify Errors/Buffers after logMethod has run. Scrub
+    // final string fields while a secret scope is active, before observers see them.
+    if (redactor && secretScope.hasSecretValues()) {
+      line = JSON.stringify(redactor.redactObject(JSON.parse(line))) + '\n';
+    }
+    return observer.streamWrite(line);
+  };
 
   if (!silent) {
     const redaction = resolveRedaction(opts.redact);
@@ -377,7 +403,7 @@ function createLogger(opts = {}) {
     });
 
     const logMethod = composeLogMethod(redactor, features);
-    if (logMethod) loggerOpts.hooks = { logMethod };
+    if (logMethod) loggerOpts.hooks.logMethod = logMethod;
   }
 
   // --- context mixin ------------------------------------------------------
@@ -389,7 +415,7 @@ function createLogger(opts = {}) {
     ? opts.contextKeys.slice()
     : null;
 
-  if (!silent && (opts.module || staticContext || provider)) {
+  if (!silent && (opts.module || staticContext || provider || opts.otel)) {
     // Precedence, lowest to highest: base/service < module < context < contextProvider
     // < fields passed on the log call itself (Pino's default mixin merge strategy
     // assigns the merge object over the mixin output).
@@ -418,10 +444,18 @@ function createLogger(opts = {}) {
         }
       }
 
-      return out;
+      return Object.assign(out, observer.context());
     };
   }
 
+  return { loggerOpts, features, redactor, silent, isDev, observer };
+}
+
+function createLogger(opts = {}) {
+  const pino = require('pino');
+  const path = require('path');
+  const { loggerOpts, features, redactor, silent, isDev, observer } = buildPinoOptions(opts);
+
   // --- destination / transport -------------------------------------------
   // `opts.destination` and `transport` are mutually exclusive in Pino, so an
   // explicit destination always wins and the NTL formatter is skipped.
@@ -437,8 +471,7 @@ function createLogger(opts = {}) {
     };
   }
 
-  const logger = destination ? pino(loggerOpts, destination) : pino(loggerOpts);
-  decorateLogger(logger, features, redactor);
+  const logger = decorateLogger(destination ? pino(loggerOpts, destination) : pino(loggerOpts), features, redactor, observer);
 
   if (opts.processHandlers) {
     const handlerOpts = typeof opts.processHandlers === 'object' ? opts.processHandlers : {};
@@ -455,3 +488,71 @@ function createLogger(opts = {}) {
 
 module.exports.createLogger = createLogger;
 module.exports.isSilent = isSilent;
+
+/**
+ * Plain Pino options for framework-owned loggers. No transport, process
+ * handlers, or feature timers are created; the framework owns the lifecycle.
+ * Supply custom serializers here so their output is redacted too.
+ */
+function createPinoOptions(opts = {}) {
+  for (const key of ['sampling', 'rateLimit', 'deduplication', 'destination', 'processHandlers']) {
+    if (opts[key] !== undefined) {
+      throw new TypeError(`createPinoOptions does not support ${key}; use createLogger instead`);
+    }
+  }
+  const pino = require('pino');
+  const { loggerOpts, redactor } = buildPinoOptions(opts);
+  const serializers = {
+    req: req => ({
+      method: req.method,
+      url: req.url,
+      version: req.headers && req.headers['accept-version'],
+      host: req.host,
+      remoteAddress: req.ip || (req.socket && req.socket.remoteAddress),
+      remotePort: req.socket && req.socket.remotePort,
+    }),
+    res: res => ({ statusCode: res.statusCode }),
+    err: pino.stdSerializers.err,
+    ...opts.serializers,
+  };
+  loggerOpts.serializers = {};
+  for (const [key, serialize] of Object.entries(serializers)) {
+    if (typeof serialize !== 'function') throw new TypeError(`Invalid serializer: ${key}`);
+    loggerOpts.serializers[key] = redactor
+      ? value => redactor.redactObject(serialize(value))
+      : serialize;
+  }
+  if (redactor) {
+    // Pino invokes formatters before serializers. Preserve their input objects
+    // (including prototypes/getters) and redact the serialized output instead.
+    loggerOpts.formatters.log = obj => {
+      const plain = {};
+      for (const key of Object.keys(obj)) {
+        if (!Object.hasOwn(serializers, key)) plain[key] = obj[key];
+      }
+      const safe = redactor.redactObject(plain);
+      for (const key of Object.keys(obj)) {
+        if (Object.hasOwn(serializers, key)) safe[key] = obj[key];
+      }
+      return safe;
+    };
+  }
+  return loggerOpts;
+}
+
+/** Capture the actual JSON records without a console or worker transport. */
+function createTestLogger(opts = {}) {
+  const records = [];
+  const logger = createLogger({
+    ...opts,
+    silent: opts.silent ?? false,
+    level: opts.level ?? 'trace',
+    destination: { write(line) { records.push(JSON.parse(line)); } },
+  });
+  return { logger, records };
+}
+
+module.exports.createPinoOptions = createPinoOptions;
+module.exports.createTestLogger = createTestLogger;
+
+module.exports.withSecretValues = require('./lib/secretScope').withSecretValues;

package/transports/pino.js

@@ -62,6 +62,11 @@ const CONTEXT_KEYS = [
   'jobId',
   'agentUuid',
   'commandId',
+  'collectionCycleId',
+  'runId',
+  'workId',
+  'stageId',
+  'deviceId',
 ];
 
 /**