@zudojs/logger 0.0.1 → 1.0.0

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,94 @@ 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()`.
+
+## 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
 ```
 
-## Features
+## 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` / `` 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");
+});
+```
+
+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,7 @@ export declare class ZudojsLogger implements Logger, ZudojsLoggerContext {
     private _configuration;
     private readonly _contextStorage;
     private _disposed;
+    private readonly _pending;
     constructor(options?: LoggerOptions, contextStorage?: LoggerContextStorage);
     get configuration(): LoggerConfiguration;
     get contextStorage(): LoggerContextStorage;
@@ -54,6 +59,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

@@ -14,6 +14,7 @@ export class ZudojsLogger {
     _configuration;
     _contextStorage;
     _disposed = false;
+    _pending = new Set();
     constructor(options = {}, contextStorage) {
         this._configuration = resolveLoggerOptions(options);
         this._contextStorage = contextStorage ?? createLoggerContextStorage();
@@ -97,6 +98,24 @@ export class ZudojsLogger {
     createChildLogger(options) {
         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.
+        const tracked = dispatch
+            .catch(() => { })
+            .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]);
+        }
+    }
 }
 /**
  * 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,17 @@ export function createEntry(configuration, contextStorage, level, message, optio
     const contextMetadata = activeContext
         ? contextToLogMetadata(activeContext)
         : {};
-    const metadata = {
+    const rawMetadata = {
         ...configuration.metadata,
         ...contextMetadata,
         ...(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,
@@ -30,7 +37,7 @@ export function createEntry(configuration, contextStorage, level, message, optio
         metadata,
         context: context
             ? {
-                metadata: context.metadata,
+                metadata: redactLogValue(context.metadata, isSecret, replacement),
             }
             : undefined,
         source: options.source,

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

@@ -4,7 +4,7 @@
 import { LoggerLevel, shouldLog, } from "../../../loggerLevel/loggerLevel.type.js";
 import { LoggerConfigurationError } from "../../../loggerErrors/loggerError.base.js";
 import { createEntry } from "./loggerCoreMethods.entry.js";
-import { dispatchEntry } from "./loggerCoreMethods.dispatch.js";
+import { dispatchEntrySync } from "./loggerCoreMethods.dispatch.js";
 /**
  * Level logging methods extracted from ZudojsLogger.
  */
@@ -18,6 +18,13 @@ export function logAtLevel(ctx, level, message, options = {}) {
         throw new LoggerConfigurationError("Logger message must be a string.");
     }
     const entry = createEntry(ctx.configuration, ctx.contextStorage, level, message, options);
-    void dispatchEntry(ctx.configuration, entry, (error) => ctx.handleInfrastructureError(error));
+    // 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
+    // promise lets the lifecycle methods drain it.
+    const dispatch = dispatchEntrySync(ctx.configuration, entry, (error) => ctx.handleInfrastructureError(error));
+    if (dispatch) {
+        ctx.trackDispatch(dispatch);
+    }
 }
 //# sourceMappingURL=loggerCoreMethods.level.js.map

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

@@ -48,6 +48,10 @@ export function disableLogger(ctx) {
  */
 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();
     for (const transport of ctx.configuration.transports) {
         if (!isLoggerTransport(transport)) {
             continue;
@@ -68,11 +72,15 @@ export async function closeLogger(ctx) {
     if (ctx.isDisposed()) {
         return;
     }
+    await ctx.drainDispatches();
     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();
         }

package/dist/loggerEntry/loggerEntry.core.js

@@ -1,7 +1,6 @@
 /**
  * Core logger entry creation functions.
  */
-import { loggerLevelNameFallback } from "./loggerEntryHelpers/loggerEntryHelpers.serialize.js";
 import { createLoggerEntry } from "./loggerEntryCreate.js";
 /**
  * Creates a unique log entry identifier.

package/dist/loggerEntry/loggerEntryHelpers/index.d.ts

@@ -6,4 +6,6 @@
 export type { LogValue, LogMetadata, LoggerSource, LoggerEntryContext, } from "./loggerEntryHelpers.types.js";
 export type { LoggerEntry, LoggerEntryInput, } from "./loggerEntryHelpers.interfaces.js";
 export { serializeLoggerEntry, serializeLoggerError, serializeLoggerValue, loggerLevelNameFallback, } from "./loggerEntryHelpers.serialize.js";
+export { LOGGER_REDACTION_TOKEN, DEFAULT_LOGGER_SECRET_PATTERN, escapeLogText, hasLogControlCharacters, createSecretMatcher, redactLogValue, } from "./loggerEntryHelpers.sanitize.js";
+export type { LoggerRedactionOptions } from "./loggerEntryHelpers.sanitize.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/loggerEntry/loggerEntryHelpers/index.js

@@ -4,4 +4,5 @@
  * Logger entry helper types and utilities.
  */
 export { serializeLoggerEntry, serializeLoggerError, serializeLoggerValue, loggerLevelNameFallback, } from "./loggerEntryHelpers.serialize.js";
+export { LOGGER_REDACTION_TOKEN, DEFAULT_LOGGER_SECRET_PATTERN, escapeLogText, hasLogControlCharacters, createSecretMatcher, redactLogValue, } from "./loggerEntryHelpers.sanitize.js";
 //# sourceMappingURL=index.js.map