@zudojs/logger 1.1.0 → 1.3.0

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

@@ -11,6 +11,12 @@ export declare function formatMetadata(metadata: Record<string, unknown>, separa
 export declare function formatValue(value: unknown): string;
 /**
  * Formats an Error.
+ *
+ * With a stack trace the output is intentionally multi-line, but only
+ * the frame lines break the line: the header (which carries the
+ * attacker-influenceable message) is escaped as a single line, and every
+ * frame line is escaped and indented so none of them can start at
+ * column 0 and parse as a record of its own.
  */
 export declare function formatError(error: Error, includeStackTrace: boolean): string;
 //# sourceMappingURL=loggerFormatterFormatters.metadata.d.ts.map

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

@@ -23,28 +23,63 @@ export function formatValue(value) {
     }
     if (typeof value === "string") {
         if (/\s/.test(value)) {
-            return JSON.stringify(value);
+            // JSON escapes C0 controls but not DEL, C1 or U+2028/U+2029.
+            return escapeLogText(JSON.stringify(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 escapeLogText(JSON.stringify(serializeLoggerValue(value)));
     }
     return escapeLogText(String(value));
 }
+/**
+ * Splits an error's stack into its header (name and message) and its
+ * frame lines.
+ *
+ * The header is derived from the error itself rather than from the first
+ * stack line, because the message can contain newlines of its own and
+ * would otherwise spill across several "lines" of the stack.
+ */
+function splitStack(error, stack) {
+    const message = String(error.message ?? "");
+    const header = message ? `${error.name}: ${message}` : String(error.name);
+    if (stack.startsWith(header)) {
+        const rest = stack.slice(header.length).replace(/^\r?\n/u, "");
+        return { header, frames: rest ? rest.split("\n") : [] };
+    }
+    const lines = stack.split("\n");
+    const firstFrame = lines.findIndex((line) => /^\s+at\s/u.test(line));
+    if (firstFrame === -1) {
+        return { header: stack, frames: [] };
+    }
+    return {
+        header: lines.slice(0, firstFrame).join("\n"),
+        frames: lines.slice(firstFrame),
+    };
+}
 /**
  * Formats an Error.
+ *
+ * With a stack trace the output is intentionally multi-line, but only
+ * the frame lines break the line: the header (which carries the
+ * attacker-influenceable message) is escaped as a single line, and every
+ * frame line is escaped and indented so none of them can start at
+ * column 0 and parse as a record of its own.
  */
 export function formatError(error, includeStackTrace) {
-    if (includeStackTrace && 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")}`;
+    if (includeStackTrace && typeof error.stack === "string" && error.stack) {
+        const { header, frames } = splitStack(error, error.stack);
+        const lines = [escapeLogText(header)];
+        for (const frame of frames) {
+            const escaped = escapeLogText(frame);
+            lines.push(/^\s/u.test(escaped) ? escaped : `    ${escaped}`);
+        }
+        return `\n${lines.join("\n")}`;
     }
     const serialized = serializeLoggerError(error);
-    return `error=${JSON.stringify(serialized)}`;
+    return `error=${escapeLogText(JSON.stringify(serialized))}`;
 }
 //# sourceMappingURL=loggerFormatterFormatters.metadata.js.map

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

@@ -43,7 +43,7 @@ export function createTextLoggerFormatter(options = {}) {
         // 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()}]`;
+        const levelTag = `[${escapeLogText(entry.levelName.toUpperCase())}]`;
         parts.push(context.colors ? colorizeLevel(entry.levelName, levelTag) : levelTag);
         if (includeLogger && entry.logger) {
             parts.push(`[${escapeLogText(entry.logger)}]`);

package/dist/loggerLevel/loggerLevel.type.js

@@ -4,6 +4,7 @@
  * Lower numeric values represent more severe messages.
  * Higher numeric values represent more verbose messages.
  */
+import { InvalidLoggerLevelError } from "../loggerErrors/loggerError.base.js";
 export var LoggerLevel;
 (function (LoggerLevel) {
     LoggerLevel[LoggerLevel["FATAL"] = 0] = "FATAL";
@@ -29,7 +30,7 @@ export function loggerLevelToName(level) {
         case LoggerLevel.TRACE:
             return "trace";
         default:
-            throw new RangeError(`Unknown logger level: ${String(level)}`);
+            throw new InvalidLoggerLevelError(level);
     }
 }
 /** Converts a logger level name into its enum value. */
@@ -50,7 +51,7 @@ export function loggerLevelFromName(name) {
         case "trace":
             return LoggerLevel.TRACE;
         default:
-            throw new RangeError(`Unknown logger level name: "${name}"`);
+            throw new InvalidLoggerLevelError(name);
     }
 }
 /** Checks whether a value is a valid LoggerLevel. */

package/dist/loggerManager/loggerManager.core.d.ts

@@ -16,6 +16,16 @@ export declare class LoggerManager {
     constructor(options?: LoggerOptions);
     /** Initializes the logger manager. Initialization is idempotent. */
     initialize(options?: LoggerOptions): Logger;
+    /**
+     * Adopts an existing logger as the manager's default logger.
+     *
+     * The logger is REGISTERED with the underlying factory, so it is
+     * covered by flush(), close(), getAll() and size. Assigning it to the
+     * private default field alone (as createLoggerManagerFromLogger used
+     * to) left the registry empty, making flush()/close() no-ops for the
+     * only logger the manager owned.
+     */
+    adopt(logger: Logger): Logger;
     /** Returns the default application logger. Lazily initializes when necessary. */
     getLogger(): Logger;
     /** Returns a named logger. Named loggers are managed by the underlying factory. */

package/dist/loggerManager/loggerManager.core.js

@@ -1,3 +1,4 @@
+import { LoggerDisposedError } from "../loggerErrors/loggerError.base.js";
 import { createLogger } from "../loggerCore/core/loggerCore.core.js";
 import { createDefaultLogger } from "../loggerCore/helpers/loggerCore.helper.js";
 import { createLoggerFactory } from "../loggerFactory/loggerFactory.core.js";
@@ -19,7 +20,7 @@ export class LoggerManager {
     /** Initializes the logger manager. Initialization is idempotent. */
     initialize(options = {}) {
         if (this.closed)
-            throw new Error("LoggerManager has been closed.");
+            throw new LoggerDisposedError("LoggerManager");
         if (this.initialized && this.defaultLogger)
             return this.defaultLogger;
         const logger = this.factory.create(options.name ?? "zudojs", options);
@@ -27,10 +28,27 @@ export class LoggerManager {
         this.initialized = true;
         return logger;
     }
+    /**
+     * Adopts an existing logger as the manager's default logger.
+     *
+     * The logger is REGISTERED with the underlying factory, so it is
+     * covered by flush(), close(), getAll() and size. Assigning it to the
+     * private default field alone (as createLoggerManagerFromLogger used
+     * to) left the registry empty, making flush()/close() no-ops for the
+     * only logger the manager owned.
+     */
+    adopt(logger) {
+        if (this.closed)
+            throw new LoggerDisposedError("LoggerManager");
+        this.factory.register(logger);
+        this.defaultLogger = logger;
+        this.initialized = true;
+        return logger;
+    }
     /** Returns the default application logger. Lazily initializes when necessary. */
     getLogger() {
         if (this.closed)
-            throw new Error("LoggerManager has been closed.");
+            throw new LoggerDisposedError("LoggerManager");
         if (!this.defaultLogger)
             return this.initialize();
         return this.defaultLogger;
@@ -38,13 +56,13 @@ export class LoggerManager {
     /** Returns a named logger. Named loggers are managed by the underlying factory. */
     get(name, options = {}) {
         if (this.closed)
-            throw new Error("LoggerManager has been closed.");
+            throw new LoggerDisposedError("LoggerManager");
         return this.factory.getOrCreate(name, options);
     }
     /** Creates a new logger even when another logger with the same name already exists. */
     create(name, options = {}) {
         if (this.closed)
-            throw new Error("LoggerManager has been closed.");
+            throw new LoggerDisposedError("LoggerManager");
         return this.factory.create(name, options, true);
     }
     /** Checks whether a named logger exists. */
@@ -99,7 +117,7 @@ export class LoggerManager {
     /** Provides direct access to the underlying factory. */
     getFactory() {
         if (this.closed)
-            throw new Error("LoggerManager has been closed.");
+            throw new LoggerDisposedError("LoggerManager");
         return this.factory;
     }
 }
@@ -120,8 +138,7 @@ export function createManagedDefaultLogger(name = "zudojs") {
 /** Creates a logger manager from an existing logger. */
 export function createLoggerManagerFromLogger(logger) {
     const manager = new LoggerManager();
-    manager["defaultLogger"] = logger;
-    manager["initialized"] = true;
+    manager.adopt(logger);
     return manager;
 }
 /** Returns a logger from a manager or creates a fallback logger when no manager is supplied. */

package/dist/loggerTransport/loggerTransportComposite/loggerTransportComposite.buffered.js

@@ -2,7 +2,9 @@
  * Buffered logger transport.
  */
 import { createLoggerTransport, writeLoggerTransport, } from "../loggerTransport.core.js";
-import { isLoggerTransportObject } from "../loggerTransportGuard.js";
+import { closeLoggerTransport, flushLoggerTransport, } from "../loggerTransportHelpers/loggerTransportHelpers.js";
+import { throwCollectedFailures } from "../../loggerErrors/loggerError.helpers.js";
+import { LoggerTransportClosedError } from "../../loggerErrors/loggerError.base.js";
 /**
  * Creates a transport that buffers entries before forwarding
  * them to another transport.
@@ -12,14 +14,51 @@ export function createBufferedLoggerTransport(transport, options = {}) {
     const maxSize = options.maxSize ?? 100;
     const flushInterval = options.flushInterval ?? 0;
     let timer;
-    const flush = async () => {
+    let deferredFailure;
+    let closed = false;
+    // Each entry is written on its own: one failing write used to abort the
+    // loop after the whole batch had already been spliced out, losing every
+    // entry behind it. Only the entries that actually failed are dropped.
+    const drain = async () => {
         if (buffer.length === 0) {
             return;
         }
         const entries = buffer.splice(0, buffer.length);
+        const failures = [];
         for (const entry of entries) {
-            await writeLoggerTransport(transport, entry);
+            try {
+                await writeLoggerTransport(transport, entry);
+            }
+            catch (error) {
+                failures.push(error);
+            }
+        }
+        throwCollectedFailures(failures, `${failures.length} buffered log entries failed to write.`);
+    };
+    // A failure from a timer-triggered drain has no caller to reach, so it
+    // is kept and rethrown by the next explicit flush()/close().
+    const takeDeferredFailure = () => {
+        if (!deferredFailure)
+            return [];
+        const { error } = deferredFailure;
+        deferredFailure = undefined;
+        return [error];
+    };
+    const flush = async () => {
+        const failures = takeDeferredFailure();
+        try {
+            await drain();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            await flushLoggerTransport(transport);
         }
+        catch (error) {
+            failures.push(error);
+        }
+        throwCollectedFailures(failures, "Buffered logger transport flush failed.");
     };
     const scheduleFlush = () => {
         if (flushInterval <= 0 || timer) {
@@ -28,10 +67,10 @@ export function createBufferedLoggerTransport(transport, options = {}) {
         timer = setTimeout(async () => {
             timer = undefined;
             try {
-                await flush();
+                await drain();
             }
-            catch {
-                /* deliberate no-op */
+            catch (error) {
+                deferredFailure ??= { error };
             }
         }, flushInterval);
         // A pending flush is housekeeping, not work: left referenced it kept a
@@ -43,9 +82,15 @@ export function createBufferedLoggerTransport(transport, options = {}) {
         name: options.name ?? "buffered",
         enabled: options.enabled ?? true,
         async write(entry) {
+            // A write after close() used to be buffered and then silently
+            // dropped: nothing drains the buffer again. Refuse it instead so
+            // the caller learns the entry was not accepted.
+            if (closed) {
+                throw new LoggerTransportClosedError(options.name ?? "buffered");
+            }
             buffer.push(entry);
             if (buffer.length >= maxSize) {
-                await flush();
+                await drain();
             }
             else {
                 scheduleFlush();
@@ -53,14 +98,25 @@ export function createBufferedLoggerTransport(transport, options = {}) {
         },
         flush,
         async close() {
+            closed = true;
             if (timer) {
                 clearTimeout(timer);
                 timer = undefined;
             }
-            await flush();
-            if (isLoggerTransportObject(transport) && transport.close) {
-                await transport.close();
+            const failures = [];
+            try {
+                await flush();
+            }
+            catch (error) {
+                failures.push(error);
+            }
+            try {
+                await closeLoggerTransport(transport);
+            }
+            catch (error) {
+                failures.push(error);
             }
+            throwCollectedFailures(failures, "Buffered logger transport close failed.");
         },
     };
     return createLoggerTransport(buffered, options);

package/dist/loggerTransport/loggerTransportComposite/loggerTransportComposite.d.ts

@@ -7,11 +7,20 @@ import { createBufferedLoggerTransport } from "./loggerTransportComposite.buffer
 /**
  * Creates a transport that forwards entries to another
  * transport only when a predicate passes.
+ *
+ * `flush()` and `close()` are forwarded to the inner transport, so a
+ * buffered or file transport nested inside is drained and released by
+ * the logger's own `flush()`/`close()`.
  */
 export declare function createConditionalLoggerTransport(transport: LoggerTransportLike, predicate: (entry: LoggerEntry) => boolean | Promise<boolean>, options?: LoggerTransportOptions): RegisteredLoggerTransport;
 /**
  * Creates a transport that forwards entries to multiple
  * transports.
+ *
+ * Every sink receives every entry even when another sink throws: writes
+ * are settled independently and the failures are rethrown afterwards
+ * (one failure as itself, several as an AggregateError). `flush()` and
+ * `close()` fan out to every inner transport the same way.
  */
 export declare function createMultiLoggerTransport(transports: readonly LoggerTransportLike[], options?: LoggerTransportOptions): RegisteredLoggerTransport;
 export { createBufferedLoggerTransport };

package/dist/loggerTransport/loggerTransportComposite/loggerTransportComposite.js

@@ -2,27 +2,48 @@
  * Composite logger transports.
  */
 import { createLoggerTransport, writeLoggerTransport, } from "../loggerTransport.core.js";
+import { createLoggerTransportId } from "../loggerTransportGuard.js";
+import { closeLoggerTransport, flushLoggerTransport, } from "../loggerTransportHelpers/loggerTransportHelpers.js";
+import { settleAllOrThrow } from "../../loggerErrors/loggerError.helpers.js";
 import { createBufferedLoggerTransport } from "./loggerTransportComposite.buffered.js";
 /**
  * Creates a transport that forwards entries to another
  * transport only when a predicate passes.
+ *
+ * `flush()` and `close()` are forwarded to the inner transport, so a
+ * buffered or file transport nested inside is drained and released by
+ * the logger's own `flush()`/`close()`.
  */
 export function createConditionalLoggerTransport(transport, predicate, options = {}) {
-    return createLoggerTransport(async (entry, context) => {
-        if (await predicate(entry)) {
-            await writeLoggerTransport(transport, entry, context);
-        }
+    return createLoggerTransport({
+        name: options.name ?? createLoggerTransportId(),
+        enabled: options.enabled ?? true,
+        async write(entry, context) {
+            if (await predicate(entry)) {
+                await writeLoggerTransport(transport, entry, context);
+            }
+        },
+        flush: () => flushLoggerTransport(transport),
+        close: () => closeLoggerTransport(transport),
     }, options);
 }
 /**
  * Creates a transport that forwards entries to multiple
  * transports.
+ *
+ * Every sink receives every entry even when another sink throws: writes
+ * are settled independently and the failures are rethrown afterwards
+ * (one failure as itself, several as an AggregateError). `flush()` and
+ * `close()` fan out to every inner transport the same way.
  */
 export function createMultiLoggerTransport(transports, options = {}) {
-    return createLoggerTransport(async (entry, context) => {
-        for (const transport of transports) {
-            await writeLoggerTransport(transport, entry, context);
-        }
+    const sinks = [...transports];
+    return createLoggerTransport({
+        name: options.name ?? createLoggerTransportId(),
+        enabled: options.enabled ?? true,
+        write: (entry, context) => settleAllOrThrow(sinks.map((sink) => () => writeLoggerTransport(sink, entry, context)), "Multiple logger transports failed to write an entry."),
+        flush: () => settleAllOrThrow(sinks.map((sink) => () => flushLoggerTransport(sink)), "Multiple logger transports failed to flush."),
+        close: () => settleAllOrThrow(sinks.map((sink) => () => closeLoggerTransport(sink)), "Multiple logger transports failed to close."),
     }, options);
 }
 export { createBufferedLoggerTransport };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/logger",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Structured logging with transports, log levels, and context propagation for Zudojs applications.",
   "license": "MIT",
   "author": {
@@ -28,7 +28,7 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@zudojs/errors": "1.0.1"
+    "@zudojs/errors": "1.2.0"
   },
   "devDependencies": {
     "typescript": "7.0.2",