@zudojs/logger 0.1.0 → 1.1.0

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,20 @@ 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. 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;
@@ -60,6 +74,8 @@ export async function flushLogger(ctx) {
             await registered.flush();
         }
     }
+    if (failed)
+        throw failure;
 }
 /**
  * Closes all transports and marks logger as disposed.
@@ -68,15 +84,32 @@ 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;
+    try {
+        await ctx.drainDispatches();
+    }
+    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();
         }
     }
     ctx.markDisposed();
+    if (failed)
+        throw failure;
 }
 //# sourceMappingURL=loggerCoreMethods.lifecycle.js.map

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

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

@@ -0,0 +1,69 @@
+/**
+ * Log text sanitization and secret redaction.
+ *
+ * Log records routinely carry attacker-controlled strings (a username,
+ * a URL, an error message echoing request input). Written verbatim to a
+ * line-oriented sink, a single newline lets that input FORGE a complete
+ * additional log line, and an ESC byte lets it drive the operator's
+ * terminal. Every string that reaches a text-shaped formatter is
+ * therefore escaped here first.
+ */
+/**
+ * Replacement token written in place of a redacted value.
+ */
+export declare const LOGGER_REDACTION_TOKEN = "[REDACTED]";
+/**
+ * Field names treated as secrets by default.
+ *
+ * Matching is case-insensitive and substring-based so `dbPassword`,
+ * `X-Api-Key` and `refresh_token` are all covered.
+ */
+export declare const DEFAULT_LOGGER_SECRET_PATTERN: RegExp;
+/**
+ * Controls secret redaction for a logger.
+ */
+export interface LoggerRedactionOptions {
+    /**
+     * Whether redaction runs at all. Defaults to true.
+     */
+    readonly enabled?: boolean;
+    /**
+     * Exact field names to redact, in addition to `pattern`.
+     */
+    readonly keys?: readonly string[];
+    /**
+     * Field-name pattern. Defaults to DEFAULT_LOGGER_SECRET_PATTERN.
+     * Pass a pattern that never matches to rely on `keys` alone.
+     */
+    readonly pattern?: RegExp;
+    /**
+     * Replacement written in place of a secret.
+     */
+    readonly replacement?: string;
+}
+/**
+ * Escapes control characters that could forge log records.
+ *
+ * CR, LF, TAB and the ANSI escape byte become printable escapes; every
+ * other C0 control character and DEL becomes `\xNN`. Ordinary text,
+ * including every non-ASCII character, is returned unchanged.
+ */
+export declare function escapeLogText(value: string): string;
+/**
+ * Returns whether a string contains characters that can forge a record.
+ */
+export declare function hasLogControlCharacters(value: string): boolean;
+/**
+ * Builds a predicate deciding whether a field name holds a secret.
+ */
+export declare function createSecretMatcher(options?: LoggerRedactionOptions): (key: string) => boolean;
+/**
+ * Recursively replaces secret-named fields with a redaction token.
+ *
+ * Nesting, arrays and getters are all covered: the walk descends into
+ * every enumerable own property, and a getter is read here — once,
+ * before the value can reach a transport. Cycles resolve to
+ * "[Circular]" rather than recursing forever.
+ */
+export declare function redactLogValue(value: unknown, isSecret: (key: string) => boolean, replacement?: string, seen?: WeakSet<object>): unknown;
+//# sourceMappingURL=loggerEntryHelpers.sanitize.d.ts.map

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

