@zudojs/logger 1.2.0 → 1.4.0

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

@@ -1,25 +1,27 @@
 /**
  * ZudojsLogger lifecycle methods.
  */
-import { LoggerLevel } from "../../../loggerLevel/loggerLevel.type.js";
+import { resolveLoggerLevel, } from "../../../loggerLevel/loggerLevel.type.js";
 import { createLoggerTransport } from "../../../loggerTransport/loggerTransport.core.js";
 import { isLoggerTransport } from "../../../loggerTransport/loggerTransportGuard.js";
 import { LoggerConfigurationError } from "../../../loggerErrors/loggerError.base.js";
 import { throwCollectedFailures } from "../../../loggerErrors/loggerError.helpers.js";
 /**
- * Sets the logger level.
+ * Sets the logger level from an enum value or a case-insensitive name.
  */
 export function setLoggerLevel(ctx, level) {
     ctx.assertActive();
-    if (!Number.isInteger(level) ||
-        level < LoggerLevel.FATAL ||
-        level > LoggerLevel.TRACE) {
+    let resolved;
+    try {
+        resolved = resolveLoggerLevel(level);
+    }
+    catch {
         throw new LoggerConfigurationError(`Invalid logger level: ${String(level)}.`);
     }
     ctx.assertMutable();
     ctx.updateConfiguration({
         ...ctx.configuration,
-        level,
+        level: resolved,
     });
 }
 /**

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.interfaces.d.ts

@@ -20,9 +20,19 @@ export interface LoggerEntry {
      */
     readonly levelName: LoggerLevelName;
     /**
-     * Human-readable message.
+     * The message as the caller logged it. A transport receives it unchanged;
+     * the formatter's rendering of the whole record is in `formatted`.
      */
     readonly message: string;
+    /**
+     * The record rendered as one line by the logger's formatter: the string a
+     * text or JSON formatter returned, or the JSON line of the record an
+     * object formatter (`createStructuredLoggerFormatter`) returned. Set on
+     * entries a logger hands to its transports. Line-oriented transports
+     * print `entry.formatted ?? entry.message`; `message` is always the raw
+     * message the caller logged.
+     */
+    readonly formatted?: string;
     /**
      * Structured metadata.
      */

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

@@ -12,6 +12,14 @@
  * Replacement token written in place of a redacted value.
  */
 export declare const LOGGER_REDACTION_TOKEN = "[REDACTED]";
+/**
+ * Replacement token written in place of a property whose getter threw.
+ *
+ * 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.
  *
@@ -64,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

@@ -19,6 +19,14 @@ 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]";
+/**
+ * Replacement token written in place of a property whose getter threw.
+ *
+ * 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.
  *
@@ -85,15 +93,32 @@ export function createSecretMatcher(options = {}) {
         : configured;
     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;
     }
@@ -104,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

@@ -3,14 +3,23 @@
  */
 /**
  * Serializes an error-like object into a plain object.
+ *
+ * @param includeStack - `false` leaves the stack out (its frames carry
+ *   absolute file paths). Defaults to `true`.
  */
 export declare function serializeLoggerError(error: {
     name?: string;
     message: string;
     stack?: string;
-}): Record<string, unknown>;
+}, includeStack?: boolean): 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. `includeErrorStack: false` leaves the
+ * stack out of every Error found in the value.
  */
-export declare function serializeLoggerValue(value: unknown, seen?: WeakSet<object>): unknown;
+export declare function serializeLoggerValue(value: unknown, seen?: WeakSet<object>, includeErrorStack?: boolean): unknown;
 //# sourceMappingURL=loggerEntryHelpers.valueSerialize.d.ts.map

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

@@ -1,20 +1,28 @@
 /**
  * Logger entry value serialization.
  */
+import { LOGGER_UNREADABLE_TOKEN } from "./loggerEntryHelpers.sanitize.js";
 /**
  * Serializes an error-like object into a plain object.
+ *
+ * @param includeStack - `false` leaves the stack out (its frames carry
+ *   absolute file paths). Defaults to `true`.
  */
-export function serializeLoggerError(error) {
-    return {
-        name: error.name,
-        message: error.message,
-        stack: error.stack,
-    };
+export function serializeLoggerError(error, includeStack = true) {
+    return includeStack
+        ? { name: error.name, message: error.message, stack: error.stack }
+        : { name: error.name, message: error.message };
 }
 /**
  * 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. `includeErrorStack: false` leaves the
+ * stack out of every Error found in the value.
  */
-export function serializeLoggerValue(value, seen = new WeakSet()) {
+export function serializeLoggerValue(value, seen = new WeakSet(), includeErrorStack = true) {
     if (value === null ||
         value === undefined ||
         typeof value === "string" ||
@@ -29,7 +37,7 @@ export function serializeLoggerValue(value, seen = new WeakSet()) {
         return value.toISOString();
     }
     if (value instanceof Error) {
-        return serializeLoggerError(value);
+        return serializeLoggerError(value, includeErrorStack);
     }
     if (typeof value === "function") {
         return `[Function ${value.name || "anonymous"}]`;
@@ -44,21 +52,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, includeErrorStack));
+        }
+        if (value instanceof Set) {
+            return Array.from(value, (item) => serializeLoggerValue(item, seen, includeErrorStack));
+        }
+        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, includeErrorStack));
+            }
+            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, includeErrorStack));
+        }
+        return result;
+    }
+    finally {
+        seen.delete(value);
     }
-    return result;
 }
 //# sourceMappingURL=loggerEntryHelpers.valueSerialize.js.map

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

@@ -1,5 +1,5 @@
 import type { Logger } from "../loggerCore/core/loggerCore.type.js";
