logixia 2.0.0 → 2.0.6

package/dist/{logitron-logger-BFDSO8Io.d.mts → logitron-logger-D_MYYrQt.d.ts}

@@ -1,105 +1,17 @@
-import { b as LoggerWithLevels, f as ILogger, h as LogEntry, p as ILoggerDefault, v as LogLevelString, x as NamespaceLevels, y as LoggerConfig } from "./index-3mw5gaCw.mjs";
-
-//#region src/plugin.d.ts
-
-interface LogixiaPlugin {
-  /**
-   * Unique plugin name.
-   * logixia uses this to prevent duplicate registration of the same plugin
-   * on the same logger instance.
-   */
-  name: string;
-  /**
-   * Called once immediately after `logger.use(plugin)` is called.
-   * Use for one-time setup (open connections, allocate buffers, etc.).
-   * Async `onInit` errors are silently swallowed to avoid blocking the logger.
-   */
-  onInit?(): void | Promise<void>;
-  /**
-   * Called for every log entry **after** PII redaction and **before** transport
-   * dispatch. Plugins run in registration order; each receives the (possibly
-   * modified) output of the previous plugin.
-   *
-   * - Return the entry (modified or unchanged) to continue processing.
-   * - Return `null` to **drop** the entry — no transport will receive it.
-   *
-   * Errors thrown inside `onLog` are swallowed so a buggy plugin cannot crash
-   * logging; the chain continues with the previous (un-transformed) entry.
-   */
-  onLog?(entry: LogEntry): LogEntry | null | Promise<LogEntry | null>;
-  /**
-   * Called when a transport write fails (after any configured retries).
-   * Useful for routing transport errors to an alerting or metrics system.
-   * Errors thrown inside `onError` are silently swallowed.
-   */
-  onError?(error: Error, entry?: LogEntry): void | Promise<void>;
-  /**
-   * Called when the logger is closed via `logger.close()` or the process
-   * receives a shutdown signal (when `gracefulShutdown` is enabled).
-   * Errors thrown inside `onShutdown` are silently swallowed.
-   */
-  onShutdown?(): void | Promise<void>;
-}
-/**
- * Holds an ordered list of `LogixiaPlugin` instances and dispatches lifecycle
- * events to them. One registry is created per logger instance; a global
- * singleton is also exported for process-wide registration.
- */
-declare class PluginRegistry {
-  private readonly _plugins;
-  /**
-   * Register a plugin. Silently skips if a plugin with the same `name` is
-   * already registered on this registry.
-   */
-  register(plugin: LogixiaPlugin): void;
-  /** Remove a previously registered plugin by name. No-op if not found. */
-  unregister(name: string): void;
-  /** Returns `true` if a plugin with the given name is registered. */
-  has(name: string): boolean;
-  /** Number of currently registered plugins. */
-  get size(): number;
-  /**
-   * Run all `onLog` hooks in order.
-   * Returns `null` if any plugin cancels the entry; otherwise returns the
-   * (possibly transformed) entry.
-   */
-  runOnLog(entry: LogEntry): Promise<LogEntry | null>;
-  /**
-   * Notify all `onError` hooks.
-   * Errors thrown inside hooks are swallowed to prevent error cascades.
-   */
-  runOnError(error: Error, entry?: LogEntry): Promise<void>;
-  /** Run all `onShutdown` hooks concurrently. Hook errors are swallowed. */
-  runOnShutdown(): Promise<void>;
-}
+import { C as LogixiaLoggerInstance, L as LogixiaPlugin, b as LoggerConfig, p as ILoggerDefault, w as NamespaceLevels, x as LoggerWithLevels, y as LogLevelString } from "./index-CFDGkI8n.js";
 /**
- * Module-level singleton registry.
- *
- * Plugins registered here are automatically copied into every **new** logger
- * instance created after the registration. Already-created loggers are not
- * retroactively affected — use `logger.use(plugin)` for per-instance control.
- */
-declare const globalPluginRegistry: PluginRegistry;
-/**
- * Register a plugin in the global registry so it applies to every future
- * logger instance.
+ * The logixia logger. Create instances with {@link createLogger} so that custom
+ * levels from `levelOptions.levels` also become methods.
  *
  * @example
  * ```ts
- * import { usePlugin } from 'logixia';
- *
- * usePlugin({
- *   name: 'audit-sink',
- *   onLog(entry) {
- *     if (entry.level === 'error') auditQueue.push(entry);
- *     return entry;
- *   },
- * });
+ * const logger = createLogger({ appName: 'api', environment: 'production' });
+ * await logger.info('Server started', { port: 3000 });
+ * const req = logger.child('RequestHandler', { requestId: 'r-1' });
+ * await req.error(new Error('boom'));
+ * await logger.close(); // flush buffered transports before exit
  * ```
  */
