@bymax-one/nest-logger 1.2.3 → 1.2.5

package/CHANGELOG.md

@@ -11,8 +11,154 @@ heading here.
 
 ## [Unreleased]
 
+## [1.2.5] - 2026-08-14
+
+### Fixed
+
+- **An `Error` handed to the NestJS logger methods is no longer silently dropped.** Reported from a
+  real run rather than a unit test. `@bymax-one/nest-auth` logs the cause the way every caller does,
+  an SMTP `STARTTLS 502` failed, and this is what came out:
+
+  ```js
+  // the call site, nest-auth
+  this.logger.error(`delivery failed for "${subject}"`, error)
+  ```
+
+  ```json
+  {
+    "level": "error",
+    "context": "DefaultAuthEmailProvider",
+    "msg": "delivery failed for \"Verify your email address\""
+  }
+  ```
+
+  No `err`, no `stack`, no warning. The cause existed the whole time and was discarded. The dispatch
+  is fire-and-forget, so the HTTP response was `204` while nothing had been delivered: **the log was
+  the only surface where that failure could appear, and it appeared without its reason.** In CI you
+  can raise the level and re-run; in production nobody runs at `debug`, so the reason was never
+  written at all.
+
+  Neither side was obviously wrong, which is what made it survive. NestJS types the slot as
+  `error(message, stack?: string, context?: string)`, so this library read a string and discarded
+  anything else — implementing the contract faithfully. Passing the `Error` itself is what callers
+  actually do, because every other logger in the ecosystem accepts it.
+
+  **Measured before the fix: eleven of the twelve level/position combinations lost the `Error`.**
+  Only `error(err)` survived — every other level (`log`, `warn`, `debug`, `verbose`, `fatal`) routes
+  through a shared helper that handled no `Error` in either position. `fatal` was the worst of them,
+  being the level a caller reaches for when the process is about to die.
+
+  An `Error` anywhere in the variadic tail is now attached as `err`, the same field the leading-`Error`
+  branch already wrote, at every level. A trailing _string_ is still the `stack`, and `stack` is never
+  populated from an `Error` — the `err` serializer derives it, so writing both would emit the same
+  trace under two names.
+
+  **Detection is structural, not `instanceof`.** The first version of this fix used
+  `instanceof Error`, which is realm-local — so it would still have dropped a genuine `Error` built in
+  a `vm` context, and one already normalized into a plain `{ name, message, stack }`, which is what
+  `HttpExceptionFilter` produces and what any error crossing a process or worker boundary becomes.
+  That is the population most likely to be carrying the reason something failed, and this repository
+  had already recorded the same lesson in `sanitizeError` ("too narrow, and the gap was a live
+  defect"). The bridge now shares `isErrorLike` with `sanitizeError`, so the two cannot disagree about
+  what an error is. The bar stays deliberately narrow — string `name` AND string `message` — so an
+  ordinary metadata object is not mistaken for a cause.
+
+  **Two output changes to expect, since "additive" would overstate it.** Nothing is removed or
+  renamed, and a caller passing a string stack is untouched. But a caller who was passing an `Error`
+  necessarily sees a difference, because that is the defect:
+
+  - entries that silently dropped a cause now carry an `err` object — a **new field** on lines that
+    previously had none, which a strict log-pipeline schema will see;
+  - `warn(new Error('x'))` and the other non-`error` levels now emit `msg: "x"` instead of
+    `msg: "Error: x"`, matching what `error(new Error('x'))` already produced. A query grepping for
+    the `"Error: "` prefix on those levels will stop matching.
+
+  Both are the point of the change rather than side effects, but neither is invisible.
+
+  Scope, as measured by the reporting consumer across the ten `@bymax-one/*` packages that backend
+  installs at its pinned versions: **37 affected call sites, all of them in `nest-auth`**, none
+  elsewhere. Two are security-relevant — a breach check that fails open and logs that it admitted a
+  password it could not verify, and the `onRefreshTokenReuseDetected` hook, the tripwire for a stolen
+  token. Both said something went wrong and threw away what.
+
+### Documentation
+
+- **The `pnpm prune --prod` note named the wrong mechanism.** It described the peer surviving as a
+  _residue_ of an incomplete prune. A second consumer whose Dockerfile never prunes — a clean
+  `pnpm install --prod --frozen-lockfile` in a fresh runtime stage — measured the peer present anyway.
+  In both images the peer was recorded in the lockfile and pnpm placed it in the store for a
+  production-only install. The distinction matters because "we do a clean prod install, not a prune"
+  reads like an exemption and is not one; it is what that consumer expected before measuring their
+  own image.
+
+  The note is now phrased as **two measurements rather than a law of pnpm** — whether a prod install
+  always carries an optional peer, however the lockfile was produced, has not been tested here. The
+  first version of this note over-generalized from the evidence, which is the same class of error as
+  the two corrections it documents.
+
+  The note now also says what is different **elsewhere**: under npm's or yarn's flat `node_modules` a
+  pruned devDependency really is gone, so the warning must not be read as universal. And it records
+  the probe that nearly produced the opposite conclusion — `require.resolve` from the library's
+  app-visible path returns `MODULE_NOT_FOUND` while the lazy import still succeeds, because the
+  library resolves from its real `.pnpm/` path. Verify by behaviour, not from a path the library
+  never uses.
+
+## [1.2.4] - 2026-08-14
+
+### Documentation
+
+- **The `1.2.3` notes below were amended after release: they were missing a `### Security` section.**
+  The terminal-escaping hardening described there shipped **in 1.2.3** — `toSingleLineMessage` is in
+  that bundle — but the release notes did not mention it, so a reader auditing the CHANGELOG for
+  security-relevant changes would have missed it. Found by a consumer reading the bundle diff rather
+  than the notes. The section was added to `[1.2.3]` where it belongs chronologically, and this entry
+  exists so anyone who already read those notes learns they changed. No code moved; the amendment is
+  the correction.
+
+- **An optional peer dependency is NOT absent from a pruned production install.** Two consumers
+  independently reasoned that because `pino-pretty` is a `devDependency`, `pnpm prune --prod` strips
+  it and `PrettyDevDestination` therefore cannot run in production. That is false under pnpm, and one
+  of them disproved it inside a real production image: `prune --prod` removes the **top-level link**
+  while the package stays in the store, linked beside this library as the resolved optional peer, so
+  the lazy `import('pino-pretty')` inside `onInit` resolves relative to the library's own directory
+  and succeeds.
+
+  The practical consequence is documented in the README and the destinations guideline: do not treat
+  "it is a devDependency" as proof that a code path is unreachable in production. A `PrettyDevDestination`
+  left registered in a production deployment will not crash and will not warn — it will render ANSI
+  colour into a log pipeline that has silently failed to parse every line since the deploy.
+
+### Tests
+
+- **The rescue path now asserts the audit signal it was written to protect.** The end-to-end case for
+  the total-init-failure fallback names `LOGGER_BOOTSTRAP_WARNING` — the signal that exists so a
+  security review can see PII redaction was disabled — as its justification, then asserted
+  `LOGGER_BOOTSTRAP_OK` instead. The guarantee was covered transitively (same path, and `warn` clears
+  any filter `info` clears), but the test did not pin the promise it cited, so it could have been
+  weakened without anyone noticing what was surrendered. A dedicated case now boots with
+  `shouldDisableDefaultRedact: true` and asserts the warning survives the rescue, with its flag and
+  level. Verified to fail when the rescuer election is moved after `announceBootstrap()`.
+
 ## [1.2.3] - 2026-08-14
 
+### Security
+
+- **Control characters in a destination failure report are escaped before reaching a terminal.**
+  The `LOGGER_DESTINATION_INIT_FAILED` and `LOGGER_DESTINATION_WRITE_FAILED` lines are written
+  straight to `process.stderr` and read by a human in a terminal, and `JSON.stringify` escapes C0 and
+  nothing else — DEL, the C1 range (U+0085 NEL included), U+2028 and U+2029 survive verbatim, which is
+  enough to drive a terminal or forge what looks like a separate log entry. The destination `name` is
+  consumer-chosen and the failure text is frequently remote-derived, so both are attacker-influenced
+  surfaces. `destination`, `err.type`, `err.message` and `msg` now pass through `toSingleLineMessage`,
+  the same per-sink escaping the rest of the library applies.
+
+- **A rejected value that throws while being coerced can no longer abort application bootstrap.**
+  The failure reporter normalized the thrown value _outside_ its own guard, so `String(cause)` on a
+  value with a throwing `toString`/`Symbol.toPrimitive` — or the `name`/`message` reads on an `Error`
+  with hostile getters — escaped the reporter. It runs inside the registry catch that exists to keep a
+  bad sink from mattering, so the escape aborted boot: the failure handler became a harder failure
+  than the one it was handling. Coercion now happens inside the guard.
+
 ### Fixed
 
 - **A destination that fails to initialize no longer silences the entire application.** Reported
@@ -868,7 +1014,9 @@ published `dist/` is identical — no runtime behaviour changes for consumers.
 - Professional CI suite: `ci.yml`, `bench.yml`, `codeql.yml`, `scorecard.yml`,
   `release.yml`, Dependabot, and issue templates
 
-[Unreleased]: https://github.com/bymaxone/nest-logger/compare/v1.2.3...HEAD
+[Unreleased]: https://github.com/bymaxone/nest-logger/compare/v1.2.5...HEAD
+[1.2.5]: https://github.com/bymaxone/nest-logger/compare/v1.2.4...v1.2.5
+[1.2.4]: https://github.com/bymaxone/nest-logger/compare/v1.2.3...v1.2.4
 [1.2.3]: https://github.com/bymaxone/nest-logger/compare/v1.2.2...v1.2.3
 [1.2.2]: https://github.com/bymaxone/nest-logger/compare/v1.2.1...v1.2.2
 [1.2.1]: https://github.com/bymaxone/nest-logger/compare/v1.2.0...v1.2.1

package/README.md

@@ -149,6 +149,32 @@ pnpm add @opentelemetry/api @opentelemetry/sdk-node
 
 ```
 
+> ⚠️ **Under pnpm, `-D` may not make it absent in production — measure, do not assume.** Two
+> consumers who had assumed otherwise measured the peer **present** in their real production images,
+> by two different build routes: `pnpm prune --prod` keeps the store entry, and a clean
+> `pnpm install --prod --frozen-lockfile` in a fresh stage installs it too. In both, the peer was
+> recorded in the lockfile. `PrettyDevDestination` imports it lazily, relative to the library's own
+> directory under `.pnpm/`, where it is a sibling — so it resolves.
+>
+> That is two measurements, not a law of pnpm: whether a production install always carries an optional
+> peer, however the lockfile was produced, has not been tested here. The advice below does not depend
+> on it.
+>
+> The clean-install case is worth stating separately, because "we do a fresh prod install, not a
+> prune" reads like an exemption and is not one. It is what one of those consumers concluded before
+> measuring their own image.
+>
+> **On other package managers this is different**, and the difference cuts the other way: under npm's
+> or yarn's flat `node_modules`, a pruned devDependency really is gone. If you install with those,
+> do not read this warning as universal.
+>
+> Either way, the rule that survives both layouts: **"it is a devDependency, therefore this path
+> cannot run in production" is not a safe premise, because the premise is about someone else's
+> install command.** A `PrettyDevDestination` left registered in production will not crash and will
+> not warn — it renders ANSI colour into a log pipeline that has silently failed to parse every line
+> since the deploy, which is indistinguishable from a service that went quiet. Gate it on an explicit
+> configuration value you can see, not on the packaging.
+
 > [!NOTE]
 > `@opentelemetry/api` is resolved lazily when the Pino instance is built. When it is absent the trace mixin silently steps aside — the logger never fails to start, and never warns, over an optional peer.
 

package/dist/server/index.cjs

@@ -228,6 +228,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) {
@@ -256,6 +325,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 });
@@ -292,7 +364,7 @@ exports.PinoLoggerService = class PinoLoggerService {
    * @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));
@@ -303,6 +375,7 @@ exports.PinoLoggerService = class PinoLoggerService {
     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))
@@ -461,7 +534,9 @@ exports.PinoLoggerService = class PinoLoggerService {
   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);
@@ -548,75 +623,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: common.HttpStatus.INTERNAL_SERVER_ERROR,

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);
@@ -545,75 +620,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,

package/package.json

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