@zudojs/logger 1.1.0 → 1.3.0

package/dist/loggerEntry/loggerEntry.secretFields.js

@@ -0,0 +1,90 @@
+/**
+ * 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 const DEFAULT_LOGGER_SECRET_FIELDS = Object.freeze([
+    "password",
+    "passwd",
+    "passphrase",
+    "pwd",
+    "secret",
+    "token",
+    "jwt",
+    "bearer",
+    "authorization",
+    "auth",
+    "cookie",
+    "session",
+    "sid",
+    "credential",
+    "credentials",
+    "api_key",
+    "private_key",
+    "client_secret",
+    "credit_card",
+    "card_number",
+    "cvv",
+    "cvc",
+    "ssn",
+    "social_security",
+    "pin",
+    "otp",
+]);
+/**
+ * Unambiguous secret words that are also matched as a substring of a
+ * lowercase run-together name (`userpassword`, `accesstoken`), which the
+ * word split alone cannot see.
+ */
+const SUBSTRING_SECRET_WORDS = Object.freeze([
+    "password",
+    "passwd",
+    "secret",
+    "token",
+    "apikey",
+    "privatekey",
+    "credential",
+    "authorization",
+    "cookie",
+]);
+/** Splits a field name into lowercase words. */
+function splitWords(key) {
+    return key
+        .replace(/([a-z0-9])([A-Z])/gu, "$1 $2")
+        .replace(/([A-Z]+)([A-Z][a-z])/gu, "$1 $2")
+        .toLowerCase()
+        .split(/[^a-z0-9]+/u)
+        .filter(Boolean);
+}
+/** Normalizes a field-list entry the way word runs are joined. */
+function normalizeField(field) {
+    return field.toLowerCase().replace(/[^a-z0-9]/gu, "");
+}
+/**
+ * Builds the default secret-field predicate from a word list.
+ */
+export function createDefaultSecretFieldMatcher(fields = DEFAULT_LOGGER_SECRET_FIELDS) {
+    const targets = new Set(fields.map(normalizeField).filter(Boolean));
+    return (key) => {
+        const words = splitWords(key);
+        for (let start = 0; start < words.length; start += 1) {
+            let joined = "";
+            for (let end = start; end < words.length; end += 1) {
+                joined += words[end] ?? "";
+                if (targets.has(joined))
+                    return true;
+            }
+        }
+        const compact = key.toLowerCase().replace(/[^a-z0-9]/gu, "");
+        return SUBSTRING_SECRET_WORDS.some((word) => compact.includes(word));
+    };
+}
+//# sourceMappingURL=loggerEntry.secretFields.js.map

package/dist/loggerEntry/loggerEntryCreate.js

@@ -2,6 +2,7 @@
  * Logger entry creation from input.
  */
 import { createLoggerEntryId } from "./loggerEntry.core.js";