-declare function usePlugin(plugin: LogixiaPlugin): void;
-//#endregion
-//#region src/core/logitron-logger.d.ts
 declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>> = LoggerConfig> implements ILoggerDefault {
   [K: string]: any;
   private config;
@@ -114,6 +26,8 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>>
   private _levelValues;
   /** Numeric threshold for the currently active log level. */
   private _minLevelValue;
+  /** Level set via setLevel(); outranks every other level source until the process ends. */
+  private _runtimeLevel;
   /** `source=value` pairs already reported as unknown levels — warn once per logger. */
   private readonly _warnedInvalidLevels;
   /** Pre-built ANSI color codes to avoid recreating the object in colorize(). */
@@ -137,6 +51,10 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>>
   private readonly _pluginRegistry;
   /** Set on loggers created by child(); they borrow the root's transports, sampler and plugins. */
   private readonly _parent;
+  /** Namespace level map shared by a logger and all its children; `version` bumps on every change. */
+  private readonly _nsStore;
+  /** Store version this logger's threshold was last computed against. */
+  private _nsSeenVersion;
   constructor(config: TConfig, context?: string, parent?: LogixiaLogger<TConfig>);
   private setupGracefulShutdown;
   private createCustomLevelMethods;
@@ -145,17 +63,61 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>>
    * Keeps the actual log() call free of allocations in the common case.
    */
   private _buildPerfCaches;
+  /**
+   * Log at `error` level. An `Error` is logged with its message and serialized
+   * (name, message, stack) under `data.error`; a string is logged as-is.
+   * `data` is merged into the entry payload.
+   */
   error(messageOrError: string | Error, data?: Record<string, unknown>): Promise<void>;
+  /** Log `message` at `warn` level; `data` is merged into the entry payload. */
   warn(message: string, data?: Record<string, unknown>): Promise<void>;
+  /** Log `message` at `info` level; `data` is merged into the entry payload. */
   info(message: string, data?: Record<string, unknown>): Promise<void>;
+  /** Log `message` at `debug` level; `data` is merged into the entry payload. */
   debug(message: string, data?: Record<string, unknown>): Promise<void>;
+  /** Log `message` at `trace` level; `data` is merged into the entry payload. */
   trace(message: string, data?: Record<string, unknown>): Promise<void>;
+  /** Log `message` at `verbose` level; `data` is merged into the entry payload. */
   verbose(message: string, data?: Record<string, unknown>): Promise<void>;
+  /**
+   * Log at an arbitrary level name, including custom levels. Levels below the
+   * active threshold are dropped, as are level names that are not registered
+   * in `levelOptions.levels` (and are not built-in).
+   */
   logLevel(level: string, message: string, data?: Record<string, unknown>): Promise<void>;
+  /** Start a named timer; finish it with {@link timeEnd}. Reusing a label restarts it. */
   time(label: string): void;
+  /**
+   * Stop the timer `label`, log its duration at `info` level, and return the
+   * elapsed milliseconds. Logs a `warn` and returns `undefined` if the timer
+   * does not exist.
+   *
+   * @example
+   * ```ts
+   * logger.time('db');
+   * await query();
+   * const ms = await logger.timeEnd('db');
+   * ```
+   */
   timeEnd(label: string): Promise<number | undefined>;
   timeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
+  /**
+   * Change the minimum log level at runtime. The override outranks
+   * `LOGIXIA_LEVEL`, `LOGIXIA_LEVEL_<NS>` and `namespaceLevels`, and survives
+   * later changes to fields or namespace levels. Unknown level names are
+   * ignored with a warning and the current level is kept.
+   *
+   * @example
+   * ```ts
+   * logger.setLevel('debug');
+   * ```
+   */
   setLevel(level: LogLevelString): void;
+  /**
+   * Return the configured minimum log level, not the per-namespace effective
+   * one. Without `setLevel()` it is `LOGIXIA_LEVEL`, else `levelOptions.level`,
+   * else a `NODE_ENV` default (`debug` in development, `warn` in test), else `info`.
+   */
   getLevel(): LogLevelString;
   private _validLevelList;
   /**
@@ -171,6 +133,10 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>>
    * (flip a module's verbosity live to chase a bug without raising global
    * volume). The new map fully replaces the previous one.
    *
+   * The map is shared by a logger and all its `child()` loggers: calling this on
+   * a child changes the whole family, and existing children pick the change up on
+   * their next log call.
+   *
    * @example
    * ```ts
    * // Turn on debug for the DB layer only, live:
@@ -182,22 +148,45 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>>
   patchNamespaceLevels(levels: NamespaceLevels): void;
   /** Return a copy of the current per-namespace level map. */
   getNamespaceLevels(): NamespaceLevels;
+  private _syncNamespaceLevels;
+  /** Set the context label (e.g. a class or module name) attached to every subsequent entry. */
   setContext(context: string): void;
+  /** Return the current context label, or `undefined` if none is set. */
   getContext(): string | undefined;
+  /** Show `fieldName` in log output, overriding the config for this logger instance. */
   enableField(fieldName: string): void;
+  /** Hide `fieldName` from log output, overriding the config for this logger instance. */
   disableField(fieldName: string): void;
+  /** Whether `fieldName` is currently shown: runtime override first, then config, default `true`. */
   isFieldEnabled(fieldName: string): boolean;
+  /** Return the visibility (`true` = shown) of every standard log field. */
   getFieldState(): Record<string, boolean>;
+  /** Drop all runtime enable/disable overrides so field visibility follows the config again. */
   resetFieldState(): void;
   /** @deprecated No-op. Library code never prompts on stdin; use setTransportLevels(). */
   enableTransportLevelPrompting(): void;
   /** @deprecated No-op. */
   disableTransportLevelPrompting(): void;
+  /** Restrict `transportId` to only the given `levels`. Warns if no transports are configured. */
   setTransportLevels(transportId: string, levels: string[]): void;
+  /** Return the levels `transportId` is restricted to, or `undefined` if it has none. */
   getTransportLevels(transportId: string): string[] | undefined;
   clearTransportLevelPreferences(): void;
+  /** Return the identifiers of the configured transports (empty if none). */
   getAvailableTransports(): string[];
-  child(context: string, data?: Record<string, unknown>): ILogger;
+  /**
+   * Create a child logger with its own `context` that shares this logger's
+   * configuration and transports. `data` is merged into the bound fields
+   * inherited from this logger and added to every entry the child writes.
+   * Closing a child does not close the shared transports.
+   *
+   * @example
+   * ```ts
+   * const req = logger.child('Checkout', { requestId: 'r-42' });
+   * await req.info('started'); // entry includes requestId
+   * ```
+   */
+  child(context: string, data?: Record<string, unknown>): LogixiaLoggerInstance;
   /**
    * Register a plugin on this logger instance.
    *
@@ -215,11 +204,27 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>>
    * No-op if the plugin is not registered on this instance.
    */
   unuse(pluginName: string): this;
+  /** Flush buffered entries in all transports without closing them. */
   flush(): Promise<void>;
+  /** Report whether the transports are healthy; `healthy: false` if no transport manager exists. */
   healthCheck(): Promise<{
     healthy: boolean;
     details: Record<string, unknown>;
   }>;
+  /**
+   * Warn about timers that were never ended, then flush and close all transports,
+   * stop the sampler and run plugin shutdown hooks. On a child logger only the
+   * timer warnings run; the shared transports stay open.
+   *
+   * To flush on SIGTERM/SIGINT, set the `gracefulShutdown` config option rather
+   * than writing your own signal handler; do not combine it with a manual
+   * handler that calls `process.exit`, which can cut the flush short.
+   *
+   * @example
+   * ```ts
+   * await logger.close(); // e.g. at the end of a script or a test
+   * ```
+   */
   close(): Promise<void>;
   private log;
   /**
@@ -231,6 +236,7 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>>
    * Feature 3: Resolve the effective log level for this logger instance.
    *
    * Priority:
+   *  0. A level set at runtime with `setLevel()` (explicit programmatic call, wins over all below)
    *  1. ENV `LOGIXIA_LEVEL_<NS_UPPER>` (e.g. LOGIXIA_LEVEL_DB for ns "db" or "db.queries")
    *  2. Matching `namespaceLevels` config entry (longer pattern = more specific, wins)
    *  3. Global `LOGIXIA_LEVEL` ENV override
@@ -251,7 +257,22 @@ declare class LogixiaLogger<TConfig extends LoggerConfig<Record<string, number>>
    * back to a direct stdout/stderr write so the entry is never lost. */
   private _handleOutputError;
 }
