evlog 2.14.1 → 2.15.0

package/dist/fork-D44V93-K.mjs

@@ -0,0 +1,227 @@
+import { M as resolveRedactConfig, T as createPluginRunner, g as createRequestLogger, j as redactEvent, k as getEmptyPluginRunner, v as getGlobalDrain, w as shouldKeep, x as isEnabled, y as getGlobalPluginRunner } from "./audit--n0QRR2Y.mjs";
+import { t as extractErrorStatus } from "./errors-BQgyQ9xe.mjs";
+import { n as shouldLog, t as getServiceForPath } from "./routes-B48wm7Pb.mjs";
+//#region src/shared/middleware.ts
+const noopResult = {
+	logger: {
+		set() {},
+		error() {},
+		info() {},
+		warn() {},
+		emit() {
+			return null;
+		},
+		getContext() {
+			return {};
+		}
+	},
+	finish: () => Promise.resolve(null),
+	skipped: true
+};
+const runnerCache = /* @__PURE__ */ new WeakMap();
+/**
+* Resolve the plugin runner for a middleware invocation by merging local
+* plugins with the globally-registered ones (deduplicated by `name`).
+*/
+function resolveMiddlewarePluginRunner(options) {
+	const global = getGlobalPluginRunner();
+	const local = options.plugins;
+	if (!local || local.length === 0) return global;
+	const cached = runnerCache.get(local);
+	if (cached && cached.global === global) return cached.merged;
+	const merged = /* @__PURE__ */ new Map();
+	for (const plugin of global.plugins) merged.set(plugin.name, plugin);
+	for (const plugin of local) merged.set(plugin.name, plugin);
+	if (merged.size === 0) return getEmptyPluginRunner();
+	const runner = createPluginRunner(Array.from(merged.values()));
+	runnerCache.set(local, {
+		global,
+		merged: runner
+	});
+	return runner;
+}
+/**
+* Apply redact, enrich, and drain to an emitted wide event — the same
+* pipeline used by {@link createMiddlewareLogger}'s `finish`.
+*/
+async function runEnrichAndDrain(emittedEvent, options, requestInfo, responseStatus, plugins) {
+	const runner = plugins ?? resolveMiddlewarePluginRunner(options);
+	const resolvedRedact = resolveRedactConfig(options.redact);
+	if (resolvedRedact) redactEvent(emittedEvent, resolvedRedact);
+	if (options.enrich || runner.hasEnrich) {
+		const enrichCtx = {
+			event: emittedEvent,
+			request: requestInfo,
+			headers: options.headers,
+			response: { status: responseStatus }
+		};
+		if (options.enrich) try {
+			await options.enrich(enrichCtx);
+		} catch (err) {
+			console.error("[evlog] enrich failed:", err);
+		}
+		if (runner.hasEnrich) await runner.runEnrich(enrichCtx);
+	}
+	const drain = options.drain ?? getGlobalDrain();
+	const hasUserDrain = !!drain;
+	const hasPluginDrain = runner.hasDrain;
+	if (hasUserDrain || hasPluginDrain) {
+		const drainCtx = {
+			event: emittedEvent,
+			request: requestInfo,
+			headers: options.headers
+		};
+		const tasks = [];
+		if (hasUserDrain) tasks.push((async () => {
+			try {
+				await drain(drainCtx);
+			} catch (err) {
+				console.error("[evlog] drain failed:", err);
+			}
+		})());
+		if (hasPluginDrain) tasks.push(runner.runDrain(drainCtx));
+		await Promise.all(tasks);
+	}
+}
+/**
+* Create a request logger with the full middleware pipeline: route filtering,
+* service overrides, duration tracking, tail sampling, emit, enrich, drain.
+*
+* Framework adapters extract method/path/requestId/headers, call this once
+* per request, and call `finish({ status | error })` when the response ends.
+* If `skipped` is `true`, the route was filtered out — bypass logging.
+*/
+function createMiddlewareLogger(options) {
+	if (!isEnabled()) return noopResult;
+	const { method, path, requestId, include, exclude, routes, keep } = options;
+	if (!shouldLog(path, include, exclude)) return noopResult;
+	const resolvedRequestId = requestId || crypto.randomUUID();
+	const logger = createRequestLogger({
+		method,
+		path,
+		requestId: resolvedRequestId
+	}, { _deferDrain: true });
+	const routeService = getServiceForPath(path, routes);
+	if (routeService) logger.set({ service: routeService });
+	const pluginRunner = resolveMiddlewarePluginRunner(options);
+	if (pluginRunner.hasExtendLogger) pluginRunner.applyExtendLogger(logger);
+	const startTime = Date.now();
+	const requestInfo = {
+		method,
+		path,
+		requestId: resolvedRequestId
+	};
+	if (pluginRunner.hasRequestLifecycle) pluginRunner.runOnRequestStart({
+		logger,
+		request: requestInfo,
+		headers: options.headers
+	});
+	const finish = async (opts) => {
+		const { status, error } = opts ?? {};
+		if (error) {
+			logger.error(error);
+			const errorStatus = extractErrorStatus(error);
+			logger.set({ status: errorStatus });
+		} else if (status !== void 0) logger.set({ status });
+		const durationMs = Date.now() - startTime;
+		const resolvedStatus = error ? extractErrorStatus(error) : status ?? logger.getContext().status;
+		const tailCtx = {
+			status: resolvedStatus,
+			duration: durationMs,
+			path,
+			method,
+			context: logger.getContext(),
+			shouldKeep: false
+		};
+		if (keep) await keep(tailCtx);
+		if (pluginRunner.hasKeep) await pluginRunner.runKeep(tailCtx);
+		const forceKeep = tailCtx.shouldKeep || shouldKeep(tailCtx);
+		const emittedEvent = logger.emit({ _forceKeep: forceKeep });
+		if (emittedEvent && (options.enrich || options.drain || pluginRunner.hasEnrich || pluginRunner.hasDrain || getGlobalDrain())) await runEnrichAndDrain(emittedEvent, options, requestInfo, resolvedStatus, pluginRunner);
+		if (pluginRunner.hasRequestLifecycle) pluginRunner.runOnRequestFinish({
+			logger,
+			request: requestInfo,
+			headers: options.headers,
+			event: emittedEvent,
+			status: resolvedStatus,
+			durationMs,
+			error
+		});
+		return emittedEvent;
+	};
+	return {
+		logger,
+		finish,
+		skipped: false
+	};
+}
+//#endregion
+//#region src/shared/fork.ts
+/**
+* Attach {@link RequestLogger.fork} to a request logger. Replaces any existing `fork`.
+*/
+function attachForkToLogger(storage, parent, middlewareOptions, lifecycle) {
+	const log = parent;
+	log.fork = (label, fn) => {
+		forkBackgroundLogger({
+			storage,
+			parent,
+			middlewareOptions,
+			label,
+			fn,
+			lifecycle
+		});
+	};
+}
+/**
+* Run background work under a child request logger so `useLogger()` resolves to the
+* child while `fn` runs. The child emits a separate wide event when `fn` settles,
+* with `operation` and `_parentRequestId` set for correlation.
+*
+* @beta Part of `evlog/toolkit` — used by framework integrations; prefer `log.fork()`
+* on the request logger when available.
+*/
+function forkBackgroundLogger(options) {
+	const { storage, parent, middlewareOptions, label, fn, lifecycle } = options;
+	const parentCtx = parent.getContext();
+	const parentRequestId = parentCtx.requestId;
+	if (typeof parentRequestId !== "string" || parentRequestId.length === 0) throw new Error("[evlog] log.fork() requires the parent logger to have a requestId. Ensure the request was created by evlog middleware.");
+	const method = String(parentCtx.method ?? middlewareOptions.method);
+	const path = String(parentCtx.path ?? middlewareOptions.path);
+	const child = createRequestLogger({
+		method,
+		path,
+		requestId: crypto.randomUUID()
+	}, { _deferDrain: true });
+	child.set({
+		operation: label,
+		_parentRequestId: parentRequestId
+	});
+	const childRequestInfo = {
+		method,
+		path,
+		requestId: child.getContext().requestId
+	};
+	storage.run(child, () => {
+		lifecycle?.onChildEnter?.(child);
+		Promise.resolve().then(() => fn()).then(async () => {
+			const emittedEvent = child.emit();
+			const ctxStatus = child.getContext().status;
+			const status = emittedEvent?.status ?? (typeof ctxStatus === "number" ? ctxStatus : void 0);
+			if (emittedEvent && (middlewareOptions.enrich || middlewareOptions.drain || getGlobalDrain())) await runEnrichAndDrain(emittedEvent, middlewareOptions, childRequestInfo, status);
+		}).catch(async (err) => {
+			const error = err instanceof Error ? err : new Error(String(err));
+			child.error(error);
+			child.set({ status: extractErrorStatus(error) });
+			const emittedEvent = child.emit();
+			const status = extractErrorStatus(error);
+			if (emittedEvent && (middlewareOptions.enrich || middlewareOptions.drain || getGlobalDrain())) await runEnrichAndDrain(emittedEvent, middlewareOptions, childRequestInfo, status);
+		}).finally(() => {
+			lifecycle?.onChildExit?.(child);
+		});
+	});
+}
+//#endregion
+export { runEnrichAndDrain as a, resolveMiddlewarePluginRunner as i, forkBackgroundLogger as n, createMiddlewareLogger as r, attachForkToLogger as t };
+
+//# sourceMappingURL=fork-D44V93-K.mjs.map