@@ -0,0 +1,113 @@
+/**
+ * Log text sanitization and secret redaction.
+ *
+ * Log records routinely carry attacker-controlled strings (a username,
+ * a URL, an error message echoing request input). Written verbatim to a
+ * line-oriented sink, a single newline lets that input FORGE a complete
+ * additional log line, and an ESC byte lets it drive the operator's
+ * terminal. Every string that reaches a text-shaped formatter is
+ * therefore escaped here first.
+ */
+/**
+ * Matches C0 control characters plus DEL — everything that can forge a
+ * record boundary or drive a terminal.
+ */
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/g;
+/**
+ * Replacement token written in place of a redacted value.
+ */
+export const LOGGER_REDACTION_TOKEN = "[REDACTED]";
+/**
+ * Field names treated as secrets by default.
+ *
+ * Matching is case-insensitive and substring-based so `dbPassword`,
+ * `X-Api-Key` and `refresh_token` are all covered.
+ */
+export const DEFAULT_LOGGER_SECRET_PATTERN = /(pass(word|wd)?|secret|token|api[-_.]?key|private[-_.]?key|credential|authorization|cookie)/i;
+/**
+ * Escapes control characters that could forge log records.
+ *
+ * CR, LF, TAB and the ANSI escape byte become printable escapes; every
+ * other C0 control character and DEL becomes `\xNN`. Ordinary text,
+ * including every non-ASCII character, is returned unchanged.
+ */
+export function escapeLogText(value) {
+    return value.replace(CONTROL_CHARACTERS, (character) => {
+        switch (character) {
+            case "\n":
+                return "\\n";
+            case "\r":
+                return "\\r";
+            case "\t":
+                return "\\t";
+            case "\u001b":
+                return "\\u001b";
+            default: {
+                const code = character.charCodeAt(0);
+                return `\\x${code.toString(16).padStart(2, "0")}`;
+            }
+        }
+    });
+}
+/**
+ * Returns whether a string contains characters that can forge a record.
+ */
+export function hasLogControlCharacters(value) {
+    return new RegExp(CONTROL_CHARACTERS.source).test(value);
+}
+/**
+ * Builds a predicate deciding whether a field name holds a secret.
+ */
+export function createSecretMatcher(options = {}) {
+    if (options.enabled === false) {
+        return () => false;
+    }
+    // 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);
+}
+/**
+ * Recursively replaces secret-named fields with a redaction token.
+ *
+ * Nesting, arrays and getters are all covered: the walk descends into
+ * every enumerable own property, and a getter is read here — once,
+ * before the value can reach a transport. Cycles resolve to
+ * "[Circular]" rather than recursing forever.
+ */
+export function redactLogValue(value, isSecret, replacement = LOGGER_REDACTION_TOKEN, seen = new WeakSet()) {
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (value instanceof Date || value instanceof Error) {
+        return value;
+    }
+    if (seen.has(value)) {
+        return "[Circular]";
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.map((item) => redactLogValue(item, isSecret, replacement, seen));
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        // defineProperty, never assignment: a "__proto__" key coming from
+        // JSON.parse of untrusted input would otherwise reach the inherited
+        // setter and replace this object's prototype.
+        Object.defineProperty(result, key, {
+            value: isSecret(key)
+                ? replacement
+                : redactLogValue(item, isSecret, replacement, seen),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
+    }
+    return result;
+}
+//# sourceMappingURL=loggerEntryHelpers.sanitize.js.map

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

@@ -5,7 +5,11 @@ import type { LoggerEntry } from "./loggerEntryHelpers.interfaces.js";
 /**
  * Returns a plain serializable representation of an entry.
  *
- * This intentionally does not call JSON.stringify itself.
+ * This intentionally does not call JSON.stringify itself, but every
+ * caller-supplied value IS normalized first. Metadata and context used
+ * to be embedded by reference, so a circular object or a BigInt made
+ * the JSON formatter throw — and because dispatch swallows formatter
+ * errors by default, the whole log line vanished silently.
  */
 export declare function serializeLoggerEntry(entry: LoggerEntry): Record<string, unknown>;
 export { serializeLoggerError, serializeLoggerValue, } from "./loggerEntryHelpers.valueSerialize.js";

package/dist/loggerEntry/loggerEntryHelpers/loggerEntryHelpers.serialize.js

@@ -1,11 +1,15 @@
 /**
  * Logger entry serialization helpers.
  */
-import { serializeLoggerError } from "./loggerEntryHelpers.valueSerialize.js";
+import { serializeLoggerError, serializeLoggerValue, } from "./loggerEntryHelpers.valueSerialize.js";
 /**
  * Returns a plain serializable representation of an entry.
  *
- * This intentionally does not call JSON.stringify itself.
+ * This intentionally does not call JSON.stringify itself, but every
+ * caller-supplied value IS normalized first. Metadata and context used
+ * to be embedded by reference, so a circular object or a BigInt made
+ * the JSON formatter throw — and because dispatch swallows formatter
+ * errors by default, the whole log line vanished silently.
  */
 export function serializeLoggerEntry(entry) {
     return {
@@ -13,9 +17,9 @@ export function serializeLoggerEntry(entry) {
         level: entry.level,
         levelName: entry.levelName,
         message: entry.message,
-        metadata: entry.metadata,
-        context: entry.context,
-        source: entry.source,
+        metadata: serializeLoggerValue(entry.metadata),
+        context: serializeLoggerValue(entry.context),
+        source: serializeLoggerValue(entry.source),
         error: entry.error ? serializeLoggerError(entry.error) : undefined,
         logger: entry.logger,
         timestamp: entry.timestamp.toISOString(),

package/dist/loggerEntry/loggerEntryHelpers/loggerEntryHelpers.valueSerialize.js

@@ -49,7 +49,15 @@ export function serializeLoggerValue(value, seen = new WeakSet()) {
     }
     const result = {};
     for (const [key, item] of Object.entries(value)) {
-        result[key] = serializeLoggerValue(item, seen);
+        // defineProperty, never assignment: a "__proto__" key from an
+        // untrusted payload would otherwise reach the inherited setter and
+        // replace the serialized object's prototype.
+        Object.defineProperty(result, key, {
+            value: serializeLoggerValue(item, seen),
+            enumerable: true,
+            writable: true,
+            configurable: true,
+        });
     }
     return result;
 }

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

@@ -1,6 +1,7 @@
 /**
  * Logger context and source formatting helpers.
  */
+import { escapeLogText } from "../../loggerEntry/loggerEntryHelpers/loggerEntryHelpers.sanitize.js";
 /**
  * Formats logger context.
  */
@@ -13,7 +14,16 @@ export function formatContext(entry) {
         if (value === undefined || value === null) {
             continue;
         }
-        values.push(`${key}=${String(value)}`);
+        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(" ")}]` : "";
 }
@@ -27,12 +37,14 @@ export function formatSource(entry) {
     }
     const location = [];
     if (source.file) {
-        location.push(source.file);
+        location.push(escapeLogText(source.file));
     }
     if (source.line !== undefined) {
         location.push(String(source.line));
     }
-    const functionName = source.function ? ` ${source.function}` : "";
+    const functionName = source.function
+        ? ` ${escapeLogText(source.function)}`
+        : "";
     return location.length > 0 ? `[${location.join(":")}${functionName}]` : "";
 }
 //# sourceMappingURL=loggerFormatterFormatters.context.js.map

package/dist/loggerFormatter/loggerFormatterFormatters/loggerFormatterFormatters.js

@@ -3,6 +3,7 @@
  */
 import { serializeLoggerEntry } from "../../loggerEntry/loggerEntrySerialize.js";
 import { createLoggerFormatter } from "../loggerFormatter.core.js";
+import { escapeLogText } from "../../loggerEntry/loggerEntryHelpers/loggerEntryHelpers.sanitize.js";
 import { createJsonLoggerFormatter } from "./loggerFormatterFormatters.json.js";
 import { createTextLoggerFormatter } from "./loggerFormatterFormatters.text.js";
 /**
@@ -11,8 +12,8 @@ import { createTextLoggerFormatter } from "./loggerFormatterFormatters.text.js";
 export function createCompactLoggerFormatter(options = {}) {
     return createLoggerFormatter((entry) => {
         const level = entry.levelName.toUpperCase();
-        const logger = entry.logger ? ` ${entry.logger}:` : "";
-        return `${level}${logger} ${entry.message}`;
+        const logger = entry.logger ? ` ${escapeLogText(entry.logger)}:` : "";
+        return `${level}${logger} ${escapeLogText(entry.message)}`;
     }, {
         name: options.name ?? "compact",
     });

package/dist/loggerFormatter/loggerFormatterFormatters/loggerFormatterFormatters.json.js

@@ -6,17 +6,33 @@ import { createLoggerFormatter } from "../loggerFormatter.core.js";
 /**
  * Removes undefined values recursively.
  */
-function removeUndefinedValues(value) {
+function removeUndefinedValues(value, seen = new WeakSet()) {
     if (Array.isArray(value)) {
-        return value.map((item) => removeUndefinedValues(item));
+        if (seen.has(value)) {
+            return "[Circular]";
+        }
+        seen.add(value);
+        return value.map((item) => removeUndefinedValues(item, seen));
     }
     if (value && typeof value === "object" && !(value instanceof Date)) {
+        // Without a cycle guard this walk recursed until the stack blew,
+        // and the resulting RangeError was swallowed by dispatch — losing
+        // the log line rather than reporting the offending value.
+        if (seen.has(value)) {
+            return "[Circular]";
+        }
+        seen.add(value);
         const result = {};
         for (const [key, item] of Object.entries(value)) {
             if (item === undefined) {
                 continue;
             }
-            result[key] = removeUndefinedValues(item);
+            Object.defineProperty(result, key, {
+                value: removeUndefinedValues(item, seen),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
         }
         return result;
     }

package/dist/loggerFormatter/loggerFormatterFormatters/loggerFormatterFormatters.metadata.js

@@ -2,14 +2,17 @@
  * Logger metadata and error formatting helpers.
  */
 import { serializeLoggerError, serializeLoggerValue, } from "../../loggerEntry/loggerEntryHelpers/loggerEntryHelpers.valueSerialize.js";
+import { escapeLogText } from "../../loggerEntry/loggerEntryHelpers/loggerEntryHelpers.sanitize.js";
 /**
  * Formats metadata as key=value pairs.
  */
 export function formatMetadata(metadata, separator) {
-    return Object.entries(metadata)
+    return (Object.entries(metadata)
         .filter(([, value]) => value !== undefined)
-        .map(([key, value]) => `${key}=${formatValue(value)}`)
-        .join(separator);
+        // Metadata KEYS are as attacker-influenceable as values (a header
+        // name, a form field) and were previously interpolated raw.
+        .map(([key, value]) => `${escapeLogText(key)}=${formatValue(value)}`)
+        .join(separator));
 }
 /**
  * Formats an arbitrary metadata value.
@@ -22,19 +25,24 @@ export function formatValue(value) {
         if (/\s/.test(value)) {
             return JSON.stringify(value);
         }
-        return value;
+        // A value with no whitespace can still carry ANSI escapes or other
+        // C0 controls, which used to reach the sink verbatim.
+        return escapeLogText(value);
     }
     if (typeof value === "object") {
         return JSON.stringify(serializeLoggerValue(value));
     }
-    return String(value);
+    return escapeLogText(String(value));
 }
 /**
  * Formats an Error.
  */
 export function formatError(error, includeStackTrace) {
     if (includeStackTrace && error.stack) {
-        return `\n${error.stack}`;
+        // A stack trace is intentionally multi-line, but everything in it
+        // that came from user input (the message) must not be able to
+        // introduce a further record boundary of its own.
+        return `\n${error.stack.split("\n").map(escapeLogText).join("\n")}`;
     }
     const serialized = serializeLoggerError(error);
     return `error=${JSON.stringify(serialized)}`;

package/dist/loggerFormatter/loggerFormatterFormatters/loggerFormatterFormatters.text.js

@@ -2,8 +2,26 @@
  * Text logger formatter.
  */
 import { createLoggerFormatter } from "../loggerFormatter.core.js";
+import { escapeLogText } from "../../loggerEntry/loggerEntryHelpers/loggerEntryHelpers.sanitize.js";
 import { formatContext, formatSource, } from "./loggerFormatterFormatters.context.js";
 import { formatMetadata, formatError, } from "./loggerFormatterFormatters.metadata.js";
+/** ANSI colour per severity, used only when the caller opts in. */
+const LEVEL_COLORS = Object.freeze({
+    fatal: "35",
+    error: "31",
+    warn: "33",
+    info: "36",
+    debug: "32",
+    trace: "90",
+});
+/** Wraps a level tag in an ANSI colour sequence. */
+function colorizeLevel(levelName, tag) {
+    const color = LEVEL_COLORS[levelName];
+    if (color === undefined) {
+        return tag;
+    }
+    return `\u001b[${color}m${tag}\u001b[0m`;
+}
 /**
  * Creates a human-readable text formatter.
  */
@@ -15,16 +33,25 @@ export function createTextLoggerFormatter(options = {}) {
     const includeSource = options.includeSource ?? false;
     const includeStackTrace = options.includeStackTrace ?? true;
     const metadataSeparator = options.metadataSeparator ?? " ";
-    return createLoggerFormatter((entry) => {
+    return createLoggerFormatter((entry, context) => {
         const parts = [];
         if (includeTimestamp) {
             parts.push(entry.timestamp.toISOString());
         }
-        parts.push(`[${entry.levelName.toUpperCase()}]`);
+        // LoggerFormatterContext.colors was declared from the first
+        // release and read by nothing, so `colors: true` produced plain
+        // output. Colour codes are emitted only on explicit opt-in, and
+        // only around the fixed level name — never around user text,
+        // which stays escaped.
+        const levelTag = `[${entry.levelName.toUpperCase()}]`;
+        parts.push(context.colors ? colorizeLevel(entry.levelName, levelTag) : levelTag);
         if (includeLogger && entry.logger) {
-            parts.push(`[${entry.logger}]`);
+            parts.push(`[${escapeLogText(entry.logger)}]`);
         }
-        parts.push(entry.message);
+        // The message is the single most attacker-influenceable field on
+        // an entry. Emitted verbatim, a newline inside it forged a whole
+        // extra log record and an ESC byte drove the operator's terminal.
+        parts.push(escapeLogText(entry.message));
         if (includeContext && entry.context) {
             const context = formatContext(entry);
             if (context) {

package/dist/loggerOptions/loggerOptions.type.d.ts

@@ -1,7 +1,8 @@
-import type { LoggerLevel } from "../loggerLevel/loggerLevel.type.js";
+import { LoggerLevel } from "../loggerLevel/loggerLevel.type.js";
 import type { LoggerContextData } from "../loggerContext/loggerContext.core.js";
 import type { LoggerFormatterLike } from "../loggerFormatter/loggerFormatter.type.js";
 import type { LoggerTransportLike } from "../loggerTransport/loggerTransport.type.js";
+import type { LoggerRedactionOptions } from "../loggerEntry/loggerEntryHelpers/loggerEntryHelpers.sanitize.js";
 /** Options used to configure a Zudojs logger. */
 export interface LoggerOptions {
     readonly name?: string;
@@ -16,6 +17,15 @@ export interface LoggerOptions {
     readonly transportTimeout?: number;
     readonly inheritContext?: boolean;
     readonly mutable?: boolean;
+    /**
+     * Secret redaction for metadata and context.
+     *
+     * Redaction is ON by default: fields whose NAME looks like a secret
+     * (password, token, api key, credential, authorization, cookie) are
+     * replaced with "[REDACTED]" before an entry reaches a formatter.
+     * Pass `{ enabled: false }` to opt out.
+     */
+    readonly redact?: LoggerRedactionOptions;
 }
 /** Options used when creating a child logger. */
 export interface ChildLoggerOptions {
@@ -53,6 +63,7 @@ export interface LoggerConfiguration {
     readonly transportTimeout: number;
     readonly inheritContext: boolean;
     readonly mutable: boolean;
+    readonly redact: LoggerRedactionOptions;
 }
 /** Default logger configuration values. */
 export declare const DEFAULT_LOGGER_OPTIONS: Required<Pick<LoggerOptions, "enabled" | "throwTransportErrors" | "asynchronous" | "transportTimeout" | "inheritContext" | "mutable">>;

package/dist/loggerOptions/loggerOptions.type.js

@@ -1,3 +1,4 @@
+import { LoggerLevel } from "../loggerLevel/loggerLevel.type.js";
 /** Default logger configuration values. */
 export const DEFAULT_LOGGER_OPTIONS = {
     enabled: true,
@@ -28,7 +29,7 @@ export function resolveLoggerOptions(options = {}) {
     validateLoggerOptions(options);
     return Object.freeze({
         name: options.name ?? "zudojs",
-        level: options.level ?? 3,
+        level: options.level ?? LoggerLevel.INFO,
         environment: options.environment,
         metadata: Object.freeze({ ...(options.metadata ?? {}) }),
         formatter: options.formatter ?? "text",
@@ -40,6 +41,7 @@ export function resolveLoggerOptions(options = {}) {
         transportTimeout: options.transportTimeout ?? DEFAULT_LOGGER_OPTIONS.transportTimeout,
         inheritContext: options.inheritContext ?? DEFAULT_LOGGER_OPTIONS.inheritContext,
         mutable: options.mutable ?? DEFAULT_LOGGER_OPTIONS.mutable,
+        redact: Object.freeze({ ...(options.redact ?? {}) }),
     });
 }
 /** Merges two logger option objects. Values from `override` take precedence. */
@@ -66,6 +68,7 @@ export function createChildLoggerOptions(parent, options = {}) {
         transportTimeout: parent.transportTimeout,
         inheritContext: parent.inheritContext,
         mutable: parent.mutable,
+        redact: parent.redact,
     };
 }
 //# sourceMappingURL=loggerOptions.type.js.map

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",