+import { InvalidLoggerEntryError } from "../loggerErrors/loggerError.base.js";
 import { loggerLevelNameFallback } from "./loggerEntryHelpers/loggerEntryHelpers.serialize.js";
 /**
  * Creates a normalized LoggerEntry.
@@ -10,7 +11,7 @@ export function createLoggerEntry(input) {
     const timestamp = input.timestamp ?? new Date();
     const timestampMs = timestamp.getTime();
     if (!Number.isFinite(timestampMs)) {
-        throw new RangeError("Logger entry timestamp must be a valid date.");
+        throw new InvalidLoggerEntryError("Logger entry timestamp must be a valid date.");
     }
     const levelName = input.levelName ?? loggerLevelNameFallback(input.level);
     return Object.freeze({

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

@@ -6,6 +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 { LOGGER_REDACTION_TOKEN, LOGGER_UNREADABLE_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,5 +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";
+export { LOGGER_REDACTION_TOKEN, LOGGER_UNREADABLE_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

@@ -13,10 +13,21 @@
  */
 export declare const LOGGER_REDACTION_TOKEN = "[REDACTED]";
 /**
- * Field names treated as secrets by default.
+ * Replacement token written in place of a property whose getter threw.
  *
- * Matching is case-insensitive and substring-based so `dbPassword`,
- * `X-Api-Key` and `refresh_token` are all covered.
+ * A throwing accessor used to propagate out of `logger.info(...)` and
+ * abort the caller. The field is marked instead, the rest of the entry
+ * is logged, and the failure is reported as an infrastructure error.
+ */
+export declare const LOGGER_UNREADABLE_TOKEN = "[Unreadable]";
+/**
+ * Legacy substring pattern for secret field names.
+ *
+ * @deprecated No longer the default: it redacted `passenger`/`compass`
+ * and missed `auth`, `sessionId`, `ssn`, `cardNumber`, `cvv` and `otp`.
+ * The default is now the word-based matcher over
+ * `DEFAULT_LOGGER_SECRET_FIELDS`. Pass this as `redact.pattern` to opt
+ * back into the old behaviour.
  */
 export declare const DEFAULT_LOGGER_SECRET_PATTERN: RegExp;
 /**
@@ -32,8 +43,9 @@ export interface LoggerRedactionOptions {
      */
     readonly keys?: readonly string[];
     /**
-     * Field-name pattern. Defaults to DEFAULT_LOGGER_SECRET_PATTERN.
-     * Pass a pattern that never matches to rely on `keys` alone.
+     * Field-name pattern. When omitted, the word-based default matcher over
+     * `DEFAULT_LOGGER_SECRET_FIELDS` is used. Pass a pattern that never
+     * matches to rely on `keys` alone.
      */
     readonly pattern?: RegExp;
     /**
@@ -45,8 +57,8 @@ export interface LoggerRedactionOptions {
  * 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.
+ * other C0/C1 control character and DEL becomes `\xNN`, and U+2028 /
+ * U+2029 become `\u2028` / `\u2029`. All other text is unchanged.
  */
 export declare function escapeLogText(value: string): string;
 /**
@@ -60,10 +72,15 @@ export declare function createSecretMatcher(options?: LoggerRedactionOptions): (
 /**
  * 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.
+ * Nesting, arrays, `Map`, `Set` 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. A getter that
+ * throws yields {@link LOGGER_UNREADABLE_TOKEN} and is reported through
+ * `onReadError` instead of aborting the caller's log statement.
+ *
+ * `seen` tracks the ANCESTOR PATH only (each object is unmarked as the
+ * walk ascends), so a back-edge resolves to "[Circular]" while an
+ * object merely referenced twice in one payload is logged both times.
  */
-export declare function redactLogValue(value: unknown, isSecret: (key: string) => boolean, replacement?: string, seen?: WeakSet<object>): unknown;
+export declare function redactLogValue(value: unknown, isSecret: (key: string) => boolean, replacement?: string, seen?: WeakSet<object>, onReadError?: (key: string, error: unknown) => void): unknown;
 //# sourceMappingURL=loggerEntryHelpers.sanitize.d.ts.map

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

@@ -8,28 +8,41 @@
  * terminal. Every string that reaches a text-shaped formatter is
  * therefore escaped here first.
  */
+import { createDefaultSecretFieldMatcher } from "../loggerEntry.secretFields.js";
 /**
- * Matches C0 control characters plus DEL — everything that can forge a
- * record boundary or drive a terminal.
+ * Matches C0 controls, DEL, C1 controls (NEL, CSI) and the Unicode
+ * line/paragraph separators — everything that can forge a record
+ * boundary or drive a terminal.
  */
-const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/g;
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g;
 /**
  * Replacement token written in place of a redacted value.
  */
 export const LOGGER_REDACTION_TOKEN = "[REDACTED]";
 /**
- * Field names treated as secrets by default.
+ * Replacement token written in place of a property whose getter threw.
  *
- * Matching is case-insensitive and substring-based so `dbPassword`,
- * `X-Api-Key` and `refresh_token` are all covered.
+ * A throwing accessor used to propagate out of `logger.info(...)` and
+ * abort the caller. The field is marked instead, the rest of the entry
+ * is logged, and the failure is reported as an infrastructure error.
+ */
+export const LOGGER_UNREADABLE_TOKEN = "[Unreadable]";
+/**
+ * Legacy substring pattern for secret field names.
+ *
+ * @deprecated No longer the default: it redacted `passenger`/`compass`
+ * and missed `auth`, `sessionId`, `ssn`, `cardNumber`, `cvv` and `otp`.
+ * The default is now the word-based matcher over
+ * `DEFAULT_LOGGER_SECRET_FIELDS`. Pass this as `redact.pattern` to opt
+ * back into the old behaviour.
  */
 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.
