@zudojs/logger 0.1.0 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zudojs Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,7 @@
 # @zudojs/logger
 
-Structured logging with transports, log levels, and context propagation for Zudojs applications.
+Structured logging with transports, formatters, log levels, secret
+redaction, and context propagation for Zudojs applications.
 
 ## Installation
 
@@ -17,16 +18,105 @@ const logger = createLogger({ name: "api" });
 
 logger.info("Server started", { port: 3000, env: "production" });
 logger.error("Connection failed", { error: err.message });
+
+await logger.flush(); // drain in-flight writes before exit
+```
+
+## Levels
+
+`fatal` (0), `error` (1), `warn` (2), `info` (3), `debug` (4), `trace`
+(5). A logger emits every message at or below its configured level;
+`level` defaults to `info`.
+
+## Transports
+
+A transport is either a `{ name, enabled, write, flush?, close? }`
+object or a `(entry, context) => void | Promise<void>` function. When no
+transport is configured the logger writes to the console.
+
+Built in: `createConsoleLoggerTransport`, and the composites
+`createMultiLoggerTransport`, `createConditionalLoggerTransport` and
+`createBufferedLoggerTransport`. File and HTTP transports are not
+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.
+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.
+
+## 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.
+
+```typescript
+logger.info("login", { user: "alice", password: "hunter2" });
+// metadata: { user: "alice", password: "[REDACTED]" }
+
+createLogger({ redact: { keys: ["ssn"], replacement: "***" } });
+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
+`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.
+
+## Context
+
+```typescript
+import { createLoggerContext, withLoggerContext } from "@zudojs/logger";
+
+const scoped = logger.withContext(
+  createLoggerContext({ requestId: "req-1", metadata: { tenant: "acme" } }),
+);
+scoped.info("handled"); // metadata carries requestId and tenant
+
+withLoggerContext(logger, createLoggerContext({ traceId }), (scoped) => {
+  scoped.info("inside the trace");
+});
 ```
 
-## Features
+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" })`.
+
+## Formatters
+
+`createTextLoggerFormatter`, `createJsonLoggerFormatter`,
+`createCompactLoggerFormatter`, `createDevelopmentLoggerFormatter`,
+`createProductionLoggerFormatter`, `createStructuredLoggerFormatter`.
 
-- Structured JSON logging
-- Log levels: debug, info, warn, error
-- Multiple transports (console, file, HTTP)
-- Child loggers with inherited context
-- Correlation ID propagation
-- Sensitive data redaction
+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.
 
 ## Use Cases
 

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

@@ -3,7 +3,7 @@
  */
 import type { LoggerLevel } from "../../loggerLevel/loggerLevel.type.js";
 import type { LogMetadata } from "../../loggerEntry/loggerEntry.type.js";
-import type { LoggerContext } from "../../loggerContext/loggerContext.core.js";
+import type { LoggerContext, LoggerContextStorage } from "../../loggerContext/loggerContext.core.js";
 import type { ChildLoggerOptions, LogOptions } from "../../loggerOptions/loggerOptions.type.js";
 import type { Logger } from "./loggerCore.type.js";
 /**
@@ -12,7 +12,14 @@ import type { Logger } from "./loggerCore.type.js";
 export declare class ContextLogger implements Logger {
     private readonly logger;
     private readonly context;
-    constructor(logger: Logger, context: LoggerContext);
+    private readonly storage;
+    /**
+     * @param storage The context storage the WRAPPED logger reads from.
+     *   This used to be created fresh inside `run()`, so the scoped
+     *   context was written into a throwaway stack and never reached the
+     *   entry — withContext() silently produced context-free logs.
+     */
+    constructor(logger: Logger, context: LoggerContext, storage: LoggerContextStorage);
     get name(): string;
     get level(): LoggerLevel;
     get enabled(): boolean;

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

@@ -2,16 +2,23 @@
  * ContextLogger wrapper implementation.
  */
 import { createLoggerContext } from "../../loggerContext/loggerContext.core.js";