+/**
+ * Create a logger from `config`, with an optional default `context` label.
+ *
+ * Every key of `levelOptions.levels` that is not already a method becomes an
+ * async method on the returned logger, typed through the config, and routes to
+ * {@link LogixiaLogger.logLevel}.
+ *
+ * @example
+ * ```ts
+ * const logger = createLogger({
+ *   appName: 'api',
+ *   levelOptions: { level: 'info', levels: { error: 0, warn: 1, info: 2, audit: 2 } },
+ * });
+ * await logger.audit('user exported data', { userId: 'u1' });
+ * ```
+ */
 declare function createLogger<T extends LoggerConfig<Record<string, number>>>(config: T, context?: string): LoggerWithLevels<T>;
-//#endregion
-export { globalPluginRegistry as a, PluginRegistry as i, createLogger as n, usePlugin as o, LogixiaPlugin as r, LogixiaLogger as t };
-//# sourceMappingURL=logitron-logger-BFDSO8Io.d.mts.map
+export { createLogger as n, LogixiaLogger as t };
+//# sourceMappingURL=logitron-logger-D_MYYrQt.d.ts.map

package/dist/logitron-logger-D_MYYrQt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logitron-logger-D_MYYrQt.d.ts","names":[],"sources":["../src/core/logitron-logger.ts"],"mappings":";;;;;;;;;;;;;;cAyLa,cACX,gBAAgB,aAAa,0BAA0B,yBAC5C;GAEV;UAEO;UACA;UACA;UACA;UACA;UACA;;mBAGS;;UAIT;;UAEA;;UAEA;;mBAES;;UAET;;UAEA;;UAEA;;;;;UAKA;;UAEA;;UAEA;;UAEA;;mBAES;;mBAEA;;mBAEA;;UAET;EAEI,YAAA,QAAQ,SAAS,kBAAkB,SAAS,cAAc;UA4G9D;UAiBA;;;;;UAsBA;;;;;;EA2HF,MAAM,yBAAyB,OAAO,OAAO,0BAA0B;;EAYvE,KAAK,iBAAiB,OAAO,0BAA0B;;EAKvD,KAAK,iBAAiB,OAAO,0BAA0B;;EAKvD,MAAM,iBAAiB,OAAO,0BAA0B;;EAKxD,MAAM,iBAAiB,OAAO,0BAA0B;;EAKxD,QAAQ,iBAAiB,OAAO,0BAA0B;;;;;;EAS1D,SAAS,eAAe,iBAAiB,OAAO,0BAA0B;;EAOhF,KAAK;;;;;;;;;;;;;EAgBC,QAAQ,gBAAgB;EAmBxB,UAAU,GAAG,eAAe,UAAU,QAAQ,KAAK,QAAQ;;;;;;;;;;;;EAyBjE,SAAS,OAAO;;;;;;EAuBhB,YAAY;UAIJ;;;;;UAQA;;;;;;;;;;;;;;;;;;;EAkCR,mBAAmB,QAAQ;;EAS3B,qBAAqB,QAAQ;;EAO7B,sBAAsB;UAId;;EAMR,WAAW;;EAKX;;EAOA,YAAY;;EASZ,aAAa;;EASb,eAAe;;EASf,iBAAiB;;EAmBjB;;EAQA;;EAMA;;EAMA,mBAAmB,qBAAqB;;EAMxC,mBAAmB;EAMnB;;EAMA;;;;;;;;;;;;;EAkBA,MAAM,iBAAiB,OAAO,0BAA0B;;;;;;;;;;;;EA0BxD,IAAI,QAAQ;;;;;EASZ,MAAM;;EAQA,SAAS;;EAKT,eAAe;IAAU;IAAkB,SAAS;;;;;;;;;;;;;;;;EAqBpD,SAAS;UAsBD;;;;;UA8GN;;;;;;;;;;;UAgBA;UAwCA;UAgDA;;;;;;;;UAcA;;;UAuBM;;;;;;;;;;;;;;;;;;iBA+BA,aAAa,UAAU,aAAa,yBAClD,QAAQ,GACR,mBACC,iBAAiB"}