+ * other C0/C1 control character and DEL becomes `\xNN`, and U+2028 /
+ * U+2029 become `\u2028` / `\u2029`. All other text is unchanged.
  */
 export function escapeLogText(value) {
     return value.replace(CONTROL_CHARACTERS, (character) => {
@@ -42,6 +55,10 @@ export function escapeLogText(value) {
                 return "\\t";
             case "\u001b":
                 return "\\u001b";
+            case "\u2028":
+                return "\\u2028";
+            case "\u2029":
+                return "\\u2029";
             default: {
                 const code = character.charCodeAt(0);
                 return `\\x${code.toString(16).padStart(2, "0")}`;
@@ -62,25 +79,46 @@ export function createSecretMatcher(options = {}) {
     if (options.enabled === false) {
         return () => false;
     }
+    const exact = new Set((options.keys ?? []).map((key) => key.toLowerCase()));
+    const configured = options.pattern;
+    if (configured === undefined) {
+        const isDefaultSecret = createDefaultSecretFieldMatcher();
+        return (key) => exact.has(key.toLowerCase()) || isDefaultSecret(key);
+    }
     // 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);
 }
+/** Defines an own, enumerable property without touching a setter. */
+function defineLogProperty(target, key, 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(target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+    });
+}
 /**
  * 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.
+ * Nesting, arrays, `Map`, `Set` 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. A getter that
+ * throws yields {@link LOGGER_UNREADABLE_TOKEN} and is reported through
+ * `onReadError` instead of aborting the caller's log statement.
+ *
+ * `seen` tracks the ANCESTOR PATH only (each object is unmarked as the
+ * walk ascends), so a back-edge resolves to "[Circular]" while an
+ * object merely referenced twice in one payload is logged both times.
  */
-export function redactLogValue(value, isSecret, replacement = LOGGER_REDACTION_TOKEN, seen = new WeakSet()) {
+export function redactLogValue(value, isSecret, replacement = LOGGER_REDACTION_TOKEN, seen = new WeakSet(), onReadError) {
     if (value === null || typeof value !== "object") {
         return value;
     }
@@ -91,23 +129,43 @@ export function redactLogValue(value, isSecret, replacement = LOGGER_REDACTION_T
         return "[Circular]";
     }
     seen.add(value);
-    if (Array.isArray(value)) {
-        return value.map((item) => redactLogValue(item, isSecret, replacement, seen));
+    try {
+        const descend = (item) => redactLogValue(item, isSecret, replacement, seen, onReadError);
+        if (Array.isArray(value)) {
+            return value.map(descend);
+        }
+        if (value instanceof Set) {
+            return Array.from(value, descend);
+        }
+        const result = {};
+        if (value instanceof Map) {
+            for (const [key, item] of value.entries()) {
+                const name = typeof key === "string" ? key : String(key);
+                defineLogProperty(result, name, isSecret(name) ? replacement : descend(item));
+            }
+            return result;
+        }
+        for (const key of Object.keys(value)) {
+            if (isSecret(key)) {
+                // Never even read a secret-named accessor.
+                defineLogProperty(result, key, replacement);
+                continue;
+            }
+            let item;
+            try {
+                item = value[key];
+            }
+            catch (error) {
+                onReadError?.(key, error);
+                defineLogProperty(result, key, LOGGER_UNREADABLE_TOKEN);
+                continue;
+            }
+            defineLogProperty(result, key, descend(item));
+        }
+        return result;
     }
-    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,
-        });
+    finally {
+        seen.delete(value);
     }
-    return result;
 }
 //# sourceMappingURL=loggerEntryHelpers.sanitize.js.map

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

@@ -1,6 +1,7 @@
 /**
  * Logger entry serialization helpers.
  */
+import { InvalidLoggerLevelError } from "../../loggerErrors/loggerError.base.js";
 import { serializeLoggerError, serializeLoggerValue, } from "./loggerEntryHelpers.valueSerialize.js";
 /**
  * Returns a plain serializable representation of an entry.
@@ -49,7 +50,7 @@ export function loggerLevelNameFallback(level) {
         case 5:
             return "trace";
         default:
-            throw new RangeError(`Unknown logger level: ${String(level)}`);
+            throw new InvalidLoggerLevelError(level);
     }
 }
 //# sourceMappingURL=loggerEntryHelpers.serialize.js.map

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

@@ -11,6 +11,11 @@ export declare function serializeLoggerError(error: {
 }): Record<string, unknown>;
 /**
  * Converts arbitrary values into safer serializable values.
+ *
+ * `seen` tracks the ANCESTOR PATH only, so only a genuine back-edge
+ * becomes "[Circular]"; `Map` and `Set` keep their contents; and a
+ * property whose getter throws becomes "[Unreadable]" rather than
+ * taking the whole log line down.
  */
 export declare function serializeLoggerValue(value: unknown, seen?: WeakSet<object>): unknown;
 //# sourceMappingURL=loggerEntryHelpers.valueSerialize.d.ts.map

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

@@ -1,6 +1,7 @@
 /**
  * Logger entry value serialization.
  */
+import { LOGGER_UNREADABLE_TOKEN } from "./loggerEntryHelpers.sanitize.js";
 /**
  * Serializes an error-like object into a plain object.
  */
@@ -13,6 +14,11 @@ export function serializeLoggerError(error) {
 }
 /**
  * Converts arbitrary values into safer serializable values.
+ *
+ * `seen` tracks the ANCESTOR PATH only, so only a genuine back-edge
+ * becomes "[Circular]"; `Map` and `Set` keep their contents; and a
+ * property whose getter throws becomes "[Unreadable]" rather than
+ * taking the whole log line down.
  */
 export function serializeLoggerValue(value, seen = new WeakSet()) {
     if (value === null ||
@@ -44,21 +50,46 @@ export function serializeLoggerValue(value, seen = new WeakSet()) {
         return "[Circular]";
     }
     seen.add(value);
-    if (Array.isArray(value)) {
-        return value.map((item) => serializeLoggerValue(item, seen));
-    }
-    const result = {};
-    for (const [key, item] of Object.entries(value)) {
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item) => serializeLoggerValue(item, seen));
+        }
+        if (value instanceof Set) {
+            return Array.from(value, (item) => serializeLoggerValue(item, seen));
+        }
+        const result = {};
         // 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,
-        });
+        const define = (key, item) => {
+            Object.defineProperty(result, key, {
+                value: item,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+        };
+        if (value instanceof Map) {
+            for (const [key, item] of value.entries()) {
+                define(typeof key === "string" ? key : String(key), serializeLoggerValue(item, seen));
+            }
+            return result;
+        }
+        for (const key of Object.keys(value)) {
+            let item;
+            try {
+                item = value[key];
+            }
+            catch {
+                define(key, LOGGER_UNREADABLE_TOKEN);
+                continue;
+            }
+            define(key, serializeLoggerValue(item, seen));
+        }
+        return result;
+    }
+    finally {
+        seen.delete(value);
     }
-    return result;
 }
 //# sourceMappingURL=loggerEntryHelpers.valueSerialize.js.map

package/dist/loggerErrors/loggerError.helpers.d.ts

@@ -12,4 +12,15 @@ export declare function getLoggerErrorCause(error: unknown): unknown;
 export declare function createLoggerTransportError(transportName: string, error: unknown): LoggerTransportError;
 /** Creates a formatter error while preserving the original failure. */
 export declare function createLoggerFormatterError(formatterName: string, error: unknown): LoggerFormatterError;
+/**
+ * Rethrows collected failures: the single failure itself, or an
+ * AggregateError when more than one step failed. Does nothing when the
+ * list is empty.
+ */
+export declare function throwCollectedFailures(failures: readonly unknown[], message: string): void;
+/**
+ * Runs every step even when earlier ones fail, then rethrows the
+ * collected failures via {@link throwCollectedFailures}.
+ */
+export declare function settleAllOrThrow(steps: readonly (() => unknown)[], message: string): Promise<void>;
 //# sourceMappingURL=loggerError.helpers.d.ts.map

package/dist/loggerErrors/loggerError.helpers.js

@@ -38,4 +38,25 @@ export function createLoggerFormatterError(formatterName, error) {
     const message = error instanceof Error ? error.message : String(error);
     return new LoggerFormatterError(`Logger formatter "${formatterName}" failed: ${message}`, { formatterName, cause });
 }
+/**
+ * Rethrows collected failures: the single failure itself, or an
+ * AggregateError when more than one step failed. Does nothing when the
+ * list is empty.
+ */
+export function throwCollectedFailures(failures, message) {
+    if (failures.length === 0)
+        return;
+    if (failures.length === 1)
+        throw failures[0];
+    throw new AggregateError(failures, message);
+}
+/**
+ * Runs every step even when earlier ones fail, then rethrows the
+ * collected failures via {@link throwCollectedFailures}.
+ */
+export async function settleAllOrThrow(steps, message) {
+    const results = await Promise.allSettled(steps.map(async (step) => step()));
+    const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    throwCollectedFailures(failures, message);
+}
 //# sourceMappingURL=loggerError.helpers.js.map

package/dist/loggerFactory/loggerFactory.core.d.ts

@@ -17,6 +17,13 @@ export declare class LoggerFactory {
      * instance is returned unless `forceNew` is enabled.
      */
     create(name?: string, options?: LoggerOptions, forceNew?: boolean): Logger;
+    /**
+     * Registers an existing logger under its own name (or `name`).
+     *
+     * An adopted logger is then covered by `flushAll()`, `disposeAll()`,
+     * `getAll()` and `size` exactly like one the factory created itself.
+     */
+    register(logger: Logger, name?: string): Logger;
     /** Returns an existing logger. */
     get(name: string): Logger | undefined;
     /** Gets an existing logger or creates it. */

package/dist/loggerFactory/loggerFactory.core.js

@@ -31,6 +31,16 @@ export class LoggerFactory {
         this.loggers.set(loggerName, logger);
         return logger;
     }
+    /**
+     * Registers an existing logger under its own name (or `name`).
+     *
+     * An adopted logger is then covered by `flushAll()`, `disposeAll()`,
+     * `getAll()` and `size` exactly like one the factory created itself.
+     */
+    register(logger, name) {
+        this.loggers.set(name ?? logger.name, logger);
+        return logger;
+    }
     /** Returns an existing logger. */
     get(name) {
         return this.loggers.get(name);

package/dist/loggerFormatter/loggerFormatter.core.js

@@ -1,6 +1,7 @@
 /**
  * Core logger formatter functions.
  */
+import { LoggerFormatterNotFoundError } from "../loggerErrors/loggerError.base.js";
 import { createLoggerFormatterId, isLoggerFormatterFunction, isLoggerFormatterObject, isLoggerFormatter, } from "./loggerFormatterGuard.js";
 /**
  * Creates a function-backed formatter.
@@ -20,7 +21,7 @@ export function createLoggerFormatter(formatter, options = {}) {
                 return formatter(entry, context);
             }
             if (typeof formatter === "string") {
-                throw new Error(`Cannot format with string identifier "${formatter}" directly. Resolve the formatter first.`);
+                throw new LoggerFormatterNotFoundError(formatter);
             }
             return formatter.format(entry, context);
         },
@@ -34,7 +35,7 @@ export function formatLoggerEntry(formatter, entry, context = {}) {
         return formatter(entry, context);
     }
     if (typeof formatter === "string") {
-        throw new Error(`Cannot format with string identifier "${formatter}" directly. Resolve the formatter first.`);
+        throw new LoggerFormatterNotFoundError(formatter);
     }
     return formatter.format(entry, context);
 }

package/dist/loggerFormatter/loggerFormatterFormatters/loggerFormatterFormatters.js

@@ -11,7 +11,7 @@ import { createTextLoggerFormatter } from "./loggerFormatterFormatters.text.js";
  */
 export function createCompactLoggerFormatter(options = {}) {
     return createLoggerFormatter((entry) => {
-        const level = entry.levelName.toUpperCase();
+        const level = escapeLogText(entry.levelName.toUpperCase());
         const logger = entry.logger ? ` ${escapeLogText(entry.logger)}:` : "";
         return `${level}${logger} ${escapeLogText(entry.message)}`;
     }, {

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

@@ -12,29 +12,42 @@ function removeUndefinedValues(value, seen = new WeakSet()) {
             return "[Circular]";
         }
         seen.add(value);
-        return value.map((item) => removeUndefinedValues(item, seen));
+        try {
+            return value.map((item) => removeUndefinedValues(item, seen));
+        }
+        finally {
+            seen.delete(value);
+        }
     }
     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.
+        // the log line rather than reporting the offending value. `seen`
+        // tracks the ancestor path only (unmarked on ascent), so an object
+        // referenced twice in one payload is kept rather than collapsing
+        // to "[Circular]" from its second occurrence on.
         if (seen.has(value)) {
             return "[Circular]";
         }
         seen.add(value);
-        const result = {};
-        for (const [key, item] of Object.entries(value)) {
-            if (item === undefined) {
-                continue;
+        try {
+            const result = {};
+            for (const [key, item] of Object.entries(value)) {
+                if (item === undefined) {
+                    continue;
+                }
+                Object.defineProperty(result, key, {
+                    value: removeUndefinedValues(item, seen),
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
             }
-            Object.defineProperty(result, key, {
-                value: removeUndefinedValues(item, seen),
-                enumerable: true,
-                writable: true,
-                configurable: true,
-            });
+            return result;
+        }
+        finally {
+            seen.delete(value);
         }
-        return result;
     }
     return value;
 }