@zudojs/logger 1.0.0 → 1.1.0

package/README.md

@@ -42,6 +42,12 @@ included — implement the `LoggerTransport` interface for those.
 `transportTimeout` (default 10s) bounds every transport write, so a
 transport that stops responding cannot hang `flush()` or `close()`.
 
+`throwTransportErrors` (default `false`) rethrows transport and formatter
+failures instead of dropping them. A synchronous transport throws from the
+log call itself; a failure from an asynchronous transport (or with
+`asynchronous: true`) cannot, so it is rethrown by the next `flush()` or
+`close()`, which still flush and close the transports first.
+
 ## Flushing
 
 Dispatch completes synchronously when every transport is synchronous.
@@ -71,7 +77,7 @@ createLogger({ redact: { enabled: false } }); // opt out
 Text-shaped formatters escape control characters in the message, the
 logger name, metadata keys and values, context values and source
 locations. A newline or ANSI escape inside attacker-supplied text
-becomes `\n` / `` rather than forging an extra log record or
+becomes `\n` / `\u001b` rather than forging an extra log record or
 driving the operator's terminal. The JSON formatter relies on
 `JSON.stringify`, which escapes the same characters.
 
@@ -94,6 +100,11 @@ withLoggerContext(logger, createLoggerContext({ traceId }), (scoped) => {
 });
 ```
 
+Per-call context is merged into the entry's metadata the same way:
+`logger.log(LoggerLevel.INFO, "handled", { context: { tenant: "acme" } })`.
+The entry's `context` also carries the identifiers (`requestId`, `traceId`,
+...) of the active context for transports that read them directly.
+
 Child loggers inherit name, level, formatter, transports, metadata and
 redaction settings: `logger.child({ name: "api.db" })`.
 

package/dist/loggerCore/core/loggerCore.core.d.ts

@@ -31,7 +31,10 @@ export declare class ZudojsLogger implements Logger, ZudojsLoggerContext {
     private _configuration;
     private readonly _contextStorage;
     private _disposed;
+    private _closing;
     private readonly _pending;
+    private readonly _dispatchFailures;
+    private _droppedFailures;
     constructor(options?: LoggerOptions, contextStorage?: LoggerContextStorage);
     get configuration(): LoggerConfiguration;
     get contextStorage(): LoggerContextStorage;

package/dist/loggerCore/core/loggerCore.core.js

@@ -7,6 +7,8 @@ import { resolveLoggerOptions } from "../../loggerOptions/loggerOptions.type.js"
 import { normalizeConfiguration, assertActive as assertActiveHelper, assertMutable as assertMutableHelper, handleInfrastructureError as handleInfrastructureErrorHelper, } from "../helpers/loggerCoreHelpers.js";
 import { logAtLevel, childLogger, withContextLogger, setLoggerLevel, enableLogger, disableLogger, flushLogger, closeLogger, } from "../helpers/loggerCoreMethods/index.js";
 import { getLoggerName, getLoggerLevel, getLoggerEnabled, } from "../helpers/loggerCoreMethods.loggerProps.js";
+/** Upper bound on dispatch failures retained between two flushes. */
+const MAX_RETAINED_DISPATCH_FAILURES = 32;
 /**
  * Logger implementation.
  */
@@ -14,7 +16,10 @@ export class ZudojsLogger {
     _configuration;
     _contextStorage;
     _disposed = false;
+    _closing;
     _pending = new Set();
+    _dispatchFailures = [];
+    _droppedFailures = 0;
     constructor(options = {}, contextStorage) {
         this._configuration = resolveLoggerOptions(options);
         this._contextStorage = contextStorage ?? createLoggerContextStorage();
@@ -75,7 +80,14 @@ export class ZudojsLogger {
         return flushLogger(this);
     }
     close() {
-        return closeLogger(this);
+        // Concurrent callers share one closure: two overlapping close() calls
+        // used to drain and close every transport twice.
+        if (this._closing)
+            return this._closing;
+        this._closing = closeLogger(this).finally(() => {
+            this._closing = undefined;
+        });
+        return this._closing;
     }
     assertActive() {
         assertActiveHelper(this._disposed, this._configuration.name);
@@ -99,11 +111,23 @@ export class ZudojsLogger {
         return new ZudojsLogger(options, this._contextStorage);
     }
     trackDispatch(dispatch) {
-        // dispatchEntry routes its own failures through handleError, so a
-        // rejection here is unexpected; swallow it to keep an unawaited log
-        // call from crashing the process, and keep the entry drainable.
+        // A dispatch rejects only when handleError threw — i.e. when
+        // `throwTransportErrors` is on and an asynchronous transport failed.
+        // Nothing can throw from the log call that started it, so the failure
+        // is kept (bounded) and surfaced by the next flush()/close(); it was
+        // previously swallowed outright, which made the option a no-op for
+        // every asynchronous transport.
         const tracked = dispatch
-            .catch(() => { })
+            .then(() => { }, (error) => {
+            if (!this._configuration.throwTransportErrors)
+                return;
+            if (this._dispatchFailures.length < MAX_RETAINED_DISPATCH_FAILURES) {
+                this._dispatchFailures.push(error);
+            }
+            else {
+                this._droppedFailures += 1;
+            }
+        })
             .finally(() => {
             this._pending.delete(tracked);
         });
@@ -115,6 +139,14 @@ export class ZudojsLogger {
         while (this._pending.size > 0) {
             await Promise.all([...this._pending]);
         }
+        if (this._dispatchFailures.length === 0)
+            return;
+        const failures = this._dispatchFailures.splice(0);
+        const dropped = this._droppedFailures;
+        this._droppedFailures = 0;
+        if (failures.length === 1 && dropped === 0)
+            throw failures[0];
+        throw new AggregateError(failures, `${failures.length + dropped} log dispatch(es) failed since the last flush.`);
     }
 }
 /**

package/dist/loggerCore/helpers/loggerCoreMethods/loggerCoreMethods.entry.js

@@ -14,9 +14,14 @@ export function createEntry(configuration, contextStorage, level, message, optio
     const contextMetadata = activeContext
         ? contextToLogMetadata(activeContext)
         : {};
+    // Per-call `options.context` flows into metadata exactly like the ambient
+    // context does. It used to reach only `entry.context.metadata`, which the
+    // text formatters never print, so `log(level, msg, { context })` silently
+    // dropped the data from every text-shaped line.
     const rawMetadata = {
         ...configuration.metadata,
         ...contextMetadata,
+        ...(options.context ?? {}),
         ...(options.metadata ?? {}),
     };
     // Redaction is applied HERE, before the entry is frozen, so every
@@ -35,8 +40,12 @@ export function createEntry(configuration, contextStorage, level, message, optio
         level,
         message,
         metadata,
+        // `LoggerEntryContext` declares the correlation identifiers, but they
+        // were never copied here, so a transport reading `entry.context.requestId`
+        // always saw `undefined`.
         context: context
             ? {
+                ...context.identifiers,
                 metadata: redactLogValue(context.metadata, isSecret, replacement),
             }
             : undefined,

package/dist/loggerCore/helpers/loggerCoreMethods/loggerCoreMethods.lifecycle.js

@@ -50,8 +50,18 @@ export async function flushLogger(ctx) {
     ctx.assertActive();
     // In-flight dispatches must land in the transports before those
     // transports are asked to flush, otherwise flush() is a no-op for
-    // everything logged in the same tick.
-    await ctx.drainDispatches();
+    // everything logged in the same tick. A dispatch failure (surfaced
+    // when `throwTransportErrors` is on) is rethrown only after the
+    // transports have still been flushed.
+    let failure;
+    let failed = false;
+    try {
+        await ctx.drainDispatches();
+    }
+    catch (error) {
+        failure = error;
+        failed = true;
+    }
     for (const transport of ctx.configuration.transports) {
         if (!isLoggerTransport(transport)) {
             continue;
@@ -64,6 +74,8 @@ export async function flushLogger(ctx) {
             await registered.flush();
         }
     }
+    if (failed)
+        throw failure;
 }
 /**
  * Closes all transports and marks logger as disposed.
@@ -72,7 +84,18 @@ export async function closeLogger(ctx) {
     if (ctx.isDisposed()) {
         return;
     }
-    await ctx.drainDispatches();
+    // Closing is terminal: transports are flushed and closed and the logger
+    // is marked disposed even when a dispatch failed; the failure is rethrown
+    // afterwards.
+    let failure;
+    let failed = false;
+    try {
+        await ctx.drainDispatches();
+    }
+    catch (error) {
+        failure = error;
+        failed = true;
+    }
     for (const transport of ctx.configuration.transports) {
         if (!isLoggerTransport(transport)) {
             continue;
@@ -86,5 +109,7 @@ export async function closeLogger(ctx) {
         }
     }
     ctx.markDisposed();
+    if (failed)
+        throw failure;
 }
 //# sourceMappingURL=loggerCoreMethods.lifecycle.js.map

package/dist/loggerEntry/loggerEntryHelpers/loggerEntryHelpers.sanitize.js

@@ -62,7 +62,13 @@ export function createSecretMatcher(options = {}) {
     if (options.enabled === false) {
         return () => false;
     }
-    const pattern = options.pattern ?? DEFAULT_LOGGER_SECRET_PATTERN;
+    // Copy the pattern without `g`/`y`: those flags make `test()` advance
+    // `lastIndex`, so a shared pattern would match a secret-named field on
+    // one entry and let it through unredacted on the next.
+    const configured = options.pattern ?? DEFAULT_LOGGER_SECRET_PATTERN;
+    const pattern = configured.global || configured.sticky
+        ? new RegExp(configured.source, configured.flags.replace(/[gy]/gu, ""))
+        : configured;
     const exact = new Set((options.keys ?? []).map((key) => key.toLowerCase()));
     return (key) => exact.has(key.toLowerCase()) || pattern.test(key);
 }

package/dist/loggerFormatter/loggerFormatterFormatters/loggerFormatterFormatters.context.js

@@ -17,6 +17,12 @@ export function formatContext(entry) {
         if (typeof value === "object") {
             continue;
         }
+        // Context identifiers are also flattened into metadata; skip the ones
+        // the metadata block already prints so a line never repeats itself.
+        if (Object.hasOwn(entry.metadata, key) &&
+            entry.metadata[key] === value) {
+            continue;
+        }
         values.push(`${escapeLogText(key)}=${escapeLogText(String(value))}`);
     }
     return values.length > 0 ? `[${values.join(" ")}]` : "";

package/dist/loggerTransport/loggerTransportComposite/loggerTransportComposite.buffered.js

@@ -34,6 +34,10 @@ export function createBufferedLoggerTransport(transport, options = {}) {
                 /* deliberate no-op */
             }
         }, flushInterval);
+        // A pending flush is housekeeping, not work: left referenced it kept a
+        // finished process alive for a full `flushInterval`. close() flushes
+        // whatever is buffered, so nothing is lost by letting the loop exit.
+        timer.unref?.();
     };
     const buffered = {
         name: options.name ?? "buffered",

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@zudojs/logger",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Structured logging with transports, log levels, and context propagation for Zudojs applications.",
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -24,7 +28,7 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@zudojs/errors": "1.0.0"
+    "@zudojs/errors": "1.0.1"
   },
   "devDependencies": {
     "typescript": "7.0.2",