package/dist/fork-D44V93-K.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork-D44V93-K.mjs","names":[],"sources":["../src/shared/middleware.ts","../src/shared/fork.ts"],"sourcesContent":["import type { DrainContext, EnrichContext, RedactConfig, RequestLogger, RouteConfig, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, getGlobalDrain, getGlobalPluginRunner, isEnabled, shouldKeep } from '../logger'\nimport { redactEvent, resolveRedactConfig } from '../redact'\nimport { extractErrorStatus } from './errors'\nimport type { EvlogPlugin, PluginRunner } from './plugin'\nimport { createPluginRunner, getEmptyPluginRunner } from './plugin'\nimport { shouldLog, getServiceForPath } from './routes'\n\n/**\n * Base options shared by every framework integration. Re-exported via\n * `evlog/toolkit` so custom integrations can extend it.\n */\nexport interface BaseEvlogOptions {\n  /** Route glob patterns to include. If unset, all routes are logged. */\n  include?: string[]\n  /** Route glob patterns to exclude. Takes precedence over `include`. */\n  exclude?: string[]\n  /** Per-route service overrides. */\n  routes?: Record<string, RouteConfig>\n  /** Drain callback invoked with every emitted event. */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /** Enrich callback invoked after emit, before drain. */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\n  /** Tail sampling callback. Set `ctx.shouldKeep = true` to force-keep. */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n  /**\n   * PII auto-redaction. `true` enables built-in patterns; pass an object for\n   * fine-grained control. Applied before enrich/drain.\n   */\n  redact?: boolean | RedactConfig\n  /** Plugins for this middleware, merged with globally-registered ones. */\n  plugins?: EvlogPlugin[]\n}\n\n/** Internal options accepted by `createMiddlewareLogger`. */\nexport interface MiddlewareLoggerOptions extends BaseEvlogOptions {\n  method: string\n  path: string\n  requestId?: string\n  /** Pre-filtered safe request headers used for enrich/drain context. */\n  headers?: Record<string, string>\n}\n\nexport interface MiddlewareLoggerResult {\n  logger: RequestLogger\n  finish: (opts?: { status?: number; error?: Error }) => Promise<WideEvent | null>\n  skipped: boolean\n}\n\nconst noopResult: MiddlewareLoggerResult = {\n  logger: {\n    set() {},\n    error() {},\n    info() {},\n    warn() {},\n    emit() {\n      return null \n    },\n    getContext() {\n      return {} \n    },\n  },\n  finish: () => Promise.resolve(null),\n  skipped: true,\n}\n\n// Memoizes the merged runner per local plugins array (stable across requests\n// because it lives in the middleware factory closure). Invalidated when\n// `initLogger` swaps the global runner, so the merge cost is paid once.\nconst runnerCache = new WeakMap<EvlogPlugin[], { global: PluginRunner; merged: PluginRunner }>()\n\n/**\n * Resolve the plugin runner for a middleware invocation by merging local\n * plugins with the globally-registered ones (deduplicated by `name`).\n */\nexport function resolveMiddlewarePluginRunner(options: { plugins?: EvlogPlugin[] }): PluginRunner {\n  const global = getGlobalPluginRunner()\n  const local = options.plugins\n  if (!local || local.length === 0) return global\n\n  const cached = runnerCache.get(local)\n  if (cached && cached.global === global) return cached.merged\n\n  const merged = new Map<string, EvlogPlugin>()\n  for (const plugin of global.plugins) merged.set(plugin.name, plugin)\n  for (const plugin of local) merged.set(plugin.name, plugin)\n  if (merged.size === 0) return getEmptyPluginRunner()\n\n  const runner = createPluginRunner(Array.from(merged.values()))\n  runnerCache.set(local, { global, merged: runner })\n  return runner\n}\n\n/**\n * Apply redact, enrich, and drain to an emitted wide event — the same\n * pipeline used by {@link createMiddlewareLogger}'s `finish`.\n */\n// eslint-disable-next-line max-params\nexport async function runEnrichAndDrain(\n  emittedEvent: WideEvent,\n  options: MiddlewareLoggerOptions,\n  requestInfo: { method: string; path: string; requestId?: string },\n  responseStatus?: number,\n  plugins?: PluginRunner,\n): Promise<void> {\n  const runner = plugins ?? resolveMiddlewarePluginRunner(options)\n  const resolvedRedact = resolveRedactConfig(options.redact)\n  if (resolvedRedact) {\n    redactEvent(emittedEvent, resolvedRedact)\n  }\n\n  if (options.enrich || runner.hasEnrich) {\n    const enrichCtx: EnrichContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n      response: { status: responseStatus },\n    }\n    if (options.enrich) {\n      try {\n        await options.enrich(enrichCtx)\n      } catch (err) {\n        console.error('[evlog] enrich failed:', err)\n      }\n    }\n    if (runner.hasEnrich) {\n      await runner.runEnrich(enrichCtx)\n    }\n  }\n\n  const drain = options.drain ?? getGlobalDrain()\n  const hasUserDrain = !!drain\n  const hasPluginDrain = runner.hasDrain\n  if (hasUserDrain || hasPluginDrain) {\n    const drainCtx: DrainContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n    }\n    const tasks: Array<Promise<unknown>> = []\n    if (hasUserDrain) {\n      tasks.push(\n        (async () => {\n          try {\n            await drain!(drainCtx)\n          } catch (err) {\n            console.error('[evlog] drain failed:', err)\n          }\n        })(),\n      )\n    }\n    if (hasPluginDrain) {\n      tasks.push(runner.runDrain(drainCtx))\n    }\n    await Promise.all(tasks)\n  }\n}\n\n/**\n * Create a request logger with the full middleware pipeline: route filtering,\n * service overrides, duration tracking, tail sampling, emit, enrich, drain.\n *\n * Framework adapters extract method/path/requestId/headers, call this once\n * per request, and call `finish({ status | error })` when the response ends.\n * If `skipped` is `true`, the route was filtered out — bypass logging.\n */\nexport function createMiddlewareLogger(options: MiddlewareLoggerOptions): MiddlewareLoggerResult {\n  if (!isEnabled()) return noopResult\n\n  const { method, path, requestId, include, exclude, routes, keep } = options\n\n  if (!shouldLog(path, include, exclude)) {\n    return noopResult\n  }\n\n  const resolvedRequestId = requestId || crypto.randomUUID()\n\n  const logger = createRequestLogger({\n    method,\n    path,\n    requestId: resolvedRequestId,\n  }, { _deferDrain: true })\n\n  const routeService = getServiceForPath(path, routes)\n  if (routeService) {\n    logger.set({ service: routeService })\n  }\n\n  const pluginRunner = resolveMiddlewarePluginRunner(options)\n  if (pluginRunner.hasExtendLogger) {\n    pluginRunner.applyExtendLogger(logger)\n  }\n\n  const startTime = Date.now()\n  const requestInfo = { method, path, requestId: resolvedRequestId }\n\n  if (pluginRunner.hasRequestLifecycle) {\n    pluginRunner.runOnRequestStart({\n      logger,\n      request: requestInfo,\n      headers: options.headers,\n    })\n  }\n\n  const finish = async (opts?: { status?: number; error?: Error }): Promise<WideEvent | null> => {\n    const { status, error } = opts ?? {}\n\n    if (error) {\n      logger.error(error)\n      const errorStatus = extractErrorStatus(error)\n      logger.set({ status: errorStatus })\n    } else if (status !== undefined) {\n      logger.set({ status })\n    }\n\n    const durationMs = Date.now() - startTime\n\n    const resolvedStatus = error\n      ? extractErrorStatus(error)\n      : status ?? (logger.getContext().status as number | undefined)\n\n    const tailCtx: TailSamplingContext = {\n      status: resolvedStatus,\n      duration: durationMs,\n      path,\n      method,\n      context: logger.getContext(),\n      shouldKeep: false,\n    }\n\n    if (keep) {\n      await keep(tailCtx)\n    }\n    if (pluginRunner.hasKeep) {\n      await pluginRunner.runKeep(tailCtx)\n    }\n\n    const forceKeep = tailCtx.shouldKeep || shouldKeep(tailCtx)\n    const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n\n    if (\n      emittedEvent\n      && (options.enrich || options.drain || pluginRunner.hasEnrich || pluginRunner.hasDrain || getGlobalDrain())\n    ) {\n      await runEnrichAndDrain(emittedEvent, options, requestInfo, resolvedStatus, pluginRunner)\n    }\n\n    if (pluginRunner.hasRequestLifecycle) {\n      pluginRunner.runOnRequestFinish({\n        logger,\n        request: requestInfo,\n        headers: options.headers,\n        event: emittedEvent,\n        status: resolvedStatus,\n        durationMs,\n        error,\n      })\n    }\n\n    return emittedEvent\n  }\n\n  return { logger, finish, skipped: false }\n}\n","import type { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\nimport { createRequestLogger, getGlobalDrain } from '../logger'\nimport { extractErrorStatus } from './errors'\nimport type { MiddlewareLoggerOptions } from './middleware'\nimport { runEnrichAndDrain } from './middleware'\n\n/**\n * Optional hooks for integrations that track active loggers (e.g. Elysia `activeLoggers`).\n */\nexport interface ForkLifecycle {\n  /** Called after the child logger is installed in storage, before `fn` runs. */\n  onChildEnter?: (child: RequestLogger) => void\n  /** Called after the child has finished (emit + enrich/drain), success or failure. */\n  onChildExit?: (child: RequestLogger) => void\n}\n\n/**\n * Options for {@link forkBackgroundLogger}.\n *\n * @beta Part of `evlog/toolkit`\n */\nexport interface ForkBackgroundLoggerOptions {\n  storage: AsyncLocalStorage<RequestLogger>\n  parent: RequestLogger\n  middlewareOptions: MiddlewareLoggerOptions\n  label: string\n  fn: () => void | Promise<void>\n  lifecycle?: ForkLifecycle\n}\n\n/**\n * Attach {@link RequestLogger.fork} to a request logger. Replaces any existing `fork`.\n */\nexport function attachForkToLogger(\n  storage: AsyncLocalStorage<RequestLogger>,\n  parent: RequestLogger,\n  middlewareOptions: MiddlewareLoggerOptions,\n  lifecycle?: ForkLifecycle,\n): void {\n  const log = parent as RequestLogger & { fork?: (label: string, fn: () => void | Promise<void>) => void }\n  log.fork = (label: string, fn: () => void | Promise<void>) => {\n    forkBackgroundLogger({ storage, parent, middlewareOptions, label, fn, lifecycle })\n  }\n}\n\n/**\n * Run background work under a child request logger so `useLogger()` resolves to the\n * child while `fn` runs. The child emits a separate wide event when `fn` settles,\n * with `operation` and `_parentRequestId` set for correlation.\n *\n * @beta Part of `evlog/toolkit` — used by framework integrations; prefer `log.fork()`\n * on the request logger when available.\n */\nexport function forkBackgroundLogger(options: ForkBackgroundLoggerOptions): void {\n  const { storage, parent, middlewareOptions, label, fn, lifecycle } = options\n\n  const parentCtx = parent.getContext() as Record<string, unknown>\n  const parentRequestId = parentCtx.requestId\n  if (typeof parentRequestId !== 'string' || parentRequestId.length === 0) {\n    throw new Error(\n      '[evlog] log.fork() requires the parent logger to have a requestId. '\n      + 'Ensure the request was created by evlog middleware.',\n    )\n  }\n\n  const method = String(parentCtx.method ?? middlewareOptions.method)\n  const path = String(parentCtx.path ?? middlewareOptions.path)\n\n  const child = createRequestLogger(\n    {\n      method,\n      path,\n      requestId: crypto.randomUUID(),\n    },\n    { _deferDrain: true },\n  )\n\n  child.set({\n    operation: label,\n    _parentRequestId: parentRequestId,\n  })\n\n  const childRequestInfo = {\n    method,\n    path,\n    requestId: child.getContext().requestId as string,\n  }\n\n  storage.run(child, () => {\n    lifecycle?.onChildEnter?.(child)\n    void Promise.resolve()\n      .then(() => fn())\n      .then(async () => {\n        const emittedEvent = child.emit()\n        const ctxStatus = child.getContext().status\n        const status = (emittedEvent?.status\n          ?? (typeof ctxStatus === 'number' ? ctxStatus : undefined)) as number | undefined\n        if (\n          emittedEvent\n          && (middlewareOptions.enrich || middlewareOptions.drain || getGlobalDrain())\n        ) {\n          await runEnrichAndDrain(emittedEvent, middlewareOptions, childRequestInfo, status)\n        }\n      })\n      .catch(async (err: unknown) => {\n        const error = err instanceof Error ? err : new Error(String(err))\n        child.error(error)\n        child.set({ status: extractErrorStatus(error) })\n        const emittedEvent = child.emit()\n        const status = extractErrorStatus(error)\n        if (\n          emittedEvent\n          && (middlewareOptions.enrich || middlewareOptions.drain || getGlobalDrain())\n        ) {\n          await runEnrichAndDrain(emittedEvent, middlewareOptions, childRequestInfo, status)\n        }\n      })\n      .finally(() => {\n        lifecycle?.onChildExit?.(child)\n      })\n  })\n}\n"],"mappings":"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"}