-import type { LoggerOptions, ChildLoggerOptions } from "../loggerOptions/loggerOptions.type.js";
+import type { LoggerOptions, ChildLoggerOptionsInput } from "../loggerOptions/loggerOptions.type.js";
 /**
  * Factory responsible for creating and managing Zudojs loggers.
  *
@@ -17,12 +17,19 @@ 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. */
     getOrCreate(name: string, options?: LoggerOptions): Logger;
     /** Creates a child logger from an existing logger. */
-    child(parent: Logger, options?: ChildLoggerOptions): Logger;
+    child(parent: Logger, options?: ChildLoggerOptionsInput): Logger;
     /**
      * Removes a logger from the factory registry.
      *

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.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;
 }

package/dist/loggerFormatter/loggerFormatterFormatters/loggerFormatterFormatters.metadata.d.ts

@@ -3,12 +3,15 @@
  */
 /**
  * Formats metadata as key=value pairs.
+ *
+ * @param includeStackTrace - `false` leaves the stack out of any Error in
+ *   the metadata, as the text formatter's option of the same name promises.
  */
-export declare function formatMetadata(metadata: Record<string, unknown>, separator: string): string;
+export declare function formatMetadata(metadata: Record<string, unknown>, separator: string, includeStackTrace?: boolean): string;
 /**
  * Formats an arbitrary metadata value.
  */
-export declare function formatValue(value: unknown): string;
+export declare function formatValue(value: unknown, includeStackTrace?: boolean): string;
 /**
  * Formats an Error.
  *

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

@@ -5,19 +5,22 @@ import { serializeLoggerError, serializeLoggerValue, } from "../../loggerEntry/l
 import { escapeLogText } from "../../loggerEntry/loggerEntryHelpers/loggerEntryHelpers.sanitize.js";
 /**
  * Formats metadata as key=value pairs.
+ *
+ * @param includeStackTrace - `false` leaves the stack out of any Error in
+ *   the metadata, as the text formatter's option of the same name promises.
  */
-export function formatMetadata(metadata, separator) {
+export function formatMetadata(metadata, separator, includeStackTrace = true) {
     return (Object.entries(metadata)
         .filter(([, value]) => value !== undefined)
         // 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)}`)
+        .map(([key, value]) => `${escapeLogText(key)}=${formatValue(value, includeStackTrace)}`)
         .join(separator));
 }
 /**
  * Formats an arbitrary metadata value.
  */
-export function formatValue(value) {
+export function formatValue(value, includeStackTrace = true) {
     if (value === null) {
         return "null";
     }
@@ -31,7 +34,8 @@ export function formatValue(value) {
         return escapeLogText(value);
     }
     if (typeof value === "object") {
-        return escapeLogText(JSON.stringify(serializeLoggerValue(value)));
+        const serialized = serializeLoggerValue(value, new WeakSet(), includeStackTrace);
+        return escapeLogText(JSON.stringify(serialized));
     }
     return escapeLogText(String(value));
 }
@@ -79,7 +83,10 @@ export function formatError(error, includeStackTrace) {
         }
         return `\n${lines.join("\n")}`;
     }
-    const serialized = serializeLoggerError(error);
+    // Name and message only: the fallback used to serialize the stack as
+    // well, so `includeStackTrace: false` still printed every frame (and the
+    // absolute paths in them) inside the JSON.
+    const serialized = serializeLoggerError(error, false);
     return `error=${escapeLogText(JSON.stringify(serialized))}`;
 }
 //# sourceMappingURL=loggerFormatterFormatters.metadata.js.map

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

@@ -65,12 +65,16 @@ export function createTextLoggerFormatter(options = {}) {
             }
         }
         if (includeMetadata && Object.keys(entry.metadata).length > 0) {
-            parts.push(formatMetadata(entry.metadata, metadataSeparator));
+            parts.push(formatMetadata(entry.metadata, metadataSeparator, includeStackTrace));
         }
-        if (entry.error) {
-            parts.push(formatError(entry.error, includeStackTrace));
+        const line = parts.join(" ");
+        if (!entry.error) {
+            return line;
         }
-        return parts.join(" ");
+        // A stack starts on its own line; joining it with " " left a trailing
+        // space after the message.
+        const error = formatError(entry.error, includeStackTrace);
+        return error.startsWith("\n") ? `${line}${error}` : `${line} ${error}`;
     }, { name: options.name ?? "text" });
 }
 //# sourceMappingURL=loggerFormatterFormatters.text.js.map

package/dist/loggerLevel/loggerLevel.type.d.ts

@@ -14,10 +14,23 @@ export declare enum LoggerLevel {
 }
 /** String representation of supported logger levels. */
 export type LoggerLevelName = "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+/**
+ * A level as configuration accepts it: the enum value, or its name in any
+ * case (`"error"`, `"ERROR"`). `"warning"` and `"information"` are accepted
+ * at runtime as aliases of `"warn"` and `"info"`.
+ */
+export type LoggerLevelLike = LoggerLevel | LoggerLevelName | Uppercase<LoggerLevelName>;
 /** Converts a logger level into its canonical name. */
 export declare function loggerLevelToName(level: LoggerLevel): LoggerLevelName;
 /** Converts a logger level name into its enum value. */
 export declare function loggerLevelFromName(name: LoggerLevelName | string): LoggerLevel;
+/**
+ * Resolves a configured level (enum value or case-insensitive name) to its
+ * enum value.
+ *
+ * @throws InvalidLoggerLevelError when the value is neither.
+ */
+export declare function resolveLoggerLevel(level: LoggerLevelLike): LoggerLevel;
 /** Checks whether a value is a valid LoggerLevel. */
 export declare function isLoggerLevel(value: unknown): value is LoggerLevel;
 /** Checks whether a value is a valid logger level name. */