package/dist/middleware.d.mts

@@ -1,8 +1,5 @@
-import "./transport.types-BMnurPcc.mjs";
-import { u as IBaseLogger } from "./index-3mw5gaCw.mjs";
-
-//#region src/middleware/http-logger.d.ts
-
+import { n as HttpResponseShape, t as HttpRequestShape } from "./http-shapes-BnBkJcid.mjs";
+import { u as IBaseLogger } from "./index-BSTtFcQ6.mjs";
 interface HttpLoggerOptions {
   /**
    * Skip logging for a request. Called before any I/O.
@@ -28,10 +25,13 @@ interface HttpLoggerOptions {
    */
   extraFields?: (req: IncomingRequest) => Record<string, unknown>;
   /**
-   * Trace ID header. Default: 'x-trace-id'.
-   * If the header is absent, a short random ID is generated.
+   * Header name, or list of names tried in order, to read the trace ID from.
+   * Default: the library-wide list (`DEFAULT_TRACE_HEADERS`: traceparent,
+   * x-trace-id, x-request-id, x-correlation-id, trace-id).
+   * If none is present, `request.id` is used when it is not a framework counter,
+   * otherwise a UUID is generated and shared with the logixia context helpers.
    */
-  traceIdHeader?: string;
+  traceIdHeader?: string | readonly string[];
   /**
    * Additional headers to redact from logged output. Merged with the defaults
    * (authorization, cookie, set-cookie, x-api-key, proxy-authorization,
@@ -54,26 +54,12 @@ interface HttpLoggerOptions {
   /** Log level for error responses (status ≥ 500). Default: 'error'. */
   errorLevel?: string;
 }