-import { createLoggerContextStorage } from "../../loggerContext/loggerContextStorage.js";
 /**
  * Logger wrapper that provides scoped context.
  */
 export class ContextLogger {
     logger;
     context;
-    constructor(logger, context) {
+    storage;
+    /**
+     * @param storage The context storage the WRAPPED logger reads from.
+     *   This used to be created fresh inside `run()`, so the scoped
+     *   context was written into a throwaway stack and never reached the
+     *   entry — withContext() silently produced context-free logs.
+     */
+    constructor(logger, context, storage) {
         this.logger = logger;
         this.context = context;
+        this.storage = storage;
     }
     get name() {
         return this.logger.name;
@@ -44,14 +51,14 @@ export class ContextLogger {
         this.run(() => this.logger.log(level, message, options));
     }
     child(options) {
-        return new ContextLogger(this.logger.child(options), this.context);
+        return new ContextLogger(this.logger.child(options), this.context, this.storage);
     }
     withContext(context) {
         return new ContextLogger(this.logger, createLoggerContext({
             parent: this.context,
             ...context.identifiers,
             metadata: context.metadata,
-        }));
+        }), this.storage);
     }
     setLevel(level) {
         this.logger.setLevel(level);
@@ -69,8 +76,7 @@ export class ContextLogger {
         return this.logger.close();
     }
     run(callback) {
-        const storage = createLoggerContextStorage();
-        storage.run(this.context, callback);
+        this.storage.run(this.context, callback);
     }
 }
 //# sourceMappingURL=loggerCore.context.js.map

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

@@ -19,6 +19,10 @@ export interface ZudojsLoggerContext {
     markDisposed(): void;
     updateConfiguration(config: LoggerConfiguration): void;
     createChildLogger(options: LoggerOptions): Logger;
+    /** Registers an in-flight dispatch so it can be awaited later. */
+    trackDispatch(dispatch: Promise<void>): void;
+    /** Resolves once every registered dispatch has settled. */
+    drainDispatches(): Promise<void>;
 }
 /**
  * Logger implementation.
@@ -27,6 +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;
@@ -54,6 +62,8 @@ export declare class ZudojsLogger implements Logger, ZudojsLoggerContext {
     markDisposed(): void;
     updateConfiguration(config: LoggerConfiguration): void;
     createChildLogger(options: LoggerOptions): Logger;
+    trackDispatch(dispatch: Promise<void>): void;
+    drainDispatches(): Promise<void>;
 }
 /**
  * Creates a Zudojs logger.

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,6 +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();
@@ -74,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);
@@ -97,6 +110,44 @@ export class ZudojsLogger {
     createChildLogger(options) {
         return new ZudojsLogger(options, this._contextStorage);
     }
+    trackDispatch(dispatch) {
+        // 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
+            .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);
+        });
+        this._pending.add(tracked);
+    }
+    async drainDispatches() {
+        // A dispatch can start further dispatches (a transport that logs),
+        // so drain until the set is genuinely empty.
+        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.`);
+    }
 }
 /**
  * Creates a Zudojs logger.

package/dist/loggerCore/helpers/loggerCore.helper.d.ts

@@ -14,9 +14,14 @@ export declare function createChildLogger(parent: Logger, options?: ChildLoggerO
  */
 export declare function logError(logger: Logger, error: Error, message?: string, metadata?: LogMetadata): void;
 /**
- * Creates a logger context and executes a callback inside it.
+ * Creates a context-scoped logger and runs a callback with it.
+ *
+ * The scoped logger is passed to the callback. Both branches of the
+ * previous implementation were identical and simply discarded the
+ * scoped logger, so the context never applied to anything the callback
+ * logged.
  */
-export declare function withLoggerContext<T>(logger: Logger, context: LoggerContext, callback: () => T): T;
+export declare function withLoggerContext<T>(logger: Logger, context: LoggerContext, callback: (scoped: Logger) => T): T;
 /**
  * Creates a default application logger.
  */

package/dist/loggerCore/helpers/loggerCore.helper.js

@@ -1,9 +1,9 @@
 /**
  * Logger helper functions.
  */
+import { LoggerLevel } from "../../loggerLevel/loggerLevel.type.js";
 import { createTextLoggerFormatter } from "../../loggerFormatter/loggerFormatterFormatters/loggerFormatterFormatters.text.js";
 import { createConsoleLoggerTransport } from "../../loggerTransport/loggerTransport.registry.js";
-import { ContextLogger } from "../core/loggerCore.context.js";
 import { createLogger } from "../core/loggerCore.core.js";
 /**
  * Creates a child logger.
@@ -18,20 +18,21 @@ export function logError(logger, error, message, metadata) {
     if (!logger.enabled) {
         return;
     }
-    logger.log(1, message ?? error.message, {
+    logger.log(LoggerLevel.ERROR, message ?? error.message, {
         metadata,
         error,
     });
 }
 /**
- * Creates a logger context and executes a callback inside it.
+ * Creates a context-scoped logger and runs a callback with it.
+ *
+ * The scoped logger is passed to the callback. Both branches of the
+ * previous implementation were identical and simply discarded the
+ * scoped logger, so the context never applied to anything the callback
+ * logged.
  */
 export function withLoggerContext(logger, context, callback) {
-    const scoped = logger.withContext(context);
-    if (scoped instanceof ContextLogger) {
-        return callback();
-    }
-    return callback();
+    return callback(logger.withContext(context));
 }
 /**
  * Creates a default application logger.
@@ -39,7 +40,7 @@ export function withLoggerContext(logger, context, callback) {
 export function createDefaultLogger(name = "zudojs") {
     return createLogger({
         name,
-        level: 3,
+        level: LoggerLevel.INFO,
         formatter: createTextLoggerFormatter(),
         transports: [createConsoleLoggerTransport()],
     });

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

@@ -4,7 +4,7 @@
  * Logger class helper methods.
  */
 export { createEntry } from "./loggerCoreMethods.entry.js";
