@zudojs/logger 1.1.0 → 1.3.0

package/README.md

@@ -3,6 +3,12 @@
 Structured logging with transports, formatters, log levels, secret
 redaction, and context propagation for Zudojs applications.
 
+<!-- zudo-docs:start -->
+
+**Documentation:** [zudojs.oyinlola.site/docs/packages-logger](https://zudojs.oyinlola.site/docs/packages-logger) · **For AI agents:** [Markdown version](https://zudojs.oyinlola.site/docs/packages-logger.md), [llms.txt](https://zudojs.oyinlola.site/llms.txt)
+
+<!-- zudo-docs:end -->
+
 ## Installation
 
 ```bash
@@ -39,8 +45,21 @@ Built in: `createConsoleLoggerTransport`, and the composites
 `createBufferedLoggerTransport`. File and HTTP transports are not
 included — implement the `LoggerTransport` interface for those.
 
+The multi and conditional composites forward `flush()` and `close()` to
+the transports they wrap, so a buffered or file transport nested inside
+is drained and released by the logger's own `flush()`/`close()`. The
+multi transport writes to every sink even when one throws; the failures
+are reported afterwards (several as one `AggregateError`). The buffered
+transport writes each entry independently, so a failing write loses only
+that entry, and a failure from a timer-triggered flush is rethrown by the
+next `flush()` or `close()`.
+
 `transportTimeout` (default 10s) bounds every transport write, so a
-transport that stops responding cannot hang `flush()` or `close()`.
+transport that stops responding cannot hang `flush()` or `close()`. A
+write that exceeds it fails with `LoggerTimeoutError`, carrying
+`transportName` and `timeout`; other write failures are reported as
+`LoggerTransportError` with `transportName` set, and formatter failures
+as `LoggerFormatterError` with `formatterName` set.
 
 `throwTransportErrors` (default `false`) rethrows transport and formatter
 failures instead of dropping them. A synchronous transport throws from the
@@ -48,21 +67,41 @@ 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.
 
+`flush()` and `close()` isolate each transport: one that throws does not
+stop the rest from being flushed and closed, and `close()` always leaves
+the logger disposed. The failures are rethrown afterwards (several as one
+`AggregateError`).
+
 ## Flushing
 
 Dispatch completes synchronously when every transport is synchronous.
 With an asynchronous transport — or with `asynchronous: true`, which
 always defers so the caller stays off the transport's critical path —
 writes are in flight until drained. `flush()` and `close()` drain them,
-so nothing is lost at exit.
+including writes started by child loggers (`child()`, `withContext()`),
+so nothing is lost at exit. A child reports itself disposed once its root
+logger is closed.
 
 ## Secret redaction
 
 Redaction is **on by default**. Metadata and context fields whose NAME
-looks like a secret — password, secret, token, api key, private key,
-credential, authorization, cookie — are replaced with `"[REDACTED]"`
-before the entry reaches any formatter or transport. Nested objects,
-arrays and getters are all covered.
+looks like a secret are replaced with `"[REDACTED]"` before the entry
+reaches any formatter or transport. Names are split into words
+(`x-api-key`, `api_key` and `apiKey` all read as `api key`) and matched
+against `DEFAULT_LOGGER_SECRET_FIELDS` — password, passphrase, secret,
+token, jwt, bearer, auth, authorization, cookie, session, sid,
+credential, api key, private key, client secret, card number, cvv, ssn,
+pin, otp and more — so `sessionId` and `cardNumber` are redacted while
+`passenger` and `authorId` are not. Nested objects, arrays, `Map`,
+`Set` and getters are all covered — a `Map` is redacted per key and a
+`Set` becomes an array. A getter that THROWS yields `"[Unreadable]"`
+for that field: the rest of the entry is logged and the read failure is
+reported through the same path as transport and formatter failures
+(dropped by default, rethrown with `throwTransportErrors`), so a lazy
+ORM relation can never abort the caller's log statement. Passing
+`redact.pattern` replaces the word matcher with
+your own RegExp (the old substring default is still exported as
+`DEFAULT_LOGGER_SECRET_PATTERN`).
 
 ```typescript
 logger.info("login", { user: "alice", password: "hunter2" });
@@ -74,16 +113,22 @@ createLogger({ redact: { enabled: false } }); // opt out
 
 ## Log injection
 
-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` / `\u001b` rather than forging an extra log record or
-driving the operator's terminal. The JSON formatter relies on
+Text-shaped formatters escape control characters (C0, DEL, C1 and
+U+2028/U+2029) in the message, the level, the logger name, metadata keys
+and values, context values, source locations and error stacks. A newline
+or ANSI escape inside attacker-supplied text becomes `\n` / `\u001b`
+rather than forging an extra log record or driving the operator's
+terminal. In a stack trace only the frame lines break the line: the
+error's name and message are escaped as one line, and every frame line is
+indented so none can start at column 0 and pass for a record. The JSON formatter relies on
 `JSON.stringify`, which escapes the same characters.
 
 Metadata is normalized before serialization, so circular references
 (`"[Circular]"`), BigInt values and functions never make a formatter
-throw and silently drop the record.
+throw and silently drop the record. Only a genuine back-edge becomes
+`"[Circular]"` — the walk tracks the ancestor path, so an object
+referenced from two places in one payload (`{ actor: user, target: user }`)
+is logged in full both times.
 
 ## Context
 
@@ -118,6 +163,12 @@ Pass `{ colors: true }` in the formatter context to colourize the level
 tag of text output. Colour codes are emitted only around the fixed level
 name, never around user-supplied text.
 
+A formatter returns either a string or an object
+(`LoggerFormattedOutput`). A string becomes the payload's `message`; an
+object is merged OVER the entry, so `createStructuredLoggerFormatter()`
+hands the transport its structured record (with an ISO-string
+`timestamp` and serialized metadata) rather than the raw entry.
+
 ## Use Cases
 
 - Application logging

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

@@ -35,7 +35,13 @@ export declare class ZudojsLogger implements Logger, ZudojsLoggerContext {
     private readonly _pending;
     private readonly _dispatchFailures;
     private _droppedFailures;
-    constructor(options?: LoggerOptions, contextStorage?: LoggerContextStorage);
+    private readonly _root;
+    /**
+     * @param root - The logger this one was derived from. A child's
+     *   dispatches are tracked by its root, so the root's flush()/close()
+     *   drains them, and a child reports itself disposed once its root is.
+     */
+    constructor(options?: LoggerOptions, contextStorage?: LoggerContextStorage, root?: ZudojsLogger);
     get configuration(): LoggerConfiguration;
     get contextStorage(): LoggerContextStorage;
     get name(): string;

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

@@ -20,7 +20,14 @@ export class ZudojsLogger {
     _pending = new Set();
     _dispatchFailures = [];
     _droppedFailures = 0;
-    constructor(options = {}, contextStorage) {
+    _root;
+    /**
+     * @param root - The logger this one was derived from. A child's
+     *   dispatches are tracked by its root, so the root's flush()/close()
+     *   drains them, and a child reports itself disposed once its root is.
+     */
+    constructor(options = {}, contextStorage, root) {
+        this._root = root;
         this._configuration = resolveLoggerOptions(options);
         this._contextStorage = contextStorage ?? createLoggerContextStorage();
         this._configuration = normalizeConfiguration(this._configuration);
@@ -90,7 +97,7 @@ export class ZudojsLogger {
         return this._closing;
     }
     assertActive() {
-        assertActiveHelper(this._disposed, this._configuration.name);
+        assertActiveHelper(this.isDisposed(), this._configuration.name);
     }
     assertMutable() {
         assertMutableHelper(this._configuration.mutable);
@@ -99,7 +106,7 @@ export class ZudojsLogger {
         handleInfrastructureErrorHelper(this._configuration.throwTransportErrors, error);
     }
     isDisposed() {
-        return this._disposed;
+        return this._disposed || (this._root?.isDisposed() ?? false);
     }
     markDisposed() {
         this._disposed = true;
@@ -108,9 +115,13 @@ export class ZudojsLogger {
         this._configuration = Object.freeze(config);
     }
     createChildLogger(options) {
-        return new ZudojsLogger(options, this._contextStorage);
+        return new ZudojsLogger(options, this._contextStorage, this._root ?? this);
     }
     trackDispatch(dispatch) {
+        if (this._root) {
+            this._root.trackDispatch(dispatch);
+            return;
+        }
         // 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
@@ -134,6 +145,9 @@ export class ZudojsLogger {
         this._pending.add(tracked);
     }
     async drainDispatches() {
+        if (this._root) {
+            return this._root.drainDispatches();
+        }
         // A dispatch can start further dispatches (a transport that logs),
         // so drain until the set is genuinely empty.
         while (this._pending.size > 0) {

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

@@ -4,8 +4,8 @@
 import { formatLoggerEntry } from "../../../loggerFormatter/loggerFormatter.core.js";
 import { createLoggerTransport, writeLoggerTransport, } from "../../../loggerTransport/loggerTransport.core.js";
 import { isLoggerTransport } from "../../../loggerTransport/loggerTransportGuard.js";
-import { LoggerFormatterError, LoggerTransportError, } from "../../../loggerErrors/loggerError.base.js";
-import { toLoggerError } from "../../../loggerErrors/loggerError.helpers.js";
+import { LoggerFormatterError, LoggerTimeoutError, LoggerTransportError, } from "../../../loggerErrors/loggerError.base.js";
+import { createLoggerFormatterError, createLoggerTransportError, } from "../../../loggerErrors/loggerError.helpers.js";
 /**
  * Default formatter used when no formatter is configured.
  */
@@ -33,7 +33,11 @@ async function withTransportTimeout(timeoutMs, transportName, operation) {
     let timer;
     const expiry = new Promise((_resolve, reject) => {
         timer = setTimeout(() => {
-            reject(new LoggerTransportError(`Transport "${transportName}" did not complete within ${timeoutMs}ms.`));
+            // LoggerTimeoutError carries `transportName` and `timeout`, which
+            // the bare LoggerTransportError raised here before did not — so
+            // `catch (e) { if (e instanceof LoggerTimeoutError) retry() }`
+            // could never match.
+            reject(new LoggerTimeoutError(transportName, timeoutMs));
         }, timeoutMs);
         // This timer bounds a write; it is not work in its own right. Left
         // referenced it keeps the event loop alive, so a process that has
@@ -53,6 +57,50 @@ async function withTransportTimeout(timeoutMs, transportName, operation) {
         void operation.catch(() => { });
     }
 }
+/**
+ * Builds the payload handed to a transport.
+ *
+ * `LoggerFormattedOutput` is `string | Record<string, unknown>`. A
+ * string replaces the message; an OBJECT is the formatted record and is
+ * merged over the entry, so a transport sees the formatter's fields.
+ * The object branch used to be computed and then discarded, which made
+ * `createStructuredLoggerFormatter()` pure overhead on every log call
+ * and handed the transport the raw, unformatted entry instead.
+ */
+function toTransportPayload(entry, formatted) {
+    if (typeof formatted === "string") {
+        return { ...entry, message: formatted };
+    }
+    if (formatted !== null &&
+        typeof formatted === "object" &&
+        !Array.isArray(formatted)) {
+        return {
+            ...entry,
+            ...formatted,
+        };
+    }
+    return entry;
+}
+/** Name of the configured formatter, for error reporting. */
+function resolveFormatterName(configuration) {
+    const formatter = configuration.formatter;
+    if (typeof formatter === "string") {
+        return formatter;
+    }
+    return formatter.name ?? "formatter";
+}
+/** Wraps a transport failure, keeping an already-typed logger error. */
+function toTransportError(transportName, error) {
+    return error instanceof LoggerTransportError
+        ? error
+        : createLoggerTransportError(transportName, error);
+}
+/** Wraps a formatter failure, keeping an already-typed logger error. */
+function toFormatterError(formatterName, error) {
+    return error instanceof LoggerFormatterError
+        ? error
+        : createLoggerFormatterError(formatterName, error);
+}
 /**
  * Writes to a transport.
  */
@@ -61,12 +109,7 @@ async function writeTransport(configuration, transport, entry, formatted) {
         loggerName: configuration.name,
         environment: configuration.environment,
     };
-    if (typeof formatted === "string") {
-        const formattedEntry = { ...entry, message: formatted };
-        await writeLoggerTransport(transport.transport, formattedEntry, transportContext);
-        return;
-    }
-    await writeLoggerTransport(transport.transport, entry, transportContext);
+    await writeLoggerTransport(transport.transport, toTransportPayload(entry, formatted), transportContext);
 }
 /**
  * Formats an entry with the configured formatter.
@@ -94,7 +137,7 @@ function writeTransportMaybeSync(configuration, transport, entry, formatted) {
         loggerName: configuration.name,
         environment: configuration.environment,
     };
-    const payload = typeof formatted === "string" ? { ...entry, message: formatted } : entry;
+    const payload = toTransportPayload(entry, formatted);
     const target = transport.transport;
     return typeof target === "function"
         ? target(payload, transportContext)
@@ -109,24 +152,24 @@ export async function dispatchEntry(configuration, entry, handleError) {
         formatted = formatEntry(configuration, entry);
     }
     catch (error) {
-        const formatterError = new LoggerFormatterError(`Failed to format log entry: ${toLoggerError(error).message}`, { cause: error });
-        handleError(formatterError);
+        handleError(toFormatterError(resolveFormatterName(configuration), error));
         return;
     }
     for (const transport of configuration.transports) {
+        let transportName = "transport";
         try {
             if (!isLoggerTransport(transport)) {
                 continue;
             }
             const registered = createLoggerTransport(transport);
+            transportName = registered.name;
             if (!registered.enabled) {
                 continue;
             }
             await withTransportTimeout(configuration.transportTimeout, registered.name, writeTransport(configuration, registered, entry, formatted));
         }
         catch (error) {
-            const transportError = new LoggerTransportError(`Failed to write log entry: ${toLoggerError(error).message}`, { cause: error });
-            handleError(transportError);
+            handleError(toTransportError(transportName, error));
         }
     }
 }
@@ -153,28 +196,30 @@ export function dispatchEntrySync(configuration, entry, handleError) {
         formatted = formatEntry(configuration, entry);
     }
     catch (error) {
-        handleError(new LoggerFormatterError(`Failed to format log entry: ${toLoggerError(error).message}`, { cause: error }));
+        handleError(toFormatterError(resolveFormatterName(configuration), error));
         return;
     }
     const pending = [];
     for (const transport of configuration.transports) {
+        let transportName = "transport";
         try {
             if (!isLoggerTransport(transport)) {
                 continue;
             }
             const registered = createLoggerTransport(transport);
+            transportName = registered.name;
             if (!registered.enabled) {
                 continue;
             }
             const result = writeTransportMaybeSync(configuration, registered, entry, formatted);
             if (result instanceof Promise) {
                 pending.push(withTransportTimeout(configuration.transportTimeout, registered.name, result).catch((error) => {
-                    handleError(new LoggerTransportError(`Failed to write log entry: ${toLoggerError(error).message}`, { cause: error }));
+                    handleError(toTransportError(registered.name, error));
                 }));
             }
         }
         catch (error) {
-            handleError(new LoggerTransportError(`Failed to write log entry: ${toLoggerError(error).message}`, { cause: error }));
+            handleError(toTransportError(transportName, error));
         }
     }
     if (pending.length === 0) {

package/dist/loggerCore/helpers/loggerCoreMethods/loggerCoreMethods.entry.d.ts

@@ -6,8 +6,13 @@ import type { LoggerEntry } from "../../../loggerEntry/loggerEntry.type.js";
 import type { LoggerConfiguration, LogOptions } from "../../../loggerOptions/loggerOptions.type.js";
 /**
  * Creates a normalized log entry.
+ *
+ * @param onMetadataError - Notified when a metadata property could not
+ *   be read (a throwing getter). The field is replaced with a marker
+ *   and the entry is still produced, so the caller's log statement
+ *   never aborts; reporting is the caller's job.
  */
 export declare function createEntry(configuration: LoggerConfiguration, contextStorage: {
     get(): import("../../../loggerContext/loggerContext.core.js").LoggerContext | undefined;
-}, level: LoggerLevel, message: string, options: LogOptions): LoggerEntry;
+}, level: LoggerLevel, message: string, options: LogOptions, onMetadataError?: (key: string, error: unknown) => void): LoggerEntry;
 //# sourceMappingURL=loggerCoreMethods.entry.d.ts.map

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

@@ -6,8 +6,13 @@ import { createSecretMatcher, redactLogValue, LOGGER_REDACTION_TOKEN, } from "..
 import { contextToLogMetadata, createLoggerContext, } from "../../../loggerContext/loggerContext.core.js";
 /**
  * Creates a normalized log entry.
+ *
+ * @param onMetadataError - Notified when a metadata property could not
+ *   be read (a throwing getter). The field is replaced with a marker
+ *   and the entry is still produced, so the caller's log statement
+ *   never aborts; reporting is the caller's job.
  */
-export function createEntry(configuration, contextStorage, level, message, options) {
+export function createEntry(configuration, contextStorage, level, message, options, onMetadataError) {
     const activeContext = configuration.inheritContext
         ? contextStorage.get()
         : undefined;
@@ -29,7 +34,7 @@ export function createEntry(configuration, contextStorage, level, message, optio
     // path can bypass it — including nested objects, arrays and getters.
     const isSecret = createSecretMatcher(configuration.redact);
     const replacement = configuration.redact.replacement ?? LOGGER_REDACTION_TOKEN;
-    const metadata = redactLogValue(rawMetadata, isSecret, replacement);
+    const metadata = redactLogValue(rawMetadata, isSecret, replacement, undefined, onMetadataError);
     const context = options.context
         ? createLoggerContext({
             parent: activeContext,
@@ -46,7 +51,7 @@ export function createEntry(configuration, contextStorage, level, message, optio
         context: context
             ? {
                 ...context.identifiers,
-                metadata: redactLogValue(context.metadata, isSecret, replacement),
+                metadata: redactLogValue(context.metadata, isSecret, replacement, undefined, onMetadataError),
             }
             : undefined,
         source: options.source,

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

@@ -2,7 +2,8 @@
  * ZudojsLogger level methods.
  */
 import { LoggerLevel, shouldLog, } from "../../../loggerLevel/loggerLevel.type.js";
-import { LoggerConfigurationError } from "../../../loggerErrors/loggerError.base.js";
+import { InvalidLoggerEntryError, LoggerConfigurationError, } from "../../../loggerErrors/loggerError.base.js";
+import { toLoggerError } from "../../../loggerErrors/loggerError.helpers.js";
 import { createEntry } from "./loggerCoreMethods.entry.js";
 import { dispatchEntrySync } from "./loggerCoreMethods.dispatch.js";
 /**
@@ -17,7 +18,24 @@ export function logAtLevel(ctx, level, message, options = {}) {
     if (typeof message !== "string") {
         throw new LoggerConfigurationError("Logger message must be a string.");
     }
-    const entry = createEntry(ctx.configuration, ctx.contextStorage, level, message, options);
+    // Entry construction reads caller-supplied metadata, including
+    // getters. A throwing accessor used to propagate straight out of
+    // logger.info(...) and abort the caller — and only when the level
+    // let the call through, so the same code was a silent no-op at one
+    // log level and a crash at another. The offending field becomes a
+    // marker and the failure is reported like every other infrastructure
+    // failure, AFTER the line has been dispatched.
+    const metadataFailures = [];
+    let entry;
+    try {
+        entry = createEntry(ctx.configuration, ctx.contextStorage, level, message, options, (key, error) => {
+            metadataFailures.push(new InvalidLoggerEntryError(`Failed to read log metadata field "${key}": ${toLoggerError(error).message}`, { cause: error }));
+        });
+    }
+    catch (error) {
+        ctx.handleInfrastructureError(new InvalidLoggerEntryError(`Failed to build log entry: ${toLoggerError(error).message}`, { cause: error }));
+        return;
+    }
     // Dispatch is asynchronous. It used to be fired and forgotten, so
     // flush() and close() could return while entries were still in
     // flight — messages were lost on process exit. Registering the
@@ -26,5 +44,8 @@ export function logAtLevel(ctx, level, message, options = {}) {
     if (dispatch) {
         ctx.trackDispatch(dispatch);
     }
+    for (const failure of metadataFailures) {
+        ctx.handleInfrastructureError(failure);
+    }
 }
 //# sourceMappingURL=loggerCoreMethods.level.js.map

package/dist/loggerCore/helpers/loggerCoreMethods/loggerCoreMethods.lifecycle.d.ts

@@ -17,10 +17,19 @@ export declare function enableLogger(ctx: ZudojsLoggerContext): void;
 export declare function disableLogger(ctx: ZudojsLoggerContext): void;
 /**
  * Flushes all transport buffers.
+ *
+ * In-flight dispatches land in the transports before they are flushed.
+ * Every transport is flushed even when a dispatch or another transport
+ * failed; the failures are rethrown afterwards (several as one
+ * AggregateError).
  */
 export declare function flushLogger(ctx: ZudojsLoggerContext): Promise<void>;
 /**
  * Closes all transports and marks logger as disposed.
+ *
+ * Closing is terminal: every transport is flushed and closed and the
+ * logger is marked disposed even when a dispatch or a transport failed;
+ * the failures are rethrown afterwards.
  */
 export declare function closeLogger(ctx: ZudojsLoggerContext): Promise<void>;
 //# sourceMappingURL=loggerCoreMethods.lifecycle.d.ts.map

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

@@ -5,6 +5,7 @@ import { LoggerLevel } from "../../../loggerLevel/loggerLevel.type.js";
 import { createLoggerTransport } from "../../../loggerTransport/loggerTransport.core.js";
 import { isLoggerTransport } from "../../../loggerTransport/loggerTransportGuard.js";
 import { LoggerConfigurationError } from "../../../loggerErrors/loggerError.base.js";
+import { throwCollectedFailures } from "../../../loggerErrors/loggerError.helpers.js";
 /**
  * Sets the logger level.
  */
@@ -44,72 +45,73 @@ export function disableLogger(ctx) {
     });
 }
 /**
- * Flushes all transport buffers.
+ * Flushes (and optionally closes) every configured transport, isolating
+ * each one: a failing sink is collected and the walk continues, so one
+ * bad transport cannot leave every later transport unflushed/unclosed.
  */
-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. 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;
-    }
+async function settleTransports(ctx, close, failures) {
     for (const transport of ctx.configuration.transports) {
-        if (!isLoggerTransport(transport)) {
+        if (!isLoggerTransport(transport))
             continue;
-        }
         const registered = createLoggerTransport(transport);
-        if (!registered.enabled) {
+        if (!close && !registered.enabled)
             continue;
+        const steps = close
+            ? [() => registered.flush?.(), () => registered.close?.()]
+            : [() => registered.flush?.()];
+        for (const step of steps) {
+            try {
+                await step();
+            }
+            catch (error) {
+                failures.push(error);
+            }
         }
-        if (registered.flush) {
-            await registered.flush();
-        }
     }
-    if (failed)
-        throw failure;
+}
+/** Drains in-flight dispatches, collecting (not throwing) a failure. */
+async function drainInto(ctx, failures) {
+    try {
+        await ctx.drainDispatches();
+    }
+    catch (error) {
+        failures.push(error);
+    }
+}
+/**
+ * Flushes all transport buffers.
+ *
+ * In-flight dispatches land in the transports before they are flushed.
+ * Every transport is flushed even when a dispatch or another transport
+ * failed; the failures are rethrown afterwards (several as one
+ * AggregateError).
+ */
+export async function flushLogger(ctx) {
+    ctx.assertActive();
+    const failures = [];
+    await drainInto(ctx, failures);
+    await settleTransports(ctx, false, failures);
+    throwCollectedFailures(failures, "Logger flush failed.");
 }
 /**
  * Closes all transports and marks logger as disposed.
+ *
+ * Closing is terminal: every transport is flushed and closed and the
+ * logger is marked disposed even when a dispatch or a transport failed;
+ * the failures are rethrown afterwards.
  */
 export async function closeLogger(ctx) {
     if (ctx.isDisposed()) {
         return;
     }
-    // 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;
+    const failures = [];
     try {
-        await ctx.drainDispatches();
+        await drainInto(ctx, failures);
+        await settleTransports(ctx, true, failures);
     }
-    catch (error) {
-        failure = error;
-        failed = true;
-    }
-    for (const transport of ctx.configuration.transports) {
-        if (!isLoggerTransport(transport)) {
-            continue;
-        }
-        const registered = createLoggerTransport(transport);
-        if (registered.flush) {
-            await registered.flush();
-        }
-        if (registered.close) {
-            await registered.close();
-        }
+    finally {
+        ctx.markDisposed();
     }
-    ctx.markDisposed();
-    if (failed)
-        throw failure;
+    throwCollectedFailures(failures, "Logger close failed.");
 }
 //# sourceMappingURL=loggerCoreMethods.lifecycle.js.map

package/dist/loggerEntry/index.d.ts

@@ -5,4 +5,5 @@
  */
 export * from "./loggerEntryHelpers/index.js";
 export * from "./loggerEntry.core.js";
+export { DEFAULT_LOGGER_SECRET_FIELDS, createDefaultSecretFieldMatcher, } from "./loggerEntry.secretFields.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/loggerEntry/index.js

@@ -5,4 +5,5 @@
  */
 export * from "./loggerEntryHelpers/index.js";
 export * from "./loggerEntry.core.js";
+export { DEFAULT_LOGGER_SECRET_FIELDS, createDefaultSecretFieldMatcher, } from "./loggerEntry.secretFields.js";
 //# sourceMappingURL=index.js.map

package/dist/loggerEntry/loggerEntry.secretFields.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Default secret-field matching for logger redaction.
+ *
+ * Field names are split into words (`x-api-key`, `api_key` and `apiKey`
+ * all become `api key`) and matched on whole-word runs, the same scheme
+ * @zudojs/observability's `isSensitiveField` uses. A raw substring test
+ * redacted `passenger`, `compass` and `bypassCache` (they contain `pass`)
+ * while missing `auth`, `sessionId`, `sid`, `jwt`, `ssn`, `cardNumber`,
+ * `cvv` and `otp` entirely.
+ */
+/**
+ * Secret field names matched on whole words by default.
+ */
+export declare const DEFAULT_LOGGER_SECRET_FIELDS: readonly string[];
+/**
+ * Builds the default secret-field predicate from a word list.
+ */
+export declare function createDefaultSecretFieldMatcher(fields?: readonly string[]): (key: string) => boolean;
+//# sourceMappingURL=loggerEntry.secretFields.d.ts.map