-interface IncomingRequest {
-  method?: string;
-  url?: string;
-  headers?: Record<string, string | string[] | undefined>;
-  body?: unknown;
-  socket?: {
-    remoteAddress?: string;
-  };
-  ip?: string;
-}
-interface OutgoingResponse {
-  statusCode?: number;
-  on?: (event: string, cb: () => void) => void;
-  once?: (event: string, cb: () => void) => void;
-  getHeader?: (name: string) => string | number | string[] | undefined;
-}
+type IncomingRequest = HttpRequestShape;
+type OutgoingResponse = HttpResponseShape;
 /**
  * Create an Express / Connect compatible middleware that replaces Morgan.
  */
-declare function createExpressMiddleware(logger: IBaseLogger, options?: HttpLoggerOptions): (req: IncomingRequest, res: OutgoingResponse, next: () => void) => void;
+export declare function createExpressMiddleware(logger: IBaseLogger, options?: HttpLoggerOptions): (req: IncomingRequest, res: OutgoingResponse, next: () => void) => void;
 interface FastifyInstance {
   addHook: (name: string, fn: (req: unknown, reply: unknown, done: () => void) => void) => void;
 }
@@ -85,9 +71,8 @@ interface FastifyInstance {
  * await fastify.register(createFastifyPlugin(logger, { slowRequestThresholdMs: 500 }));
  * ```
  */
-declare function createFastifyPlugin(logger: IBaseLogger, options?: HttpLoggerOptions): ((fastify: FastifyInstance, _opts: unknown, done: () => void) => void) & {
+export declare function createFastifyPlugin(logger: IBaseLogger, options?: HttpLoggerOptions): ((fastify: FastifyInstance, _opts: unknown, done: () => void) => void) & {
   [x: symbol]: string | boolean;
 };
-//#endregion
-export { type FastifyInstance, type HttpLoggerOptions, type IncomingRequest, type OutgoingResponse, createExpressMiddleware, createFastifyPlugin };
+export type { FastifyInstance, HttpLoggerOptions, IncomingRequest, OutgoingResponse };
 //# sourceMappingURL=middleware.d.mts.map

package/dist/middleware.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.mts","names":[],"sources":["../src/middleware/http-logger.ts"],"sourcesContent":[],"mappings":";;;;;UA+BiB,iBAAA;;;;;eAKF;;;;;;;;;;;;;;;;;;sBAkBO,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BzB,eAAA;;;YAGL;;;;;;;UAMK,gBAAA;;;;;;;;;iBAsID,uBAAA,SACN,uBACC,0BACF,sBAAsB;UAqFd,eAAA;;;;;;;;;;;iBAYD,mBAAA,SAA4B,uBAAsB,+BAYzB"}
+{"version":3,"file":"middleware.d.mts","names":[],"sources":["../src/middleware/http-logger.ts"],"mappings":";;UAuCiB;;;;;EAKf,QAAQ,KAAK;;;;;;EAMb;;EAEA;;;;;EAKA;;;;;EAKA,eAAe,KAAK,oBAAoB;;;;;;;;EAQxC;;;;;;EAMA;;;;;;EAMA;;;;;EAKA;;EAEA;;EAEA;;KAIU,kBAAkB;KAClB,mBAAmB;;;;wBA+Df,wBACd,QAAQ,aACR,UAAS,qBACP,KAAK,iBAAiB,KAAK,kBAAkB;UAqFhC;EACf,UAAU,cAAc,KAAK,cAAc,gBAAgB;;;;;;;;;;wBAW7C,oBAAoB,QAAQ,aAAa,UAAS,sBAAsB,SAY/C,iBAAe,gBAAgB"}

package/dist/middleware.d.ts

@@ -1,8 +1,5 @@
-import "./transport.types-CGoHpWQR.js";
-import { u as IBaseLogger } from "./index-DhIoploR.js";
-
-//#region src/middleware/http-logger.d.ts
-
+import { n as HttpResponseShape, t as HttpRequestShape } from "./http-shapes-BnBkJcid.js";
+import { u as IBaseLogger } from "./index-CFDGkI8n.js";
 interface HttpLoggerOptions {
   /**
    * Skip logging for a request. Called before any I/O.
@@ -28,10 +25,13 @@ interface HttpLoggerOptions {
    */
   extraFields?: (req: IncomingRequest) => Record<string, unknown>;
   /**
-   * Trace ID header. Default: 'x-trace-id'.
-   * If the header is absent, a short random ID is generated.
+   * Header name, or list of names tried in order, to read the trace ID from.
+   * Default: the library-wide list (`DEFAULT_TRACE_HEADERS`: traceparent,
+   * x-trace-id, x-request-id, x-correlation-id, trace-id).
+   * If none is present, `request.id` is used when it is not a framework counter,
+   * otherwise a UUID is generated and shared with the logixia context helpers.
    */
-  traceIdHeader?: string;
+  traceIdHeader?: string | readonly string[];
   /**
    * Additional headers to redact from logged output. Merged with the defaults
    * (authorization, cookie, set-cookie, x-api-key, proxy-authorization,
@@ -54,26 +54,12 @@ interface HttpLoggerOptions {
   /** Log level for error responses (status ≥ 500). Default: 'error'. */
   errorLevel?: string;
 }
-interface IncomingRequest {
-  method?: string;
-  url?: string;
-  headers?: Record<string, string | string[] | undefined>;
-  body?: unknown;
-  socket?: {
-    remoteAddress?: string;
-  };
-  ip?: string;
-}
-interface OutgoingResponse {
-  statusCode?: number;
-  on?: (event: string, cb: () => void) => void;
-  once?: (event: string, cb: () => void) => void;
-  getHeader?: (name: string) => string | number | string[] | undefined;
-}
+type IncomingRequest = HttpRequestShape;
+type OutgoingResponse = HttpResponseShape;
 /**
  * Create an Express / Connect compatible middleware that replaces Morgan.
  */
-declare function createExpressMiddleware(logger: IBaseLogger, options?: HttpLoggerOptions): (req: IncomingRequest, res: OutgoingResponse, next: () => void) => void;
+export declare function createExpressMiddleware(logger: IBaseLogger, options?: HttpLoggerOptions): (req: IncomingRequest, res: OutgoingResponse, next: () => void) => void;
 interface FastifyInstance {
   addHook: (name: string, fn: (req: unknown, reply: unknown, done: () => void) => void) => void;
 }
@@ -85,9 +71,8 @@ interface FastifyInstance {
  * await fastify.register(createFastifyPlugin(logger, { slowRequestThresholdMs: 500 }));
  * ```
  */
-declare function createFastifyPlugin(logger: IBaseLogger, options?: HttpLoggerOptions): ((fastify: FastifyInstance, _opts: unknown, done: () => void) => void) & {
+export declare function createFastifyPlugin(logger: IBaseLogger, options?: HttpLoggerOptions): ((fastify: FastifyInstance, _opts: unknown, done: () => void) => void) & {
   [x: symbol]: string | boolean;
 };
-//#endregion
-export { type FastifyInstance, type HttpLoggerOptions, type IncomingRequest, type OutgoingResponse, createExpressMiddleware, createFastifyPlugin };
+export type { FastifyInstance, HttpLoggerOptions, IncomingRequest, OutgoingResponse };
 //# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../src/middleware/http-logger.ts"],"sourcesContent":[],"mappings":";;;;;UA+BiB,iBAAA;;;;;eAKF;;;;;;;;;;;;;;;;;;sBAkBO,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BzB,eAAA;;;YAGL;;;;;;;UAMK,gBAAA;;;;;;;;;iBAsID,uBAAA,SACN,uBACC,0BACF,sBAAsB;UAqFd,eAAA;;;;;;;;;;;iBAYD,mBAAA,SAA4B,uBAAsB,+BAYzB"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../src/middleware/http-logger.ts"],"mappings":";;UAuCiB;;;;;EAKf,QAAQ,KAAK;;;;;;EAMb;;EAEA;;;;;EAKA;;;;;EAKA,eAAe,KAAK,oBAAoB;;;;;;;;EAQxC;;;;;;EAMA;;;;;;EAMA;;;;;EAKA;;EAEA;;EAEA;;KAIU,kBAAkB;KAClB,mBAAmB;;;;wBA+Df,wBACd,QAAQ,aACR,UAAS,qBACP,KAAK,iBAAiB,KAAK,kBAAkB;UAqFhC;EACf,UAAU,cAAc,KAAK,cAAc,gBAAgB;;;;;;;;;;wBAW7C,oBAAoB,QAAQ,aAAa,UAAS,sBAAsB,SAY/C,iBAAe,gBAAgB"}

package/dist/middleware.js

@@ -1,80 +1,23 @@
-const require_internal_log = require('./internal-log-BUJYMZbE.js');
-const require_safe_stringify = require('./safe-stringify-DWo3aZp_.js');
-const require_trace_utils = require('./trace.utils-DpBOLDtq.js');
-
-//#region src/middleware/http-logger.ts
-const DEFAULT_REDACT_HEADERS = [
-	"authorization",
-	"cookie",
-	"set-cookie",
-	"x-api-key",
-	"proxy-authorization",
-	"x-auth-token",
-	"x-access-token",
-	"x-csrf-token",
-	"x-amz-security-token"
-];
-const DEFAULT_REDACT_QUERY_PARAMS = [
-	"token",
-	"access_token",
-	"refresh_token",
-	"code",
-	"password",
-	"secret",
-	"api_key",
-	"apikey",
-	"key",
-	"signature",
-	"sig",
-	"auth"
-];
-function buildNameSet(defaults, extra) {
-	return new Set([...defaults, ...extra ?? []].map((n) => n.toLowerCase()));
-}
-function safeDecode(value) {
-	try {
-		return decodeURIComponent(value.replace(/\+/g, " "));
-	} catch {
-		return value;
-	}
-}
-/** Replace the values of sensitive query parameters, leaving the rest verbatim. */
-function sanitizeUrl(url, redactParams) {
-	const q = url.indexOf("?");
-	if (q === -1) return url;
-	const hashAt = url.indexOf("#", q);
-	const query = url.slice(q + 1, hashAt === -1 ? void 0 : hashAt);
-	const hash = hashAt === -1 ? "" : url.slice(hashAt);
-	const cleaned = query.split("&").map((pair) => {
-		const eq = pair.indexOf("=");
-		const rawKey = eq === -1 ? pair : pair.slice(0, eq);
-		const decoded = safeDecode(rawKey);
-		const bracket = decoded.indexOf("[");
-		const name = (bracket === -1 ? decoded : decoded.slice(0, bracket)).toLowerCase();
-		return redactParams.has(name) && eq !== -1 ? `${rawKey}=[REDACTED]` : pair;
-	}).join("&");
-	return `${url.slice(0, q)}?${cleaned}${hash}`;
-}
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_own_property = require("./own-property-BWkibepN.js");
+const require_request_trace = require("./request-trace-ByujsUZk.js");
+const require_internal_log = require("./internal-log-By4Govmu.js");
+const require_safe_stringify = require("./safe-stringify-J3sh-7YM.js");
+// src/middleware/http-logger.ts
 function sanitizeHeaders(headers, redactSet) {
 	if (!headers) return {};
 	const out = {};
-	for (const [k, v] of Object.entries(headers)) {
-		if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
-		out[k] = redactSet.has(k.toLowerCase()) ? "[REDACTED]" : v;
-	}
+	for (const [k, v] of Object.entries(headers)) require_own_property.assignOwn(out, k, redactSet.has(k.toLowerCase()) ? "[REDACTED]" : v);
 	return out;
 }
 /** Fire-and-forget a logger call; a failing log must never become an unhandled rejection. */
 function fire(result) {
 	if (result && typeof result.catch === "function") result.catch((error) => require_internal_log.internalError("http-logger: log call failed", error));
 }
-function shortId() {
-	return Math.random().toString(36).slice(2, 10);
-}
 function resolveNameSets(options) {
 	return {
-		headers: buildNameSet(DEFAULT_REDACT_HEADERS, options.redactHeaders),
-		queryParams: buildNameSet(DEFAULT_REDACT_QUERY_PARAMS, options.redactQueryParams)
+		headers: require_internal_log.buildNameSet(require_internal_log.DEFAULT_REDACT_HEADERS, options.redactHeaders),
+		queryParams: require_internal_log.buildNameSet(require_internal_log.DEFAULT_REDACT_QUERY_PARAMS, options.redactQueryParams)
 	};
 }
 function buildBaseFields(req, traceId, options, { headers: redactSet, queryParams: paramSet }) {
@@ -82,7 +25,7 @@ function buildBaseFields(req, traceId, options, { headers: redactSet, queryParam
 	const fields = {
 		traceId,
 		method: ((_req$method = req.method) === null || _req$method === void 0 ? void 0 : _req$method.toUpperCase()) ?? "UNKNOWN",
-		url: sanitizeUrl(req.url ?? "/", paramSet),
+		url: require_internal_log.redactUrlQuery(req.url ?? "/", paramSet),
 		ip: req.ip ?? ((_req$socket = req.socket) === null || _req$socket === void 0 ? void 0 : _req$socket.remoteAddress) ?? "unknown",
 		headers: sanitizeHeaders(req.headers, redactSet)
 	};
@@ -93,16 +36,16 @@ function buildBaseFields(req, traceId, options, { headers: redactSet, queryParam
 * Create an Express / Connect compatible middleware that replaces Morgan.
 */
 function createExpressMiddleware(logger, options = {}) {
-	const { skip, logBody, bodyMaxBytes, traceIdHeader = "x-trace-id", requestLevel = "debug", responseLevel = "info", errorLevel = "error", slowRequestThresholdMs = 1e3 } = options;
+	const { skip, logBody, bodyMaxBytes, traceIdHeader, requestLevel = "debug", responseLevel = "info", errorLevel = "error", slowRequestThresholdMs = 1e3 } = options;
 	const nameSets = resolveNameSets(options);
-	const traceHeaderName = traceIdHeader.toLowerCase();
+	const traceHeaders = require_request_trace.resolveTraceHeaders(traceIdHeader);
 	return function logixiaHttpMiddleware(req, res, next) {
-		var _req$headers, _res$once, _res$once2;
+		var _res$once, _res$once2;
 		if (skip === null || skip === void 0 ? void 0 : skip(req)) {
 			next();
 			return;
 		}
-		const traceId = require_trace_utils.sanitizeIncomingId((_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers[traceHeaderName]) ?? shortId();
+		const traceId = require_request_trace.resolveRequestTraceId(req, traceHeaders);
 		const startMs = Date.now();
 		const baseFields = buildBaseFields(req, traceId, options, nameSets);
 		if (requestLevel !== "silent") fire(logger.logLevel(requestLevel, "request started", {
@@ -142,20 +85,18 @@ function createExpressMiddleware(logger, options = {}) {
 * ```
 */
 function createFastifyPlugin(logger, options = {}) {
-	const { skip, traceIdHeader = "x-trace-id", requestLevel = "debug", responseLevel = "info", errorLevel = "error", slowRequestThresholdMs = 1e3 } = options;
+	const { skip, traceIdHeader, requestLevel = "debug", responseLevel = "info", errorLevel = "error", slowRequestThresholdMs = 1e3 } = options;
 	const nameSets = resolveNameSets(options);
-	const traceHeaderName = traceIdHeader.toLowerCase();
+	const traceHeaders = require_request_trace.resolveTraceHeaders(traceIdHeader);
 	function logixiaFastifyPlugin(fastify, _opts, done) {
 		fastify.addHook("onRequest", (request, _reply, hookDone) => {
-			var _req$headers2;
 			const req = request;
 			if (skip === null || skip === void 0 ? void 0 : skip(req)) {
 				hookDone();
 				return;
 			}
-			const traceId = require_trace_utils.sanitizeIncomingId((_req$headers2 = req.headers) === null || _req$headers2 === void 0 ? void 0 : _req$headers2[traceHeaderName]) ?? shortId();
+			const traceId = require_request_trace.resolveRequestTraceId(req, traceHeaders);
 			req._logixiaStart = Date.now();
-			req._logixiaId = traceId;
 			if (requestLevel !== "silent") fire(logger.logLevel(requestLevel, "request started", buildBaseFields(req, traceId, options, nameSets)));
 			hookDone();
 		});
@@ -168,7 +109,7 @@ function createFastifyPlugin(logger, options = {}) {
 			const rep = reply;
 			const duration = Date.now() - req._logixiaStart;
 			const status = rep.statusCode ?? 0;
-			const traceId = req._logixiaId ?? shortId();
+			const traceId = require_request_trace.resolveRequestTraceId(req, traceHeaders);
 			const level = status >= 500 ? errorLevel : responseLevel;
 			const baseFields = buildBaseFields(req, traceId, options, nameSets);
 			fire(logger.logLevel(level, "request completed", {
@@ -247,13 +188,12 @@ function pruneValue(value, budget, depth, ancestors) {
 		}
 		const record = {};
 		for (const [k, v] of Object.entries(value)) {
-			if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
 			if (budget.left <= 0) {
 				record["…"] = TRUNCATED;
 				break;
 			}
 			budget.left -= k.length;
-			record[k] = pruneValue(v, budget, depth + 1, ancestors);
+			require_own_property.assignOwn(record, k, pruneValue(v, budget, depth + 1, ancestors));
 		}
 		return record;
 	} catch {
@@ -262,8 +202,7 @@ function pruneValue(value, budget, depth, ancestors) {
 		ancestors.delete(value);
 	}
 }
-
-//#endregion
 exports.createExpressMiddleware = createExpressMiddleware;
 exports.createFastifyPlugin = createFastifyPlugin;
+
 //# sourceMappingURL=middleware.js.map