-export { dispatchEntry } from "./loggerCoreMethods.dispatch.js";
+export { dispatchEntry, dispatchEntrySync, } from "./loggerCoreMethods.dispatch.js";
 export { logAtLevel } from "./loggerCoreMethods.level.js";
 export { childLogger, withContextLogger } from "./loggerCoreMethods.child.js";
 export { setLoggerLevel, enableLogger, disableLogger, flushLogger, closeLogger, } from "./loggerCoreMethods.lifecycle.js";

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

@@ -4,7 +4,7 @@
  * Logger class helper methods.
  */
 export { createEntry } from "./loggerCoreMethods.entry.js";
-export { dispatchEntry } from "./loggerCoreMethods.dispatch.js";
+export { dispatchEntry, dispatchEntrySync, } from "./loggerCoreMethods.dispatch.js";
 export { logAtLevel } from "./loggerCoreMethods.level.js";
 export { childLogger, withContextLogger } from "./loggerCoreMethods.child.js";
 export { setLoggerLevel, enableLogger, disableLogger, flushLogger, closeLogger, } from "./loggerCoreMethods.lifecycle.js";

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

@@ -17,6 +17,8 @@ export function childLogger(ctx, options = {}) {
 export function withContextLogger(ctx, context) {
     ctx.assertActive();
     const child = childLogger(ctx);
-    return new ContextLogger(child, context);
+    // The child shares the parent's context storage, so the wrapper must
+    // scope THAT storage for the context to reach created entries.
+    return new ContextLogger(child, context, ctx.contextStorage);
 }
 //# sourceMappingURL=loggerCoreMethods.child.js.map

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

@@ -7,4 +7,15 @@ import type { LoggerConfiguration } from "../../../loggerOptions/loggerOptions.t
  * Dispatches an entry to the configured transports.
  */
 export declare function dispatchEntry(configuration: LoggerConfiguration, entry: LoggerEntry, handleError: (error: Error) => void): Promise<void>;
+/**
+ * Dispatches an entry, completing synchronously where it can.
+ *
+ * Returns `undefined` when every configured transport finished
+ * synchronously (nothing to await), otherwise a promise covering the
+ * asynchronous remainder. `asynchronous: true` skips the fast path
+ * entirely and always defers, keeping the caller off the transport's
+ * critical path — the option was previously stored and never read, so
+ * both settings behaved identically.
+ */
+export declare function dispatchEntrySync(configuration: LoggerConfiguration, entry: LoggerEntry, handleError: (error: Error) => void): void | Promise<void>;
 //# sourceMappingURL=loggerCoreMethods.dispatch.d.ts.map

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

@@ -18,6 +18,41 @@ function defaultFormat(configuration, entry) {
         environment: configuration.environment,
     });
 }
+/**
+ * Bounds a transport write with the configured transport timeout.
+ *
+ * `transportTimeout` was accepted, validated and stored but never read,
+ * so a transport whose write() never settled blocked flush() and
+ * close() forever. A non-positive timeout disables the bound.
+ */
+async function withTransportTimeout(timeoutMs, transportName, operation) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        await operation;
+        return;
+    }
+    let timer;
+    const expiry = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            reject(new LoggerTransportError(`Transport "${transportName}" did not complete within ${timeoutMs}ms.`));
+        }, 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
+        // finished but logged through an async transport hangs until the
+        // timeout elapses. Every other timer in the framework is unref'd
+        // for the same reason.
+        timer.unref?.();
+    });
+    try {
+        await Promise.race([operation, expiry]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        // The abandoned write must never surface as an unhandled rejection.
+        void operation.catch(() => { });
+    }
+}
 /**
  * Writes to a transport.
  */
@@ -33,22 +68,45 @@ async function writeTransport(configuration, transport, entry, formatted) {
     }
     await writeLoggerTransport(transport.transport, entry, transportContext);
 }
