@bymax-one/nest-logger 1.2.5 → 1.2.7

package/dist/server/index.cjs

@@ -232,6 +232,13 @@ function escapeControlCharacters(text) {
 var DEFAULT_MAX_CAUSE_DEPTH = 3;
 var MAX_AGGREGATE_ERRORS = 10;
 var CIRCULAR_SENTINEL = "[Circular]";
+var DERIVED_ERROR_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "message",
+  "stack",
+  "cause",
+  "errors"
+]);
 function sanitizeError(err, options) {
   const maxCauseDepth = DEFAULT_MAX_CAUSE_DEPTH;
   return toSanitizedError(err, /* @__PURE__ */ new WeakSet(), 0, maxCauseDepth);
@@ -267,11 +274,23 @@ function toSanitizedError(value, seen, depth2, maxDepth) {
         result.errors.push(createWidthMarker(aggregated.length - MAX_AGGREGATE_ERRORS));
       }
     }
+    assignOwnErrorFields(result, value);
     return result;
   } catch {
     return { name: "SanitizeFailed", message: "Failed to sanitize the thrown value" };
   }
 }
+function assignOwnErrorFields(target, source) {
+  try {
+    const own = Array.isArray(source) ? {} : source;
+    for (const [key, value] of Object.entries(own)) {
+      if (!Object.hasOwn(target, key) && !DERIVED_ERROR_FIELDS.has(key)) {
+        Object.defineProperty(target, key, { value, enumerable: true });
+      }
+    }
+  } catch {
+  }
+}
 function toSanitizedChild(value, seen, depth2, maxDepth) {
   if (isObject(value) && seen.has(value)) {
     return CIRCULAR_SENTINEL;
@@ -586,6 +605,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
 exports.DefaultStdoutDestination = class DefaultStdoutDestination {
   /**
    * @param opts.minLevel — Optional minimum level filter. Entries below this
@@ -600,9 +643,17 @@ exports.DefaultStdoutDestination = class DefaultStdoutDestination {
   }
   /**
    * 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);
   }
 };
 exports.DefaultStdoutDestination = __decorateClass([
@@ -1034,7 +1085,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,
@@ -1057,10 +1108,7 @@ function reportWriteFailure(name, cause) {
   );
 }
 function rescueToStdout(payload) {
-  try {
-    process.stdout.write(payload);
-  } catch {
-  }
+  writeStdoutSafely(payload);
 }
 function destinationToStream(destination, health) {
   return new stream.Writable({
@@ -1372,13 +1420,6 @@ function leafNameOf(path) {
   }
   return leaf;
 }
-var DERIVED_ERROR_FIELDS = /* @__PURE__ */ new Set([
-  "name",
-  "message",
-  "stack",
-  "cause",
-  "errors"
-]);
 function serializeErrorValue(value_) {
   const sanitized = sanitizeError(value_);
   const serialized = {
@@ -1395,18 +1436,7 @@ function serializeErrorValue(value_) {
   if (sanitized.errors !== void 0) {
     serialized["errors"] = sanitized.errors;
   }
-  try {
-    const source = (
-      // Stryker disable next-line ConditionalExpression: equivalent BY CONSTRUCTION, not untested — the never-throw catch below makes the mutant observationally identical: with the null check flipped to true, `Object.entries(null)` throws, the catch swallows it, and the emitted envelope is byte-for-byte the same. The guard stays because routing the ordinary null case through exception control flow would trade an explicit branch for a hidden one.
-      typeof value_ === "object" && value_ !== null && !Array.isArray(value_) ? value_ : {}
-    );
-    for (const [key, value] of Object.entries(source)) {
-      if (!Object.hasOwn(serialized, key) && !DERIVED_ERROR_FIELDS.has(key)) {
-        Reflect.set(serialized, key, value);
-      }
-    }
-  } catch {
-  }
+  assignOwnErrorFields(serialized, sanitized);
   return serialized;
 }
 function withSemconvException(record, format) {
@@ -1456,6 +1486,9 @@ function resolveNameRedactor(options) {
   if (options.redactStrategy !== "names") {
     return PASS_THROUGH;
   }
+  return buildNameRedactor(options);
+}
+function buildNameRedactor(options) {
   const names = [
     ...options.shouldDisableDefaultRedact ? [] : REDACT_COMMON_FIELDS,
     ...options.redactPaths.flatMap((path) => leafNameOf(path) ?? [])
@@ -1474,8 +1507,9 @@ function resolveRedactOption(options) {
 }
 function buildPinoInstance(options, logContext, destinations, health) {
   const maxBytes = options.maxEntrySizeBytes;
-  const redact = resolveNameRedactor(options);
-  const bound = (serializer) => createSizeBoundedSerializer((input) => redact(serializer(input)), maxBytes);
+  const redactRecord = resolveNameRedactor(options);
+  const redactSerialized = buildNameRedactor(options);
+  const bound = (serializer) => createSizeBoundedSerializer((input) => redactSerialized(serializer(input)), maxBytes);
   const serializers = {
     err: bound(serializeErrorValue),
     ...Object.fromEntries(
@@ -1512,14 +1546,17 @@ function buildPinoInstance(options, logContext, destinations, health) {
       // consumer's extra metadata instead of silently dropping it. Runs ONCE, at
       // logger construction — no per-entry cost. `true`: bindings are a record
       // root, iterated rather than serialized.
-      bindings: (bindings) => redact(bindings, true),
+      bindings: (bindings) => redactRecord(bindings, true),
       // The name-walk redactor runs here, on the merged record (mixin output +
       // the caller's object), which is exactly the surface a caller controls.
       // `base` and child bindings are NOT visible at this hook — they are
       // library-owned (`service`, the `@InjectLogger` context) and carry nothing
       // sensitive, which `pino-factory.spec.ts` pins.
       log: (record) => withSemconvException(
-        withEventName(redact(record, true), options.eventNameField),
+        withEventName(
+          redactRecord(record, true),
+          options.eventNameField
+        ),
         options.errorFormat
       )
     },
@@ -1757,7 +1794,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}
 `
         );
@@ -2037,23 +2074,60 @@ exports.BymaxLoggerModule = __decorateClass([
 ], exports.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
@@ -2066,18 +2140,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.
@@ -2088,8 +2175,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.
    */
@@ -2101,7 +2190,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.
@@ -2110,6 +2228,7 @@ var PrettyDevDestination = class {
   async onShutdown() {
     const stream = this.stream;
     if (stream === void 0) {
+      this.flushBuffer(writeRawToStdout);
       return;
     }
     await new Promise((resolve, reject) => {

package/dist/server/index.d.cts

@@ -864,28 +864,119 @@ 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'`.
+     *
+     * **A dot means "nested path", so a field name CONTAINING a dot has to escape
+     * it.** This library emits `event.name` as a literal top-level key, so the
+     * obvious spelling silently hides nothing — `pino-pretty` looks for an `event`
+     * object with a `name` inside and finds neither. Measured on one entry, only
+     * the option changing:
+     *
+     * ```
+     * ignore: '…,event.name'    → INFO: msg {"logKey":"X","event.name":"x"}   ← still there
+     * ignore: '…,event\\.name'  → INFO: msg {"logKey":"X"}                    ← hidden
+     * ```
+     *
+     * In a TypeScript string literal that is `'event\\.name'` — one real backslash
+     * reaching `pino-pretty`. Nested objects (`service`, `deployment`) need no
+     * escape; they really are paths.
+     */
+    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 +984,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 +1038,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 +1511,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 };