@bymax-one/nest-logger 1.2.4 → 1.2.6

package/dist/server/index.d.ts

@@ -864,28 +864,104 @@ declare class DefaultStdoutDestination implements ILogDestination {
     });
     /**
      * Write a serialized JSON log entry (terminated with `\n`) to `stdout`.
+     *
+     * Routed through {@link writeStdoutSafely} rather than calling
+     * `process.stdout.write` directly. This is the sink a consumer gets when they
+     * configure nothing, so it is the path that decides whether a closed pipe
+     * (`node app | head`) kills the application — and unguarded, it did: EPIPE
+     * arrives asynchronously through the stream's `'error'` event, Node attaches no
+     * default handler, and the emit becomes an uncaught exception. Measured on the
+     * built artifact, exit code 42.
      */
     write(payload: string): void;
 }
 
+/**
+ * How the development terminal renders an entry — a VIEW over the record, never
+ * a change to it. Every field maps to the `pino-pretty` option of the same name.
+ *
+ * Declared here rather than reusing `pino-pretty`'s own `PrettyOptions`, and the
+ * reason is load-bearing: a type import from the peer emits a hard
+ * `import { PrettyOptions } from 'pino-pretty'` at the top of the published
+ * `.d.ts`, so every consumer who type-checks WITHOUT the optional peer installed
+ * would hit an unresolved module. That would make an optional peer effectively
+ * required — a worse regression than the missing options, and the same
+ * contradiction this library already refused when asked to hard-fail on a missing
+ * peer. Measured on the built artifact, not assumed.
+ *
+ * `destination` is deliberately absent. The library owns where entries go; a
+ * consumer redirecting the stream would route around the multistream fan-out and
+ * the last-resort rescue. Omitting it from this type states the intent — applying
+ * the library's own value AFTER the spread in {@link PrettyDevDestination.onInit}
+ * is what enforces it, including against an untyped JavaScript caller.
+ *
+ * @example
+ *   // One line per entry, with the fields a project repeats on every line hidden.
+ *   const view: PrettyViewOptions = {
+ *     singleLine: true,
+ *     ignore: 'pid,hostname,service,deployment,event.name'
+ *   }
+ */
+interface PrettyViewOptions {
+    /**
+     * Collapse the whole entry onto one line. The single biggest change to how a
+     * terminal reads — `false` is what expands one entry into a block.
+     * Default: `false`.
+     */
+    singleLine?: boolean;
+    /**
+     * Comma-separated field names to hide from the rendered line. Display-only:
+     * what a real sink receives is untouched. Extend rather than replace when the
+     * goal is quieter output — the default already hides the noisiest fields.
+     * Default: `'pid,hostname,service'`.
+     */
+    ignore?: string;
+    /**
+     * Render only the message line, hiding the record entirely. In pretty mode
+     * there is no JSON copy behind it (`destinations` REPLACES stdout), so a field
+     * hidden here is not visible anywhere — including `logKey`. That is the point
+     * of the option rather than a caveat; use `messageFormat` to pull a specific
+     * field back into the line. Default: `false`.
+     */
+    hideObject?: boolean;
+    /**
+     * Template for the message line, e.g. `'[{context}] {msg}'`. The way to keep a
+     * chosen field visible when `hideObject` is on.
+     */
+    messageFormat?: string;
+    /** Timestamp format, or `false` to leave it raw. Default: `'SYS:HH:MM:ss.l'`. */
+    translateTime?: string | boolean;
+    /** ANSI colour in the rendered line. Default: `true`. */
+    colorize?: boolean;
+}
 /**
  * Pretty-print destination backed by `pino-pretty`.
  *
  * Lifecycle contract (driven by `DestinationRegistry`):
- *   1. `onInit()` resolves `pino-pretty` and builds the transform (rendering to
- *      `process.stdout`).
+ *   1. `onInit()` resolves `pino-pretty`, builds the transform (rendering to
+ *      `process.stdout`), and flushes anything written before it existed.
  *   2. `write()` forwards each serialized line to the transform.
  *   3. `onShutdown()` flushes and closes the transform.
  *
  * @example
- *   BymaxLoggerModule.forRoot({
- *     service: { name: 'api', version: '1.0.0' },
- *     destinations: [new PrettyDevDestination()]
+ *   // Default view — unchanged by the options below.
+ *   new PrettyDevDestination()
+ *
+ *   // One line per entry, with this project's repeated fields hidden.
+ *   new PrettyDevDestination({
+ *     view: { singleLine: true, ignore: 'pid,hostname,service,deployment,event.name' }
+ *   })
+ *
+ *   // Message-only, with the context pulled back into the line.
+ *   new PrettyDevDestination({
+ *     view: { hideObject: true, messageFormat: '[{context}] {msg}' }
  *   })
  */
 declare class PrettyDevDestination implements ILogDestination {
     readonly name = "pretty-dev";
     readonly minLevel?: LogLevel;
+    /** Consumer-chosen view, merged over {@link DEFAULT_VIEW} at init. */
+    private readonly view;
     /**
      * The `pino-pretty` transform stream. Undefined until {@link onInit} succeeds.
      */
@@ -893,16 +969,42 @@ declare class PrettyDevDestination implements ILogDestination {
     /**
      * Set when {@link onInit} fails (e.g. `pino-pretty` absent). Distinguishes a
      * permanently-failed destination — whose writes are DROPPED, since the registry
-     * dropped it from the active set — from the transient pre-init window, where
-     * {@link write} falls back to raw stdout so a bootstrap log is not lost.
+     * dropped it from the active set — from the transient pre-init window.
      */
     private initFailed;
+    /**
+     * Entries written before {@link onInit} built the transform, held so they can be
+     * RENDERED rather than printed raw.
+     *
+     * The transform cannot exist earlier: loading the optional peer is async, and
+     * `onInit` is the first moment the lifecycle offers. Before this buffer those
+     * entries went to stdout as raw NDJSON — correct, nothing lost, but a real boot
+     * put dozens of JSON lines on screen before the first rendered one, and a
+     * developer who had just turned pretty on reasonably concluded it had not
+     * worked. Reported from exactly that reading.
+     */
+    private buffer;
+    /**
+     * Set once {@link MAX_BUFFERED_ENTRIES} is reached. From then on entries go
+     * straight to raw stdout — and the buffer is drained raw at the same moment, so
+     * the output stays in ORDER rather than replaying old entries after newer ones.
+     */
+    private bufferOverflowed;
+    /**
+     * UTF-8 size of everything currently held, tracked incrementally so the bound
+     * costs one `Buffer.byteLength` per entry rather than a walk of the buffer.
+     */
+    private bufferedBytes;
     /**
      * @param opts.minLevel — Optional minimum level filter applied by the
      *   destination registry's multi-stream wiring. Omit to accept every level.
+     * @param opts.view — Optional rendering overrides; see {@link PrettyViewOptions}.
+     *   Omitted fields keep their default, so `new PrettyDevDestination()` renders
+     *   exactly as it did before this option existed.
      */
     constructor(opts?: {
         minLevel?: LogLevel;
+        view?: PrettyViewOptions;
     });
     /**
      * Lazily resolve `pino-pretty` and build the colorized transform that renders
@@ -921,12 +1023,24 @@ declare class PrettyDevDestination implements ILogDestination {
      *     fan-out already skips a failed destination before reaching this method
      *     (and rescues the entry when nothing else initialized); this branch is the
      *     belt to that, for any caller holding the destination directly;
-     *   - pre-init (transient window before {@link onInit}, e.g. a bootstrap log)
-     *     → fall back to raw stdout so the entry is not lost.
+     *   - pre-init (transient window before {@link onInit}, e.g. every entry NestJS
+     *     emits while instantiating providers) → BUFFERED, then rendered through
+     *     the transform once it exists. Nothing is lost on any path: if init fails
+     *     the buffer is drained raw, and if it overflows it is drained raw in order.
      *
      * @param payload — Newline-terminated JSON entry, UTF-8 encoded.
      */
     write(payload: string): void;
+    /**
+     * Hand every buffered entry to `emit`, in arrival order, and empty the buffer.
+     *
+     * Emptying unconditionally is what makes this safe to call from both the
+     * success and failure paths: whichever runs first owns the entries, and the
+     * other finds nothing to emit twice.
+     *
+     * @param emit - Receives each buffered payload, oldest first.
+     */
+    private flushBuffer;
     /**
      * Flush and close the pretty transform, resolving once the stream has ended.
      * A no-op when {@link onInit} never ran.
@@ -1382,4 +1496,4 @@ interface LogEntry {
  */
 declare const LOG_KEYS_CONVENTION_REGEX: RegExp;
 
-export { BymaxLoggerModule, type BymaxLoggerModuleAsyncOptions, type BymaxLoggerModuleOptions, type BymaxLoggerModuleOptionsFactory, DEFAULT_REDACT_PATHS, DefaultStdoutDestination, type EmittedDeploymentResource, type EmittedServiceResource, HttpExceptionFilter, HttpLoggingInterceptor, type HttpOptions, type ILogDestination, type IncomingHeaders, InjectLogger, LOGGER_DESTINATIONS_TOKEN, LOGGER_OPTIONS_TOKEN, LOGGER_PINO_INSTANCE_TOKEN, LOG_CONTEXT_METADATA_KEY, LOG_CONTEXT_TOKEN, LOG_KEYS_CONVENTION_REGEX, LogContext, type LogContext$1 as LogContextBag, LogContextService, type LogEntry, type LogLevel, LogPerformance, type LoggableRequest, type LoggableResponse, type NextHandler, type OtelOptions, PINO_LEVEL_NAMES, PINO_LEVEL_NUMBERS, PinoLoggerService, PrettyDevDestination, RESERVED_LOG_KEYS, RESERVED_LOG_KEYS_NOT_EMITTED, RequestIdMiddleware, type ReservedLogKey, type ResolvedBymaxLoggerModuleOptions, type ResolvedServiceMetadata, type ServiceMetadata, applyRequestIdMiddleware };
+export { BymaxLoggerModule, type BymaxLoggerModuleAsyncOptions, type BymaxLoggerModuleOptions, type BymaxLoggerModuleOptionsFactory, DEFAULT_REDACT_PATHS, DefaultStdoutDestination, type EmittedDeploymentResource, type EmittedServiceResource, HttpExceptionFilter, HttpLoggingInterceptor, type HttpOptions, type ILogDestination, type IncomingHeaders, InjectLogger, LOGGER_DESTINATIONS_TOKEN, LOGGER_OPTIONS_TOKEN, LOGGER_PINO_INSTANCE_TOKEN, LOG_CONTEXT_METADATA_KEY, LOG_CONTEXT_TOKEN, LOG_KEYS_CONVENTION_REGEX, LogContext, type LogContext$1 as LogContextBag, LogContextService, type LogEntry, type LogLevel, LogPerformance, type LoggableRequest, type LoggableResponse, type NextHandler, type OtelOptions, PINO_LEVEL_NAMES, PINO_LEVEL_NUMBERS, PinoLoggerService, PrettyDevDestination, type PrettyViewOptions, RESERVED_LOG_KEYS, RESERVED_LOG_KEYS_NOT_EMITTED, RequestIdMiddleware, type ReservedLogKey, type ResolvedBymaxLoggerModuleOptions, type ResolvedServiceMetadata, type ServiceMetadata, applyRequestIdMiddleware };

package/dist/server/index.mjs

@@ -225,6 +225,75 @@ function escapeControlCharacters(text) {
   return text.replace(UNSAFE_IN_MULTILINE, toEscapeSequence);
 }
 
+// src/server/utils/sanitize-error.util.ts
+var DEFAULT_MAX_CAUSE_DEPTH = 3;
+var MAX_AGGREGATE_ERRORS = 10;
+var CIRCULAR_SENTINEL = "[Circular]";
+function sanitizeError(err, options) {
+  const maxCauseDepth = DEFAULT_MAX_CAUSE_DEPTH;
+  return toSanitizedError(err, /* @__PURE__ */ new WeakSet(), 0, maxCauseDepth);
+}
+function isErrorLike(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.name === "string" && typeof candidate.message === "string";
+}
+function toSanitizedError(value, seen, depth2, maxDepth) {
+  try {
+    if (!isErrorLike(value)) {
+      return { name: "UnknownError", message: String(value) };
+    }
+    seen.add(value);
+    const result = { name: value.name, message: value.message };
+    if (value.stack !== void 0) {
+      result.stack = scrubStack(value.stack);
+    }
+    const isAtDepthLimit = depth2 >= maxDepth;
+    if (value.cause !== void 0) {
+      result.cause = isAtDepthLimit ? createDepthMarker() : toSanitizedChild(value.cause, seen, depth2 + 1, maxDepth);
+    }
+    const aggregated = readAggregatedErrors(value);
+    if (aggregated !== void 0) {
+      const capped = aggregated.slice(0, MAX_AGGREGATE_ERRORS);
+      result.errors = capped.map(
+        (inner) => isAtDepthLimit ? createDepthMarker() : toSanitizedChild(inner, seen, depth2 + 1, maxDepth)
+      );
+      if (aggregated.length > MAX_AGGREGATE_ERRORS) {
+        result.errors.push(createWidthMarker(aggregated.length - MAX_AGGREGATE_ERRORS));
+      }
+    }
+    return result;
+  } catch {
+    return { name: "SanitizeFailed", message: "Failed to sanitize the thrown value" };
+  }
+}
+function toSanitizedChild(value, seen, depth2, maxDepth) {
+  if (isObject(value) && seen.has(value)) {
+    return CIRCULAR_SENTINEL;
+  }
+  return toSanitizedError(value, seen, depth2, maxDepth);
+}
+function readAggregatedErrors(value) {
+  const candidate = value.errors;
+  return Array.isArray(candidate) ? candidate : void 0;
+}
+function scrubStack(stack) {
+  return escapeControlCharacters(
+    stack.split("\n").filter((line) => !line.includes("node_modules")).join("\n")
+  );
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function createDepthMarker() {
+  return { _truncated: true, _reason: "cause-depth-exceeded" };
+}
+function createWidthMarker(omitted) {
+  return { _truncated: true, _reason: "aggregate-width-exceeded", _omitted: omitted };
+}
+
 // src/server/services/pino-logger.service.ts
 var OWNED_PAYLOAD_KEYS = ["logKey", "userId", "context"];
 function withoutOwnedKeys(metadata) {
@@ -253,6 +322,9 @@ function safeErrorMessage(error) {
     return "Unreadable error message";
   }
 }
+function findErrorParam(optionalParams) {
+  return optionalParams.find((param) => isErrorLike(param));
+}
 function assignIfDefined(payload, key, value) {
   if (value !== void 0) {
     Reflect.defineProperty(payload, key, { value, enumerable: true });
@@ -289,7 +361,7 @@ var PinoLoggerService = class {
    * @param optionalParams - NestJS trailing params (`stack` at index 0, `context` at index 1).
    */
   error(message, ...optionalParams) {
-    if (message instanceof Error) {
+    if (isErrorLike(message)) {
       const payload2 = { err: message };
       assignIfDefined(payload2, "context", this.resolveContext(optionalParams));
       this.pino.error(payload2, safeErrorMessage(message));
@@ -300,6 +372,7 @@ var PinoLoggerService = class {
     const payload = {};
     assignIfDefined(payload, "context", context);
     assignIfDefined(payload, "stack", stack);
+    assignIfDefined(payload, "err", findErrorParam(optionalParams));
     this.pino.error(
       payload,
       toSingleLineMessage(typeof message === "string" ? message : String(message))
@@ -458,7 +531,9 @@ var PinoLoggerService = class {
   emitNestStyle(level, message, optionalParams) {
     const payload = {};
     assignIfDefined(payload, "context", this.resolveContext(optionalParams));
-    const msg = toSingleLineMessage(typeof message === "string" ? message : String(message));
+    const leading = isErrorLike(message) ? message : void 0;
+    assignIfDefined(payload, "err", leading ?? findErrorParam(optionalParams));
+    const msg = leading === void 0 ? toSingleLineMessage(typeof message === "string" ? message : String(message)) : safeErrorMessage(leading);
     switch (level) {
       case "info":
         this.pino.info(payload, msg);
@@ -508,6 +583,30 @@ function collectContextLoggerProviders() {
 function collectContextLoggerTokens() {
   return Array.from(contextTokens.values());
 }
+
+// src/server/utils/safe-stdio.util.ts
+var swallowStreamError = () => void 0;
+function ensureGuarded(stream) {
+  if (stream.listeners("error").includes(swallowStreamError)) {
+    return;
+  }
+  stream.on("error", swallowStreamError);
+}
+function writeSafely(stream, payload) {
+  try {
+    ensureGuarded(stream);
+    stream.write(payload);
+  } catch {
+  }
+}
+function writeStdoutSafely(payload) {
+  writeSafely(process.stdout, payload);
+}
+function writeStderrSafely(line) {
+  writeSafely(process.stderr, line);
+}
+
+// src/server/destinations/default-stdout.destination.ts
 var DefaultStdoutDestination = class {
   /**
    * @param opts.minLevel — Optional minimum level filter. Entries below this
@@ -522,9 +621,17 @@ var DefaultStdoutDestination = class {
   }
   /**
    * Write a serialized JSON log entry (terminated with `\n`) to `stdout`.
+   *
+   * Routed through {@link writeStdoutSafely} rather than calling
+   * `process.stdout.write` directly. This is the sink a consumer gets when they
+   * configure nothing, so it is the path that decides whether a closed pipe
+   * (`node app | head`) kills the application — and unguarded, it did: EPIPE
+   * arrives asynchronously through the stream's `'error'` event, Node attaches no
+   * default handler, and the emit becomes an uncaught exception. Measured on the
+   * built artifact, exit code 42.
    */
   write(payload) {
-    process.stdout.write(payload);
+    writeStdoutSafely(payload);
   }
 };
 DefaultStdoutDestination = __decorateClass([
@@ -545,75 +652,6 @@ function stripQueryString(url) {
   return queryStart === -1 ? url : url.slice(0, queryStart);
 }
 
-// src/server/utils/sanitize-error.util.ts
-var DEFAULT_MAX_CAUSE_DEPTH = 3;
-var MAX_AGGREGATE_ERRORS = 10;
-var CIRCULAR_SENTINEL = "[Circular]";
-function sanitizeError(err, options) {
-  const maxCauseDepth = DEFAULT_MAX_CAUSE_DEPTH;
-  return toSanitizedError(err, /* @__PURE__ */ new WeakSet(), 0, maxCauseDepth);
-}
-function isErrorLike(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.name === "string" && typeof candidate.message === "string";
-}
-function toSanitizedError(value, seen, depth2, maxDepth) {
-  try {
-    if (!isErrorLike(value)) {
-      return { name: "UnknownError", message: String(value) };
-    }
-    seen.add(value);
-    const result = { name: value.name, message: value.message };
-    if (value.stack !== void 0) {
-      result.stack = scrubStack(value.stack);
-    }
-    const isAtDepthLimit = depth2 >= maxDepth;
-    if (value.cause !== void 0) {
-      result.cause = isAtDepthLimit ? createDepthMarker() : toSanitizedChild(value.cause, seen, depth2 + 1, maxDepth);
-    }
-    const aggregated = readAggregatedErrors(value);
-    if (aggregated !== void 0) {
-      const capped = aggregated.slice(0, MAX_AGGREGATE_ERRORS);
-      result.errors = capped.map(
-        (inner) => isAtDepthLimit ? createDepthMarker() : toSanitizedChild(inner, seen, depth2 + 1, maxDepth)
-      );
-      if (aggregated.length > MAX_AGGREGATE_ERRORS) {
-        result.errors.push(createWidthMarker(aggregated.length - MAX_AGGREGATE_ERRORS));
-      }
-    }
-    return result;
-  } catch {
-    return { name: "SanitizeFailed", message: "Failed to sanitize the thrown value" };
-  }
-}
-function toSanitizedChild(value, seen, depth2, maxDepth) {
-  if (isObject(value) && seen.has(value)) {
-    return CIRCULAR_SENTINEL;
-  }
-  return toSanitizedError(value, seen, depth2, maxDepth);
-}
-function readAggregatedErrors(value) {
-  const candidate = value.errors;
-  return Array.isArray(candidate) ? candidate : void 0;
-}
-function scrubStack(stack) {
-  return escapeControlCharacters(
-    stack.split("\n").filter((line) => !line.includes("node_modules")).join("\n")
-  );
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function createDepthMarker() {
-  return { _truncated: true, _reason: "cause-depth-exceeded" };
-}
-function createWidthMarker(omitted) {
-  return { _truncated: true, _reason: "aggregate-width-exceeded", _omitted: omitted };
-}
-
 // src/server/filters/http-exception.filter.ts
 var INTERNAL_ERROR_BODY = {
   statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
@@ -1025,7 +1063,7 @@ function reportDestinationFailure(logKey, name, cause, msg) {
       type: toSingleLineMessage(String(cause.name)),
       message: toSingleLineMessage(String(cause.message))
     } : { type: "UnknownError", message: toSingleLineMessage(String(cause)) };
-    process.stderr.write(
+    writeStderrSafely(
       JSON.stringify({
         level: "error",
         logKey,
@@ -1048,10 +1086,7 @@ function reportWriteFailure(name, cause) {
   );
 }
 function rescueToStdout(payload) {
-  try {
-    process.stdout.write(payload);
-  } catch {
-  }
+  writeStdoutSafely(payload);
 }
 function destinationToStream(destination, health) {
   return new Writable({
@@ -1748,7 +1783,7 @@ var DestinationRegistry = class {
         await destination.onShutdown?.();
       } catch (cause) {
         const detail = cause instanceof Error ? cause.stack ?? cause.message : String(cause);
-        process.stderr.write(
+        writeStderrSafely(
           `[DestinationRegistry] Shutdown failed for "${destination.name}": ${detail}
 `
         );
@@ -2028,23 +2063,60 @@ BymaxLoggerModule = __decorateClass([
 ], BymaxLoggerModule);
 
 // src/server/destinations/pretty-dev.destination.ts
+var DEFAULT_VIEW = {
+  colorize: true,
+  translateTime: "SYS:HH:MM:ss.l",
+  ignore: "pid,hostname,service",
+  singleLine: false
+};
+var MAX_BUFFERED_ENTRIES = 1e3;
+var MAX_BUFFERED_BYTES = 4 * 1024 * 1024;
+function writeRawToStdout(payload) {
+  writeStdoutSafely(payload);
+}
 var PrettyDevDestination = class {
   /**
    * @param opts.minLevel — Optional minimum level filter applied by the
    *   destination registry's multi-stream wiring. Omit to accept every level.
+   * @param opts.view — Optional rendering overrides; see {@link PrettyViewOptions}.
+   *   Omitted fields keep their default, so `new PrettyDevDestination()` renders
+   *   exactly as it did before this option existed.
    */
   constructor(opts = {}) {
     this.name = "pretty-dev";
     /**
      * Set when {@link onInit} fails (e.g. `pino-pretty` absent). Distinguishes a
      * permanently-failed destination — whose writes are DROPPED, since the registry
-     * dropped it from the active set — from the transient pre-init window, where
-     * {@link write} falls back to raw stdout so a bootstrap log is not lost.
+     * dropped it from the active set — from the transient pre-init window.
      */
     this.initFailed = false;
+    /**
+     * Entries written before {@link onInit} built the transform, held so they can be
+     * RENDERED rather than printed raw.
+     *
+     * The transform cannot exist earlier: loading the optional peer is async, and
+     * `onInit` is the first moment the lifecycle offers. Before this buffer those
+     * entries went to stdout as raw NDJSON — correct, nothing lost, but a real boot
+     * put dozens of JSON lines on screen before the first rendered one, and a
+     * developer who had just turned pretty on reasonably concluded it had not
+     * worked. Reported from exactly that reading.
+     */
+    this.buffer = [];
+    /**
+     * Set once {@link MAX_BUFFERED_ENTRIES} is reached. From then on entries go
+     * straight to raw stdout — and the buffer is drained raw at the same moment, so
+     * the output stays in ORDER rather than replaying old entries after newer ones.
+     */
+    this.bufferOverflowed = false;
+    /**
+     * UTF-8 size of everything currently held, tracked incrementally so the bound
+     * costs one `Buffer.byteLength` per entry rather than a walk of the buffer.
+     */
+    this.bufferedBytes = 0;
     if (opts.minLevel !== void 0) {
       this.minLevel = opts.minLevel;
     }
+    this.view = opts.view ?? {};
   }
   /**
    * Lazily resolve `pino-pretty` and build the colorized transform that renders
@@ -2057,18 +2129,31 @@ var PrettyDevDestination = class {
     try {
       const { build } = await import('pino-pretty');
       this.stream = build({
-        colorize: true,
-        translateTime: "SYS:HH:MM:ss.l",
-        ignore: "pid,hostname,service",
-        singleLine: false,
+        ...DEFAULT_VIEW,
+        ...this.view,
+        // AFTER the consumer's view, deliberately. Omitting `destination` from
+        // `PrettyViewOptions` states that the library owns the sink; applying it
+        // last is what ENFORCES it, including against an untyped caller reaching
+        // in from JavaScript. A redirected stream would route around the fan-out
+        // and the last-resort rescue.
         destination: process.stdout
       });
     } catch {
       this.initFailed = true;
+      this.flushBuffer((payload) => {
+        writeRawToStdout(payload);
+      });
       throw new Error(
         "[PrettyDevDestination] pino-pretty is not installed. Install it as a peer dependency (`pnpm add -D pino-pretty`) or remove PrettyDevDestination from `destinations`."
       );
     }
+    this.flushBuffer((payload) => {
+      try {
+        this.stream?.write(payload);
+      } catch {
+        writeRawToStdout(payload);
+      }
+    });
   }
   /**
    * Write a serialized NDJSON entry to the pretty transform.
@@ -2079,8 +2164,10 @@ var PrettyDevDestination = class {
    *     fan-out already skips a failed destination before reaching this method
    *     (and rescues the entry when nothing else initialized); this branch is the
    *     belt to that, for any caller holding the destination directly;
-   *   - pre-init (transient window before {@link onInit}, e.g. a bootstrap log)
-   *     → fall back to raw stdout so the entry is not lost.
+   *   - pre-init (transient window before {@link onInit}, e.g. every entry NestJS
+   *     emits while instantiating providers) → BUFFERED, then rendered through
+   *     the transform once it exists. Nothing is lost on any path: if init fails
+   *     the buffer is drained raw, and if it overflows it is drained raw in order.
    *
    * @param payload — Newline-terminated JSON entry, UTF-8 encoded.
    */
@@ -2092,7 +2179,36 @@ var PrettyDevDestination = class {
     if (this.initFailed) {
       return;
     }
-    process.stdout.write(payload);
+    if (this.bufferOverflowed) {
+      writeRawToStdout(payload);
+      return;
+    }
+    const payloadBytes = Buffer.byteLength(payload, "utf8");
+    if (this.buffer.length >= MAX_BUFFERED_ENTRIES || this.bufferedBytes + payloadBytes > MAX_BUFFERED_BYTES) {
+      this.bufferOverflowed = true;
+      this.flushBuffer(writeRawToStdout);
+      writeRawToStdout(payload);
+      return;
+    }
+    this.buffer.push(payload);
+    this.bufferedBytes += payloadBytes;
+  }
+  /**
+   * Hand every buffered entry to `emit`, in arrival order, and empty the buffer.
+   *
+   * Emptying unconditionally is what makes this safe to call from both the
+   * success and failure paths: whichever runs first owns the entries, and the
+   * other finds nothing to emit twice.
+   *
+   * @param emit - Receives each buffered payload, oldest first.
+   */
+  flushBuffer(emit) {
+    const held = this.buffer;
+    this.buffer = [];
+    this.bufferedBytes = 0;
+    for (const payload of held) {
+      emit(payload);
+    }
   }
   /**
    * Flush and close the pretty transform, resolving once the stream has ended.
@@ -2101,6 +2217,7 @@ var PrettyDevDestination = class {
   async onShutdown() {
     const stream = this.stream;
     if (stream === void 0) {
+      this.flushBuffer(writeRawToStdout);
       return;
     }
     await new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bymax-one/nest-logger",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "Structured JSON logging for NestJS based on Pino 10, with optional OpenTelemetry correlation.",
   "author": "Bymax One <support@bymax.one>",
   "license": "MIT",