+/**
+ * Formats an entry with the configured formatter.
+ */
+function formatEntry(configuration, entry) {
+    const formatter = configuration.formatter;
+    if (typeof formatter === "string") {
+        return defaultFormat(configuration, entry);
+    }
+    return formatLoggerEntry(formatter, entry, {
+        loggerName: configuration.name,
+        environment: configuration.environment,
+    });
+}
+/**
+ * Writes an entry through one transport WITHOUT forcing a microtask.
+ *
+ * `writeLoggerTransport` is `async`, so awaiting it always defers by at
+ * least one microtask even for a fully synchronous transport. Calling
+ * the transport directly lets a synchronous console/array transport
+ * complete inline, which is what `asynchronous: false` promises.
+ */
+function writeTransportMaybeSync(configuration, transport, entry, formatted) {
+    const transportContext = {
+        loggerName: configuration.name,
+        environment: configuration.environment,
+    };
+    const payload = typeof formatted === "string" ? { ...entry, message: formatted } : entry;
+    const target = transport.transport;
+    return typeof target === "function"
+        ? target(payload, transportContext)
+        : target.write(payload, transportContext);
+}
 /**
  * Dispatches an entry to the configured transports.
  */
 export async function dispatchEntry(configuration, entry, handleError) {
-    const formatter = configuration.formatter;
     let formatted;
     try {
-        if (typeof formatter === "string") {
-            formatted = defaultFormat(configuration, entry);
-        }
-        else {
-            formatted = formatLoggerEntry(formatter, entry, {
-                loggerName: configuration.name,
-                environment: configuration.environment,
-            });
-        }
+        formatted = formatEntry(configuration, entry);
     }
     catch (error) {
         const formatterError = new LoggerFormatterError(`Failed to format log entry: ${toLoggerError(error).message}`, { cause: error });
@@ -64,7 +122,7 @@ export async function dispatchEntry(configuration, entry, handleError) {
             if (!registered.enabled) {
                 continue;
             }
-            await writeTransport(configuration, registered, entry, formatted);
+            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 });
@@ -72,4 +130,56 @@ export async function dispatchEntry(configuration, entry, handleError) {
         }
     }
 }
+/**
+ * Dispatches an entry, completing synchronously where it can.
+ *
+ * Returns `undefined` when every configured transport finished
+ * synchronously (nothing to await), otherwise a promise covering the
+ * asynchronous remainder. `asynchronous: true` skips the fast path
+ * entirely and always defers, keeping the caller off the transport's
+ * critical path — the option was previously stored and never read, so
+ * both settings behaved identically.
+ */
+export function dispatchEntrySync(configuration, entry, handleError) {
+    if (configuration.asynchronous) {
+        // `dispatchEntry` runs synchronously up to its first await, so a
+        // synchronous transport would still execute inline. Hop a
+        // microtask first so `asynchronous: true` genuinely keeps the
+        // caller off the transport's critical path.
+        return Promise.resolve().then(() => dispatchEntry(configuration, entry, handleError));
+    }
+    let formatted;
+    try {
+        formatted = formatEntry(configuration, entry);
+    }
+    catch (error) {
+        handleError(new LoggerFormatterError(`Failed to format log entry: ${toLoggerError(error).message}`, { cause: error }));
+        return;
+    }
+    const pending = [];
+    for (const transport of configuration.transports) {
+        try {
+            if (!isLoggerTransport(transport)) {
+                continue;
+            }
+            const registered = createLoggerTransport(transport);
+            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 }));
+                }));
+            }
+        }
+        catch (error) {
+            handleError(new LoggerTransportError(`Failed to write log entry: ${toLoggerError(error).message}`, { cause: error }));
+        }
+    }
+    if (pending.length === 0) {
+        return;
+    }
+    return Promise.all(pending).then(() => undefined);
+}
 //# sourceMappingURL=loggerCoreMethods.dispatch.js.map

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

@@ -2,6 +2,7 @@
  * Logger entry creation for dispatch.
  */
 import { createLoggerEntry } from "../../../loggerEntry/loggerEntry.core.js";
+import { createSecretMatcher, redactLogValue, LOGGER_REDACTION_TOKEN, } from "../../../loggerEntry/loggerEntryHelpers/loggerEntryHelpers.sanitize.js";
 import { contextToLogMetadata, createLoggerContext, } from "../../../loggerContext/loggerContext.core.js";
 /**
  * Creates a normalized log entry.
@@ -13,11 +14,22 @@ export function createEntry(configuration, contextStorage, level, message, optio
     const contextMetadata = activeContext
         ? contextToLogMetadata(activeContext)
         : {};
-    const metadata = {
+    // 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
+    // formatter and every transport sees the already-masked value and no
+    // 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 context = options.context
         ? createLoggerContext({
             parent: activeContext,
@@ -28,9 +40,13 @@ 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
             ? {
-                metadata: context.metadata,
+                ...context.identifiers,
+                metadata: redactLogValue(context.metadata, isSecret, replacement),
             }
             : undefined,
         source: options.source,