package/dist/{headers-D74M0wsg.mjs → headers-CU-QqnYg.mjs}

@@ -24,7 +24,24 @@ function extractSafeNodeHeaders(headers) {
 	}
 	return filterSafeHeaders(raw);
 }
+/**
+* Case-insensitive header lookup against the safe-filtered shape produced by
+* {@link extractSafeHeaders} / {@link extractSafeNodeHeaders}.
+*/
+function getHeader(headers, name) {
+	if (!headers) return void 0;
+	if (headers[name] !== void 0) return headers[name];
+	const lowerName = name.toLowerCase();
+	if (headers[lowerName] !== void 0) return headers[lowerName];
+	for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === lowerName) return value;
+}
+/** Parse a header-derived numeric string. Returns `undefined` for empty/invalid input. */
+function normalizeNumber(value) {
+	if (!value) return void 0;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
 //#endregion
-export { extractSafeNodeHeaders as n, extractSafeHeaders as t };
+export { normalizeNumber as i, extractSafeNodeHeaders as n, getHeader as r, extractSafeHeaders as t };
 
-//# sourceMappingURL=headers-D74M0wsg.mjs.map
+//# sourceMappingURL=headers-CU-QqnYg.mjs.map

package/dist/headers-CU-QqnYg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers-CU-QqnYg.mjs","names":[],"sources":["../src/shared/headers.ts"],"sourcesContent":["import { filterSafeHeaders } from '../utils'\n\n/**\n * Extract headers from a Web API `Headers` object and filter out sensitive ones.\n * Works with any runtime that supports the standard `Headers` API (Hono, Elysia,\n * Nitro v3, Cloudflare Workers, Bun, Deno, etc.).\n */\nexport function extractSafeHeaders(headers: Headers): Record<string, string> {\n  const raw: Record<string, string> = {}\n  headers.forEach((value, key) => {\n    raw[key] = value\n  })\n  return filterSafeHeaders(raw)\n}\n\n/**\n * Extract headers from Node.js `IncomingHttpHeaders` and filter out sensitive ones.\n * Works with Express, Fastify, and any Node.js HTTP server using `req.headers`.\n */\nexport function extractSafeNodeHeaders(headers: Record<string, string | string[] | undefined>): Record<string, string> {\n  const raw: Record<string, string> = {}\n  for (const [key, value] of Object.entries(headers)) {\n    if (value === undefined) continue\n    raw[key] = Array.isArray(value) ? value.join(', ') : value\n  }\n  return filterSafeHeaders(raw)\n}\n\n/**\n * Case-insensitive header lookup against the safe-filtered shape produced by\n * {@link extractSafeHeaders} / {@link extractSafeNodeHeaders}.\n */\nexport function getHeader(headers: Record<string, string> | undefined, name: string): string | undefined {\n  if (!headers) return undefined\n  if (headers[name] !== undefined) return headers[name]\n  const lowerName = name.toLowerCase()\n  if (headers[lowerName] !== undefined) return headers[lowerName]\n  for (const [key, value] of Object.entries(headers)) {\n    if (key.toLowerCase() === lowerName) return value\n  }\n  return undefined\n}\n\n/** Parse a header-derived numeric string. Returns `undefined` for empty/invalid input. */\nexport function normalizeNumber(value: string | undefined): number | undefined {\n  if (!value) return undefined\n  const parsed = Number(value)\n  return Number.isFinite(parsed) ? parsed : undefined\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,mBAAmB,SAA0C;CAC3E,MAAM,MAA8B,EAAE;AACtC,SAAQ,SAAS,OAAO,QAAQ;AAC9B,MAAI,OAAO;GACX;AACF,QAAO,kBAAkB,IAAI;;;;;;AAO/B,SAAgB,uBAAuB,SAAgF;CACrH,MAAM,MAA8B,EAAE;AACtC,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,EAAE;AAClD,MAAI,UAAU,KAAA,EAAW;AACzB,MAAI,OAAO,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK,KAAK,GAAG;;AAEvD,QAAO,kBAAkB,IAAI;;;;;;AAO/B,SAAgB,UAAU,SAA6C,MAAkC;AACvG,KAAI,CAAC,QAAS,QAAO,KAAA;AACrB,KAAI,QAAQ,UAAU,KAAA,EAAW,QAAO,QAAQ;CAChD,MAAM,YAAY,KAAK,aAAa;AACpC,KAAI,QAAQ,eAAe,KAAA,EAAW,QAAO,QAAQ;AACrD,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,CAChD,KAAI,IAAI,aAAa,KAAK,UAAW,QAAO;;;AAMhD,SAAgB,gBAAgB,OAA+C;AAC7E,KAAI,CAAC,MAAO,QAAO,KAAA;CACnB,MAAM,SAAS,OAAO,MAAM;AAC5B,QAAO,OAAO,SAAS,OAAO,GAAG,SAAS,KAAA"}

package/dist/hono/index.d.mts

@@ -1,5 +1,5 @@
-import { Y as RequestLogger } from "../audit-CTIviX3P.mjs";
-import { t as BaseEvlogOptions } from "../middleware-CTnDsST-.mjs";
+import { Y as RequestLogger } from "../audit-CJl-wZ10.mjs";
+import { t as BaseEvlogOptions } from "../middleware-CGM-bOvE.mjs";
 import { MiddlewareHandler } from "hono";
 
 //#region src/hono/index.d.ts

package/dist/hono/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/hono/index.ts"],"mappings":";;;;;KAKY,gBAAA,GAAmB,gBAAA;;AAA/B;;;;;AAgBA;;;;;;;;KAAY,cAAA;EAAmB,SAAA;IAAa,GAAA,EAAK,aAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;iBAoBjC,KAAA,CAAM,OAAA,GAAS,gBAAA,GAAwB,iBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/hono/index.ts"],"mappings":";;;;;KAKY,gBAAA,GAAmB,gBAAA;;AAA/B;;;;;AAgBA;;;;;;;;KAAY,cAAA;EAAmB,SAAA;IAAa,GAAA,EAAK,aAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;iBAiCjC,KAAA,CAAM,OAAA,GAAS,gBAAA,GAAwB,iBAAA"}

package/dist/hono/index.mjs

@@ -1,6 +1,17 @@
-import { t as createMiddlewareLogger } from "../middleware-oAccqyPp.mjs";
-import { t as extractSafeHeaders } from "../headers-D74M0wsg.mjs";
+import { t as defineFrameworkIntegration } from "../integration-Bz8X6_Lb.mjs";
 //#region src/hono/index.ts
+const integration = defineFrameworkIntegration({
+	name: "hono",
+	extractRequest: (c) => ({
+		method: c.req.method,
+		path: c.req.path,
+		headers: c.req.raw.headers,
+		requestId: c.req.header("x-request-id")
+	}),
+	attachLogger: (c, logger) => {
+		c.set("log", logger);
+	}
+});
 /**
 * Create an evlog middleware for Hono.
 *
@@ -21,18 +32,11 @@ import { t as extractSafeHeaders } from "../headers-D74M0wsg.mjs";
 */
 function evlog(options = {}) {
 	return async (c, next) => {
-		const { logger, finish, skipped } = createMiddlewareLogger({
-			method: c.req.method,
-			path: c.req.path,
-			requestId: c.req.header("x-request-id") || crypto.randomUUID(),
-			headers: extractSafeHeaders(c.req.raw.headers),
-			...options
-		});
+		const { skipped, finish } = integration.start(c, options);
 		if (skipped) {
 			await next();
 			return;
 		}
-		c.set("log", logger);
 		try {
 			await next();
 			await finish({ status: c.res.status });

package/dist/hono/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/hono/index.ts"],"sourcesContent":["import type { MiddlewareHandler } from 'hono'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\n\nexport type EvlogHonoOptions = BaseEvlogOptions\n\n/**\n * Hono variables type for typed `c.get('log')` access.\n *\n * @example\n * ```ts\n * const app = new Hono<EvlogVariables>()\n * app.use(evlog())\n * app.get('/api/users', (c) => {\n *   const log = c.get('log')\n *   log.set({ users: { count: 42 } })\n *   return c.json({ users: [] })\n * })\n * ```\n */\nexport type EvlogVariables = { Variables: { log: RequestLogger } }\n\n/**\n * Create an evlog middleware for Hono.\n *\n * @example\n * ```ts\n * import { Hono } from 'hono'\n * import { evlog, type EvlogVariables } from 'evlog/hono'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Hono<EvlogVariables>()\n * app.use(evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * }))\n * ```\n */\nexport function evlog(options: EvlogHonoOptions = {}): MiddlewareHandler {\n  return async (c, next) => {\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: c.req.method,\n      path: c.req.path,\n      requestId: c.req.header('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeHeaders(c.req.raw.headers),\n      ...options,\n    })\n\n    if (skipped) {\n      await next()\n      return\n    }\n\n    c.set('log', logger)\n\n    try {\n      await next()\n      await finish({ status: c.res.status })\n    } catch (error) {\n      await finish({ error: error as Error })\n      throw error\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,MAAM,UAA4B,EAAE,EAAqB;AACvE,QAAO,OAAO,GAAG,SAAS;EACxB,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,EAAE,IAAI;GACd,MAAM,EAAE,IAAI;GACZ,WAAW,EAAE,IAAI,OAAO,eAAe,IAAI,OAAO,YAAY;GAC9D,SAAS,mBAAmB,EAAE,IAAI,IAAI,QAAQ;GAC9C,GAAG;GACJ,CAAC;AAEF,MAAI,SAAS;AACX,SAAM,MAAM;AACZ;;AAGF,IAAE,IAAI,OAAO,OAAO;AAEpB,MAAI;AACF,SAAM,MAAM;AACZ,SAAM,OAAO,EAAE,QAAQ,EAAE,IAAI,QAAQ,CAAC;WAC/B,OAAO;AACd,SAAM,OAAO,EAAS,OAAgB,CAAC;AACvC,SAAM"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/hono/index.ts"],"sourcesContent":["import type { Context, MiddlewareHandler } from 'hono'\nimport type { RequestLogger } from '../types'\nimport { defineFrameworkIntegration } from '../shared/integration'\nimport type { BaseEvlogOptions } from '../shared/middleware'\n\nexport type EvlogHonoOptions = BaseEvlogOptions\n\n/**\n * Hono variables type for typed `c.get('log')` access.\n *\n * @example\n * ```ts\n * const app = new Hono<EvlogVariables>()\n * app.use(evlog())\n * app.get('/api/users', (c) => {\n *   const log = c.get('log')\n *   log.set({ users: { count: 42 } })\n *   return c.json({ users: [] })\n * })\n * ```\n */\nexport type EvlogVariables = { Variables: { log: RequestLogger } }\n\nconst integration = defineFrameworkIntegration<Context>({\n  name: 'hono',\n  extractRequest: (c) => ({\n    method: c.req.method,\n    path: c.req.path,\n    headers: c.req.raw.headers,\n    requestId: c.req.header('x-request-id'),\n  }),\n  attachLogger: (c, logger) => {\n    c.set('log', logger)\n  },\n})\n\n/**\n * Create an evlog middleware for Hono.\n *\n * @example\n * ```ts\n * import { Hono } from 'hono'\n * import { evlog, type EvlogVariables } from 'evlog/hono'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Hono<EvlogVariables>()\n * app.use(evlog({\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * }))\n * ```\n */\nexport function evlog(options: EvlogHonoOptions = {}): MiddlewareHandler {\n  return async (c, next) => {\n    const { skipped, finish } = integration.start(c, options)\n    if (skipped) {\n      await next()\n      return\n    }\n    try {\n      await next()\n      await finish({ status: c.res.status })\n    } catch (error) {\n      await finish({ error: error as Error })\n      throw error\n    }\n  }\n}\n"],"mappings":";;AAuBA,MAAM,cAAc,2BAAoC;CACtD,MAAM;CACN,iBAAiB,OAAO;EACtB,QAAQ,EAAE,IAAI;EACd,MAAM,EAAE,IAAI;EACZ,SAAS,EAAE,IAAI,IAAI;EACnB,WAAW,EAAE,IAAI,OAAO,eAAe;EACxC;CACD,eAAe,GAAG,WAAW;AAC3B,IAAE,IAAI,OAAO,OAAO;;CAEvB,CAAC;;;;;;;;;;;;;;;;;;;AAoBF,SAAgB,MAAM,UAA4B,EAAE,EAAqB;AACvE,QAAO,OAAO,GAAG,SAAS;EACxB,MAAM,EAAE,SAAS,WAAW,YAAY,MAAM,GAAG,QAAQ;AACzD,MAAI,SAAS;AACX,SAAM,MAAM;AACZ;;AAEF,MAAI;AACF,SAAM,MAAM;AACZ,SAAM,OAAO,EAAE,QAAQ,EAAE,IAAI,QAAQ,CAAC;WAC/B,OAAO;AACd,SAAM,OAAO,EAAS,OAAgB,CAAC;AACvC,SAAM"}

package/dist/http.d.mts

@@ -1,4 +1,4 @@
-import { F as DrainContext } from "./audit-CTIviX3P.mjs";
+import { F as DrainContext } from "./audit-CJl-wZ10.mjs";
 import { DrainPipelineOptions, PipelineDrainFn } from "./pipeline.mjs";
 
 //#region src/http.d.ts

package/dist/index.d.mts

@@ -1,7 +1,8 @@
-import { $ as SamplingRates, A as AuditFields, B as H3EventContext, C as buildAuditFields, D as withAudit, E as signed, F as DrainContext, G as LoggerConfig, H as InternalFields, I as EnrichContext, K as ParsedError, L as EnvironmentContext, M as AuditTarget, N as BaseWideEvent, O as withAuditMethods, P as DeepPartial, Q as SamplingConfig, R as ErrorOptions, S as auditRedactPreset, T as mockAudit, U as Log, V as IngestPayload, W as LogLevel, X as RequestLoggerOptions, Y as RequestLogger, _ as WithAuditOptions, a as AuditInput, b as auditEnricher, c as AuditOnlyOptions, d as DefinedAuditAction, et as ServerEvent, f as DrainFn, g as WithAuditContext, h as SignedOptions, i as AuditEnricherOptions, it as WideEvent, j as AuditLoggerMethod, k as AuditActor, l as AuditPatchOp, m as SignedChainState, n as AuditDeniedError, nt as TailSamplingContext, o as AuditMatcher, p as MockAudit, q as RedactConfig, r as AuditDiffOptions, rt as TransportConfig, s as AuditMethod, t as AUDIT_SCHEMA_VERSION, tt as TailSamplingCondition, u as AuditableLogger, v as audit, w as defineAuditAction, x as auditOnly, y as auditDiff, z as FieldContext } from "./audit-CTIviX3P.mjs";
-import { n as createError, t as EvlogError } from "./error-C7gSQVqk.mjs";
-import { i as getEnvironment, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-DttRJRGa.mjs";
-import { m as isLevelEnabled } from "./utils-Dmin7wVL.mjs";
-import { t as useLogger } from "./useLogger-CyPP1sVB.mjs";
-import { t as parseError } from "./parseError-o1GpZEOR.mjs";
-export { AUDIT_SCHEMA_VERSION, type AuditActor, AuditDeniedError, type AuditDiffOptions, type AuditEnricherOptions, type AuditFields, type AuditInput, type AuditLoggerMethod, type AuditMatcher, type AuditMethod, type AuditOnlyOptions, type AuditPatchOp, type AuditTarget, type AuditableLogger, type BaseWideEvent, type DeepPartial, type DefinedAuditAction, type DrainContext, type DrainFn, type EnrichContext, type EnvironmentContext, type ErrorOptions, EvlogError, type FieldContext, type H3EventContext, type IngestPayload, type InternalFields, type Log, type LogLevel, type LoggerConfig, type MockAudit, type ParsedError, type RedactConfig, type RequestLogger, type RequestLoggerOptions, type SamplingConfig, type SamplingRates, type ServerEvent, type SignedChainState, type SignedOptions, type TailSamplingCondition, type TailSamplingContext, type TransportConfig, type WideEvent, type WithAuditContext, type WithAuditOptions, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, useLogger, withAudit, withAuditMethods };
+import { $ as SamplingRates, A as AuditFields, B as H3EventContext, C as buildAuditFields, D as withAudit, E as signed, F as DrainContext, G as LoggerConfig, H as InternalFields, I as EnrichContext, K as ParsedError, L as EnvironmentContext, M as AuditTarget, N as BaseWideEvent, O as withAuditMethods, P as DeepPartial, Q as SamplingConfig, R as ErrorOptions, S as auditRedactPreset, T as mockAudit, U as Log, V as IngestPayload, W as LogLevel, X as RequestLoggerOptions, Y as RequestLogger, _ as WithAuditOptions, a as AuditInput, at as ClientLogContext, b as auditEnricher, c as AuditOnlyOptions, ct as PluginSetupContext, d as DefinedAuditAction, et as ServerEvent, f as DrainFn, ft as definePlugin, g as WithAuditContext, h as SignedOptions, i as AuditEnricherOptions, it as WideEvent, j as AuditLoggerMethod, k as AuditActor, l as AuditPatchOp, lt as RequestFinishContext, m as SignedChainState, mt as enricherPlugin, n as AuditDeniedError, nt as TailSamplingContext, o as AuditMatcher, ot as EvlogPlugin, p as MockAudit, pt as drainPlugin, q as RedactConfig, r as AuditDiffOptions, rt as TransportConfig, s as AuditMethod, st as PluginRunner, t as AUDIT_SCHEMA_VERSION, tt as TailSamplingCondition, u as AuditableLogger, ut as RequestLifecycleContext, v as audit, w as defineAuditAction, x as auditOnly, y as auditDiff, z as FieldContext } from "./audit-CJl-wZ10.mjs";
+import { n as createError, t as EvlogError } from "./error-C-66_G2M.mjs";
+import { c as isEnabled, d as shouldKeep, i as getEnvironment, n as createLogger, r as createRequestLogger, s as initLogger, t as _log } from "./logger-Brt5-WMK.mjs";
+import { m as isLevelEnabled } from "./utils-gQCeZMbg.mjs";
+import { t as useLogger } from "./useLogger-Cb1R6bQE.mjs";
+import { t as parseError } from "./parseError-B1zJZvQ5.mjs";
+import { i as toMiddlewareOptions, n as defineEvlog, r as toLoggerConfig, t as EvlogConfig } from "./define-Fp8TrdEB.mjs";
+export { AUDIT_SCHEMA_VERSION, type AuditActor, AuditDeniedError, type AuditDiffOptions, type AuditEnricherOptions, type AuditFields, type AuditInput, type AuditLoggerMethod, type AuditMatcher, type AuditMethod, type AuditOnlyOptions, type AuditPatchOp, type AuditTarget, type AuditableLogger, type BaseWideEvent, type ClientLogContext, type DeepPartial, type DefinedAuditAction, type DrainContext, type DrainFn, type EnrichContext, type EnvironmentContext, type ErrorOptions, type EvlogConfig, EvlogError, type EvlogPlugin, type FieldContext, type H3EventContext, type IngestPayload, type InternalFields, type Log, type LogLevel, type LoggerConfig, type MockAudit, type ParsedError, type PluginRunner, type PluginSetupContext, type RedactConfig, type RequestFinishContext, type RequestLifecycleContext, type RequestLogger, type RequestLoggerOptions, type SamplingConfig, type SamplingRates, type ServerEvent, type SignedChainState, type SignedOptions, type TailSamplingCondition, type TailSamplingContext, type TransportConfig, type WideEvent, type WithAuditContext, type WithAuditOptions, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, defineEvlog, definePlugin, drainPlugin, enricherPlugin, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, toLoggerConfig, toMiddlewareOptions, useLogger, withAudit, withAuditMethods };

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { C as shouldKeep, _ as getEnvironment, a as auditEnricher, b as isEnabled, c as buildAuditFields, d as signed, f as withAudit, g as createRequestLogger, h as createLogger, i as auditDiff, l as defineAuditAction, m as _log, n as AuditDeniedError, o as auditOnly, p as withAuditMethods, r as audit, s as auditRedactPreset, t as AUDIT_SCHEMA_VERSION, u as mockAudit, y as initLogger } from "./audit-DQoBo7Dl.mjs";
+import { D as drainPlugin, E as definePlugin, O as enricherPlugin, _ as getEnvironment, a as auditEnricher, b as initLogger, c as buildAuditFields, d as signed, f as withAudit, g as createRequestLogger, h as createLogger, i as auditDiff, l as defineAuditAction, m as _log, n as AuditDeniedError, o as auditOnly, p as withAuditMethods, r as audit, s as auditRedactPreset, t as AUDIT_SCHEMA_VERSION, u as mockAudit, w as shouldKeep, x as isEnabled } from "./audit--n0QRR2Y.mjs";
 import { isLevelEnabled } from "./utils.mjs";
 import { EvlogError, createError } from "./error.mjs";
 import { useLogger } from "./runtime/server/useLogger.mjs";
 import { parseError } from "./runtime/utils/parseError.mjs";
-export { AUDIT_SCHEMA_VERSION, AuditDeniedError, EvlogError, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, useLogger, withAudit, withAuditMethods };
+import { n as toLoggerConfig, r as toMiddlewareOptions, t as defineEvlog } from "./define-D6OJdSUH.mjs";
+export { AUDIT_SCHEMA_VERSION, AuditDeniedError, EvlogError, audit, auditDiff, auditEnricher, auditOnly, auditRedactPreset, buildAuditFields, createError, createError as createEvlogError, createLogger, createRequestLogger, defineAuditAction, defineEvlog, definePlugin, drainPlugin, enricherPlugin, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, mockAudit, parseError, shouldKeep, signed, toLoggerConfig, toMiddlewareOptions, useLogger, withAudit, withAuditMethods };

package/dist/integration-Bz8X6_Lb.mjs

@@ -0,0 +1,75 @@
+import { n as extractSafeNodeHeaders, t as extractSafeHeaders } from "./headers-CU-QqnYg.mjs";
+import { r as createMiddlewareLogger, t as attachForkToLogger } from "./fork-D44V93-K.mjs";
+//#region src/shared/integration.ts
+function normalizeHeaders(headers) {
+	if (!headers) return void 0;
+	if (typeof headers.forEach === "function" && typeof headers.get === "function") return extractSafeHeaders(headers);
+	return extractSafeNodeHeaders(headers);
+}
+/**
+* Build a manifest-driven framework integration. Captures the boilerplate
+* every middleware shares (request extraction, logger setup, attachment,
+* optional AsyncLocalStorage wrapping). The framework still owns its own
+* middleware function — it just declares *what* to extract and *where* to
+* attach the logger.
+*
+* @example
+* ```ts
+* const integration = defineFrameworkIntegration<HonoContext>({
+*   name: 'hono',
+*   extractRequest: (c) => ({
+*     method: c.req.method,
+*     path: c.req.path,
+*     headers: c.req.raw.headers,
+*     requestId: c.req.header('x-request-id'),
+*   }),
+*   attachLogger: (c, logger) => c.set('log', logger),
+* })
+*
+* export function evlog(options?: BaseEvlogOptions): MiddlewareHandler {
+*   return async (c, next) => {
+*     const { skipped, finish, runWith } = integration.start(c, options)
+*     if (skipped) return next()
+*     try {
+*       await runWith(() => next())
+*       await finish({ status: c.res.status })
+*     } catch (error) {
+*       await finish({ error: error as Error })
+*       throw error
+*     }
+*   }
+* }
+* ```
+*/
+function defineFrameworkIntegration(spec) {
+	return { start(ctx, options = {}) {
+		const extracted = spec.extractRequest(ctx);
+		const headers = normalizeHeaders(extracted.headers);
+		const middlewareOptions = {
+			method: extracted.method,
+			path: extracted.path,
+			requestId: extracted.requestId || crypto.randomUUID(),
+			headers,
+			...options
+		};
+		const result = createMiddlewareLogger(middlewareOptions);
+		if (!result.skipped) {
+			if (spec.storage) attachForkToLogger(spec.storage, result.logger, middlewareOptions, spec.forkLifecycle);
+			spec.attachLogger(ctx, result.logger);
+		}
+		const { storage } = spec;
+		const runWith = async (fn) => {
+			if (!storage || result.skipped) return await fn();
+			return await storage.run(result.logger, fn);
+		};
+		return {
+			...result,
+			middlewareOptions,
+			runWith
+		};
+	} };
+}
+//#endregion
+export { defineFrameworkIntegration as t };
+
+//# sourceMappingURL=integration-Bz8X6_Lb.mjs.map

package/dist/integration-Bz8X6_Lb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-Bz8X6_Lb.mjs","names":[],"sources":["../src/shared/integration.ts"],"sourcesContent":["import type { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\nimport { attachForkToLogger } from './fork'\nimport { extractSafeHeaders, extractSafeNodeHeaders } from './headers'\nimport type { BaseEvlogOptions, MiddlewareLoggerOptions, MiddlewareLoggerResult } from './middleware'\nimport { createMiddlewareLogger } from './middleware'\n\n/** Request shape extracted from a framework context. */\nexport interface ExtractedRequest {\n  method: string\n  path: string\n  /**\n   * Either a Web `Headers` (Hono / Elysia / Fetch) or a Node-style\n   * `IncomingHttpHeaders` record (Express / Fastify). Whichever is native\n   * to the framework — it gets filtered through the safe-header helpers.\n   */\n  headers?: Headers | Record<string, string | string[] | undefined>\n  /** Used as-is when present, otherwise auto-generated. */\n  requestId?: string\n}\n\n/** Manifest passed to {@link defineFrameworkIntegration}. */\nexport interface FrameworkIntegrationSpec<TCtx> {\n  /** Stable identifier used in error messages. */\n  name: string\n  extractRequest: (ctx: TCtx) => ExtractedRequest\n  /** Attach the request logger to the framework context (`c.set('log', logger)`). */\n  attachLogger: (ctx: TCtx, logger: RequestLogger) => void\n  /**\n   * AsyncLocalStorage instance backing `useLogger()`. Required for frameworks\n   * where the logger is accessed off the request context (Express, Fastify,\n   * NestJS). When set, `log.fork()` is auto-attached to the request logger.\n   */\n  storage?: AsyncLocalStorage<RequestLogger>\n  /** Fork lifecycle hooks (only used when `storage` is set). */\n  forkLifecycle?: import('./fork').ForkLifecycle\n}\n\n/** Result returned by {@link FrameworkIntegrationHelpers.start}. */\nexport interface FrameworkRequestHandle extends MiddlewareLoggerResult {\n  middlewareOptions: MiddlewareLoggerOptions\n  /**\n   * Run the downstream handler inside the integration's storage. When no\n   * storage is configured, the callback is invoked directly.\n   */\n  runWith: <T>(fn: () => T | Promise<T>) => Promise<T>\n}\n\n/** Helpers returned by {@link defineFrameworkIntegration}. */\nexport interface FrameworkIntegrationHelpers<TCtx> {\n  start: (ctx: TCtx, options?: BaseEvlogOptions) => FrameworkRequestHandle\n}\n\nfunction normalizeHeaders(headers: ExtractedRequest['headers']): Record<string, string> | undefined {\n  if (!headers) return undefined\n  if (typeof (headers as Headers).forEach === 'function' && typeof (headers as Headers).get === 'function') {\n    return extractSafeHeaders(headers as Headers)\n  }\n  return extractSafeNodeHeaders(headers as Record<string, string | string[] | undefined>)\n}\n\n/**\n * Build a manifest-driven framework integration. Captures the boilerplate\n * every middleware shares (request extraction, logger setup, attachment,\n * optional AsyncLocalStorage wrapping). The framework still owns its own\n * middleware function — it just declares *what* to extract and *where* to\n * attach the logger.\n *\n * @example\n * ```ts\n * const integration = defineFrameworkIntegration<HonoContext>({\n *   name: 'hono',\n *   extractRequest: (c) => ({\n *     method: c.req.method,\n *     path: c.req.path,\n *     headers: c.req.raw.headers,\n *     requestId: c.req.header('x-request-id'),\n *   }),\n *   attachLogger: (c, logger) => c.set('log', logger),\n * })\n *\n * export function evlog(options?: BaseEvlogOptions): MiddlewareHandler {\n *   return async (c, next) => {\n *     const { skipped, finish, runWith } = integration.start(c, options)\n *     if (skipped) return next()\n *     try {\n *       await runWith(() => next())\n *       await finish({ status: c.res.status })\n *     } catch (error) {\n *       await finish({ error: error as Error })\n *       throw error\n *     }\n *   }\n * }\n * ```\n */\nexport function defineFrameworkIntegration<TCtx>(\n  spec: FrameworkIntegrationSpec<TCtx>,\n): FrameworkIntegrationHelpers<TCtx> {\n  return {\n    start(ctx, options = {}) {\n      const extracted = spec.extractRequest(ctx)\n      const headers = normalizeHeaders(extracted.headers)\n      const middlewareOptions: MiddlewareLoggerOptions = {\n        method: extracted.method,\n        path: extracted.path,\n        requestId: extracted.requestId || crypto.randomUUID(),\n        headers,\n        ...options,\n      }\n      const result = createMiddlewareLogger(middlewareOptions)\n\n      if (!result.skipped) {\n        if (spec.storage) {\n          attachForkToLogger(spec.storage, result.logger, middlewareOptions, spec.forkLifecycle)\n        }\n        spec.attachLogger(ctx, result.logger)\n      }\n\n      const { storage } = spec\n      const runWith = async <T>(fn: () => T | Promise<T>): Promise<T> => {\n        if (!storage || result.skipped) return await fn()\n        return await storage.run(result.logger, fn)\n      }\n\n      return { ...result, middlewareOptions, runWith }\n    },\n  }\n}\n"],"mappings":";;;AAqDA,SAAS,iBAAiB,SAA0E;AAClG,KAAI,CAAC,QAAS,QAAO,KAAA;AACrB,KAAI,OAAQ,QAAoB,YAAY,cAAc,OAAQ,QAAoB,QAAQ,WAC5F,QAAO,mBAAmB,QAAmB;AAE/C,QAAO,uBAAuB,QAAyD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCzF,SAAgB,2BACd,MACmC;AACnC,QAAO,EACL,MAAM,KAAK,UAAU,EAAE,EAAE;EACvB,MAAM,YAAY,KAAK,eAAe,IAAI;EAC1C,MAAM,UAAU,iBAAiB,UAAU,QAAQ;EACnD,MAAM,oBAA6C;GACjD,QAAQ,UAAU;GAClB,MAAM,UAAU;GAChB,WAAW,UAAU,aAAa,OAAO,YAAY;GACrD;GACA,GAAG;GACJ;EACD,MAAM,SAAS,uBAAuB,kBAAkB;AAExD,MAAI,CAAC,OAAO,SAAS;AACnB,OAAI,KAAK,QACP,oBAAmB,KAAK,SAAS,OAAO,QAAQ,mBAAmB,KAAK,cAAc;AAExF,QAAK,aAAa,KAAK,OAAO,OAAO;;EAGvC,MAAM,EAAE,YAAY;EACpB,MAAM,UAAU,OAAU,OAAyC;AACjE,OAAI,CAAC,WAAW,OAAO,QAAS,QAAO,MAAM,IAAI;AACjD,UAAO,MAAM,QAAQ,IAAI,OAAO,QAAQ,GAAG;;AAG7C,SAAO;GAAE,GAAG;GAAQ;GAAmB;GAAS;IAEnD"}

package/dist/{logger-DttRJRGa.d.mts → logger-Brt5-WMK.d.mts}

@@ -1,4 +1,4 @@
-import { F as DrainContext, G as LoggerConfig, L as EnvironmentContext, U as Log, X as RequestLoggerOptions, nt as TailSamplingContext, u as AuditableLogger } from "./audit-CTIviX3P.mjs";
+import { F as DrainContext, G as LoggerConfig, L as EnvironmentContext, U as Log, X as RequestLoggerOptions, nt as TailSamplingContext, st as PluginRunner, u as AuditableLogger } from "./audit-CJl-wZ10.mjs";
 
 //#region src/logger.d.ts
 /**
@@ -6,6 +6,12 @@ import { F as DrainContext, G as LoggerConfig, L as EnvironmentContext, U as Log
  * Call this once at application startup.
  */
 declare function initLogger(config?: LoggerConfig): void;
+/**
+ * @internal Get the globally registered plugin runner.
+ * Used by framework middleware so plugins also fire on routes that pre-date
+ * the middleware-level options.
+ */
+declare function getGlobalPluginRunner(): PluginRunner;
 /**
  * Check if logging is globally enabled.
  */
@@ -104,5 +110,5 @@ declare function createRequestLogger<T extends object = Record<string, unknown>>
  */
 declare function getEnvironment(): EnvironmentContext;
 //#endregion
-export { getGlobalDrain as a, isLoggerLocked as c, getEnvironment as i, lockLogger as l, createLogger as n, initLogger as o, createRequestLogger as r, isEnabled as s, _log as t, shouldKeep as u };
-//# sourceMappingURL=logger-DttRJRGa.d.mts.map
+export { getGlobalDrain as a, isEnabled as c, shouldKeep as d, getEnvironment as i, isLoggerLocked as l, createLogger as n, getGlobalPluginRunner as o, createRequestLogger as r, initLogger as s, _log as t, lockLogger as u };
+//# sourceMappingURL=logger-Brt5-WMK.d.mts.map

package/dist/logger-Brt5-WMK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-Brt5-WMK.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;AAgEA;;;;AAAA,iBAAgB,UAAA,CAAW,MAAA,GAAQ,YAAA;AAsCnC;;;;;AAAA,iBAAgB,qBAAA,CAAA,GAAyB,YAAA;;;;iBAOzB,SAAA,CAAA;AAShB;;;;;AAAA,iBAAgB,UAAA,CAAA;;;;iBAOA,cAAA,CAAA;AAShB;;;;;AAAA,iBAAgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;AA8BjE;iBAAgB,UAAA,CAAW,GAAA,EAAK,mBAAA;;;;AAgB/B;;;;;AAiYqB;cAPhB,IAAA,EAAM,GAAA;;;;UA2BF,2BAAA;EASK;;;AAkBf;EAtBE,WAAA;EAsB0B;;;EAlB1B,SAAA,IAAa,OAAA,EAAS,OAAA;AAAA;;;;;;;;;;;;;;AAgNxB;;iBA9LgB,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;;;;;;;;;;;;;;;AA6MvL;;;;;;;;;;iBAfgB,mBAAA,oBAAuC,MAAA,kBAAA,CAAyB,OAAA,GAAS,oBAAA,EAA2B,eAAA,GAAkB,2BAAA,GAA8B,eAAA,CAAgB,CAAA;;;;iBAepK,cAAA,CAAA,GAAkB,kBAAA"}

package/dist/logger.d.mts

@@ -1,2 +1,2 @@
-import { a as getGlobalDrain, c as isLoggerLocked, i as getEnvironment, l as lockLogger, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-DttRJRGa.mjs";
-export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, shouldKeep };
+import { a as getGlobalDrain, c as isEnabled, d as shouldKeep, i as getEnvironment, l as isLoggerLocked, n as createLogger, o as getGlobalPluginRunner, r as createRequestLogger, s as initLogger, t as _log, u as lockLogger } from "./logger-Brt5-WMK.mjs";
+export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, getGlobalPluginRunner, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, shouldKeep };

package/dist/logger.mjs

@@ -1,2 +1,2 @@
-import { C as shouldKeep, S as lockLogger, _ as getEnvironment, b as isEnabled, g as createRequestLogger, h as createLogger, m as _log, v as getGlobalDrain, x as isLoggerLocked, y as initLogger } from "./audit-DQoBo7Dl.mjs";
-export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, shouldKeep };
+import { C as lockLogger, S as isLoggerLocked, _ as getEnvironment, b as initLogger, g as createRequestLogger, h as createLogger, m as _log, v as getGlobalDrain, w as shouldKeep, x as isEnabled, y as getGlobalPluginRunner } from "./audit--n0QRR2Y.mjs";
+export { createLogger, createRequestLogger, getEnvironment, getGlobalDrain, getGlobalPluginRunner, initLogger, isEnabled, isLoggerLocked, lockLogger, _log as log, shouldKeep };

package/dist/middleware-CGM-bOvE.d.mts

@@ -0,0 +1,72 @@
+import { F as DrainContext, I as EnrichContext, Y as RequestLogger, Z as RouteConfig, it as WideEvent, nt as TailSamplingContext, ot as EvlogPlugin, q as RedactConfig, st as PluginRunner } from "./audit-CJl-wZ10.mjs";
+
+//#region src/shared/middleware.d.ts
+/**
+ * Base options shared by every framework integration. Re-exported via
+ * `evlog/toolkit` so custom integrations can extend it.
+ */
+interface BaseEvlogOptions {
+  /** Route glob patterns to include. If unset, all routes are logged. */
+  include?: string[];
+  /** Route glob patterns to exclude. Takes precedence over `include`. */
+  exclude?: string[];
+  /** Per-route service overrides. */
+  routes?: Record<string, RouteConfig>;
+  /** Drain callback invoked with every emitted event. */
+  drain?: (ctx: DrainContext) => void | Promise<void>;
+  /** Enrich callback invoked after emit, before drain. */
+  enrich?: (ctx: EnrichContext) => void | Promise<void>;
+  /** Tail sampling callback. Set `ctx.shouldKeep = true` to force-keep. */
+  keep?: (ctx: TailSamplingContext) => void | Promise<void>;
+  /**
+   * PII auto-redaction. `true` enables built-in patterns; pass an object for
+   * fine-grained control. Applied before enrich/drain.
+   */
+  redact?: boolean | RedactConfig;
+  /** Plugins for this middleware, merged with globally-registered ones. */
+  plugins?: EvlogPlugin[];
+}
+/** Internal options accepted by `createMiddlewareLogger`. */
+interface MiddlewareLoggerOptions extends BaseEvlogOptions {
+  method: string;
+  path: string;
+  requestId?: string;
+  /** Pre-filtered safe request headers used for enrich/drain context. */
+  headers?: Record<string, string>;
+}
+interface MiddlewareLoggerResult {
+  logger: RequestLogger;
+  finish: (opts?: {
+    status?: number;
+    error?: Error;
+  }) => Promise<WideEvent | null>;
+  skipped: boolean;
+}
+/**
+ * Resolve the plugin runner for a middleware invocation by merging local
+ * plugins with the globally-registered ones (deduplicated by `name`).
+ */
+declare function resolveMiddlewarePluginRunner(options: {
+  plugins?: EvlogPlugin[];
+}): PluginRunner;
+/**
+ * Apply redact, enrich, and drain to an emitted wide event — the same
+ * pipeline used by {@link createMiddlewareLogger}'s `finish`.
+ */
+declare function runEnrichAndDrain(emittedEvent: WideEvent, options: MiddlewareLoggerOptions, requestInfo: {
+  method: string;
+  path: string;
+  requestId?: string;
+}, responseStatus?: number, plugins?: PluginRunner): Promise<void>;
+/**
+ * Create a request logger with the full middleware pipeline: route filtering,
+ * service overrides, duration tracking, tail sampling, emit, enrich, drain.
+ *
+ * Framework adapters extract method/path/requestId/headers, call this once
+ * per request, and call `finish({ status | error })` when the response ends.
+ * If `skipped` is `true`, the route was filtered out — bypass logging.
+ */
+declare function createMiddlewareLogger(options: MiddlewareLoggerOptions): MiddlewareLoggerResult;
+//#endregion
+export { resolveMiddlewarePluginRunner as a, createMiddlewareLogger as i, MiddlewareLoggerOptions as n, runEnrichAndDrain as o, MiddlewareLoggerResult as r, BaseEvlogOptions as t };
+//# sourceMappingURL=middleware-CGM-bOvE.d.mts.map

package/dist/middleware-CGM-bOvE.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-CGM-bOvE.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;AAYA;;;UAAiB,gBAAA;EAMN;EAJT,OAAA;EAMsC;EAJtC,OAAA;EAMwC;EAJxC,MAAA,GAAS,MAAA,SAAe,WAAA;EAMoB;EAJ5C,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAW5B;EATV,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EASnB;EAPrB,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;EAR5C;;;;EAaA,MAAA,aAAmB,YAAA;EATL;EAWd,OAAA,GAAU,WAAA;AAAA;;UAIK,uBAAA,SAAgC,gBAAA;EAC/C,MAAA;EACA,IAAA;EACA,SAAA;EAda;EAgBb,OAAA,GAAU,MAAA;AAAA;AAAA,UAGK,sBAAA;EACf,MAAA,EAAQ,aAAA;EACR,MAAA,GAAS,IAAA;IAAS,MAAA;IAAiB,KAAA,GAAQ,KAAA;EAAA,MAAY,OAAA,CAAQ,SAAA;EAC/D,OAAA;AAAA;;;;;iBA6Bc,6BAAA,CAA8B,OAAA;EAAW,OAAA,GAAU,WAAA;AAAA,IAAkB,YAAA;;;;AAhCrF;iBAuDsB,iBAAA,CACpB,YAAA,EAAc,SAAA,EACd,OAAA,EAAS,uBAAA,EACT,WAAA;EAAe,MAAA;EAAgB,IAAA;EAAc,SAAA;AAAA,GAC7C,cAAA,WACA,OAAA,GAAU,YAAA,GACT,OAAA;;;;;;;;;iBA8Da,sBAAA,CAAuB,OAAA,EAAS,uBAAA,GAA0B,sBAAA"}