evlog 2.1.0 → 2.3.0

package/dist/elysia/index.d.mts

@@ -0,0 +1,75 @@
+import { DrainContext, EnrichContext, RequestLogger, RouteConfig, TailSamplingContext } from "../types.mjs";
+import { Elysia } from "elysia";
+
+//#region src/elysia/index.d.ts
+interface EvlogElysiaOptions {
+  /** Route patterns to include in logging (glob). If not set, all routes are logged */
+  include?: string[];
+  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */
+  exclude?: string[];
+  /** Route-specific service configuration */
+  routes?: Record<string, RouteConfig>;
+  /**
+   * Drain callback called with every emitted event.
+   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.
+   */
+  drain?: (ctx: DrainContext) => void | Promise<void>;
+  /**
+   * Enrich callback called after emit, before drain.
+   * Use to add derived context (geo, deployment info, user agent, etc.).
+   */
+  enrich?: (ctx: EnrichContext) => void | Promise<void>;
+  /**
+   * Custom tail sampling callback.
+   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.
+   */
+  keep?: (ctx: TailSamplingContext) => void | Promise<void>;
+}
+/**
+ * Get the request-scoped logger from anywhere in the call stack.
+ * Must be called inside a request handled by the `evlog()` plugin.
+ *
+ * @example
+ * ```ts
+ * import { useLogger } from 'evlog/elysia'
+ *
+ * function findUser(id: string) {
+ *   const log = useLogger()
+ *   log.set({ user: { id } })
+ * }
+ * ```
+ */
+declare function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T>;
+declare function evlog(options?: EvlogElysiaOptions): Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {
+    readonly log: RequestLogger<Record<string, unknown>>;
+  };
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}>;
+//#endregion
+export { EvlogElysiaOptions, evlog, useLogger };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/elysia/index.ts"],"mappings":";;;;UAQiB,kBAAA;;EAEf,OAAA;EAFiC;EAIjC,OAAA;EAEwB;EAAxB,MAAA,GAAS,MAAA,SAAe,WAAA;EAKV;;;;EAAd,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAUM;;;;EAL5C,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAVxC;;;;EAeA,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;AAAA;;;;;;;;;;;;AAiB9C;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;AAAA,iBAuCvE,KAAA,CAAM,OAAA,GAAS,kBAAA,GAAuB,MAAA"}

package/dist/elysia/index.mjs

@@ -0,0 +1,62 @@
+import { r as createMiddlewareLogger, t as extractSafeHeaders } from "../headers-CXOd5EyZ.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Elysia } from "elysia";
+
+//#region src/elysia/index.ts
+const storage = new AsyncLocalStorage();
+/**
+* Get the request-scoped logger from anywhere in the call stack.
+* Must be called inside a request handled by the `evlog()` plugin.
+*
+* @example
+* ```ts
+* import { useLogger } from 'evlog/elysia'
+*
+* function findUser(id: string) {
+*   const log = useLogger()
+*   log.set({ user: { id } })
+* }
+* ```
+*/
+function useLogger() {
+	const logger = storage.getStore();
+	if (!logger) throw new Error("[evlog] useLogger() was called outside of an evlog plugin context. Make sure app.use(evlog()) is registered before your routes.");
+	return logger;
+}
+function evlog(options = {}) {
+	const emitted = /* @__PURE__ */ new WeakSet();
+	const requestState = /* @__PURE__ */ new WeakMap();
+	return new Elysia({ name: "evlog" }).derive({ as: "global" }, ({ request }) => {
+		const url = new URL(request.url);
+		const { logger, finish, skipped } = createMiddlewareLogger({
+			method: request.method,
+			path: url.pathname,
+			requestId: request.headers.get("x-request-id") || crypto.randomUUID(),
+			headers: extractSafeHeaders(request.headers),
+			...options
+		});
+		storage.enterWith(logger);
+		requestState.set(request, {
+			finish,
+			skipped
+		});
+		return { log: logger };
+	}).onAfterHandle({ as: "global" }, async ({ request, set }) => {
+		const state = requestState.get(request);
+		if (!state || state.skipped || emitted.has(request)) return;
+		emitted.add(request);
+		await state.finish({ status: set.status || 200 });
+	}).onError({ as: "global" }, async ({ request, error }) => {
+		const state = requestState.get(request);
+		if (!state || state.skipped || emitted.has(request)) return;
+		emitted.add(request);
+		const logger = storage.getStore();
+		const err = error instanceof Error ? error : new Error(String(error));
+		if (logger) logger.error(err);
+		await state.finish({ error: err });
+	});
+}
+
+//#endregion
+export { evlog, useLogger };
+//# sourceMappingURL=index.mjs.map

package/dist/elysia/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/elysia/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport { Elysia } from 'elysia'\nimport type { DrainContext, EnrichContext, RequestLogger, RouteConfig, TailSamplingContext } from '../types'\nimport { createMiddlewareLogger } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\n\nconst storage = new AsyncLocalStorage<RequestLogger>()\n\nexport interface EvlogElysiaOptions {\n  /** Route patterns to include in logging (glob). If not set, all routes are logged */\n  include?: string[]\n  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */\n  exclude?: string[]\n  /** Route-specific service configuration */\n  routes?: Record<string, RouteConfig>\n  /**\n   * Drain callback called with every emitted event.\n   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.\n   */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /**\n   * Enrich callback called after emit, before drain.\n   * Use to add derived context (geo, deployment info, user agent, etc.).\n   */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\n  /**\n   * Custom tail sampling callback.\n   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.\n   */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n}\n\n/**\n * Get the request-scoped logger from anywhere in the call stack.\n * Must be called inside a request handled by the `evlog()` plugin.\n *\n * @example\n * ```ts\n * import { useLogger } from 'evlog/elysia'\n *\n * function findUser(id: string) {\n *   const log = useLogger()\n *   log.set({ user: { id } })\n * }\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = storage.getStore()\n  if (!logger) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of an evlog plugin context. '\n      + 'Make sure app.use(evlog()) is registered before your routes.',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n\n/**\n * Create an evlog plugin for Elysia.\n *\n * @example\n * ```ts\n * import { Elysia } from 'elysia'\n * import { evlog } from 'evlog/elysia'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = new Elysia()\n *   .use(evlog({\n *     drain: createAxiomDrain(),\n *     enrich: (ctx) => {\n *       ctx.event.region = process.env.FLY_REGION\n *     },\n *   }))\n *   .get('/health', ({ log }) => {\n *     log.set({ route: 'health' })\n *     return { ok: true }\n *   })\n *   .listen(3000)\n * ```\n */\ninterface RequestState {\n  finish: (opts?: { status?: number; error?: Error }) => Promise<unknown>\n  skipped: boolean\n}\n\nexport function evlog(options: EvlogElysiaOptions = {}) {\n  const emitted = new WeakSet<Request>()\n  const requestState = new WeakMap<Request, RequestState>()\n\n  return new Elysia({ name: 'evlog' })\n    .derive({ as: 'global' }, ({ request }) => {\n      const url = new URL(request.url)\n\n      const { logger, finish, skipped } = createMiddlewareLogger({\n        method: request.method,\n        path: url.pathname,\n        requestId: request.headers.get('x-request-id') || crypto.randomUUID(),\n        headers: extractSafeHeaders(request.headers),\n        ...options,\n      })\n\n      storage.enterWith(logger)\n      requestState.set(request, { finish, skipped })\n\n      return { log: logger }\n    })\n    .onAfterHandle({ as: 'global' }, async ({ request, set }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      await state.finish({ status: set.status as number || 200 })\n    })\n    .onError({ as: 'global' }, async ({ request, error }) => {\n      const state = requestState.get(request)\n      if (!state || state.skipped || emitted.has(request)) return\n      emitted.add(request)\n      const logger = storage.getStore()\n      const err = error instanceof Error ? error : new Error(String(error))\n      if (logger) logger.error(err)\n      await state.finish({ error: err })\n    })\n}\n"],"mappings":";;;;;AAMA,MAAM,UAAU,IAAI,mBAAkC;;;;;;;;;;;;;;;AAwCtD,SAAgB,YAA0E;CACxF,MAAM,SAAS,QAAQ,UAAU;AACjC,KAAI,CAAC,OACH,OAAM,IAAI,MACR,kIAED;AAEH,QAAO;;AA+BT,SAAgB,MAAM,UAA8B,EAAE,EAAE;CACtD,MAAM,0BAAU,IAAI,SAAkB;CACtC,MAAM,+BAAe,IAAI,SAAgC;AAEzD,QAAO,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC,CACjC,OAAO,EAAE,IAAI,UAAU,GAAG,EAAE,cAAc;EACzC,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;EAEhC,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,QAAQ;GAChB,MAAM,IAAI;GACV,WAAW,QAAQ,QAAQ,IAAI,eAAe,IAAI,OAAO,YAAY;GACrE,SAAS,mBAAmB,QAAQ,QAAQ;GAC5C,GAAG;GACJ,CAAC;AAEF,UAAQ,UAAU,OAAO;AACzB,eAAa,IAAI,SAAS;GAAE;GAAQ;GAAS,CAAC;AAE9C,SAAO,EAAE,KAAK,QAAQ;GACtB,CACD,cAAc,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,UAAU;EAC3D,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;AACpB,QAAM,MAAM,OAAO,EAAE,QAAQ,IAAI,UAAoB,KAAK,CAAC;GAC3D,CACD,QAAQ,EAAE,IAAI,UAAU,EAAE,OAAO,EAAE,SAAS,YAAY;EACvD,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,MAAM,WAAW,QAAQ,IAAI,QAAQ,CAAE;AACrD,UAAQ,IAAI,QAAQ;EACpB,MAAM,SAAS,QAAQ,UAAU;EACjC,MAAM,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,MAAI,OAAQ,QAAO,MAAM,IAAI;AAC7B,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;GAClC"}

package/dist/express/index.d.mts

@@ -0,0 +1,69 @@
+import { DrainContext, EnrichContext, RequestLogger, RouteConfig, TailSamplingContext } from "../types.mjs";
+import { RequestHandler } from "express";
+
+//#region src/express/index.d.ts
+interface EvlogExpressOptions {
+  /** Route patterns to include in logging (glob). If not set, all routes are logged */
+  include?: string[];
+  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */
+  exclude?: string[];
+  /** Route-specific service configuration */
+  routes?: Record<string, RouteConfig>;
+  /**
+   * Drain callback called with every emitted event.
+   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.
+   */
+  drain?: (ctx: DrainContext) => void | Promise<void>;
+  /**
+   * Enrich callback called after emit, before drain.
+   * Use to add derived context (geo, deployment info, user agent, etc.).
+   */
+  enrich?: (ctx: EnrichContext) => void | Promise<void>;
+  /**
+   * Custom tail sampling callback.
+   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.
+   */
+  keep?: (ctx: TailSamplingContext) => void | Promise<void>;
+}
+declare module 'express-serve-static-core' {
+  interface Request {
+    log: RequestLogger;
+  }
+}
+/**
+ * Get the request-scoped logger from anywhere in the call stack.
+ * Must be called inside a request handled by the `evlog()` middleware.
+ *
+ * @example
+ * ```ts
+ * import { useLogger } from 'evlog/express'
+ *
+ * function findUser(id: string) {
+ *   const log = useLogger()
+ *   log.set({ user: { id } })
+ * }
+ * ```
+ */
+declare function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T>;
+/**
+ * Create an evlog middleware for Express.
+ *
+ * @example
+ * ```ts
+ * import express from 'express'
+ * import { evlog } from 'evlog/express'
+ * import { createAxiomDrain } from 'evlog/axiom'
+ *
+ * const app = express()
+ * app.use(evlog({
+ *   drain: createAxiomDrain(),
+ *   enrich: (ctx) => {
+ *     ctx.event.region = process.env.FLY_REGION
+ *   },
+ * }))
+ * ```
+ */
+declare function evlog(options?: EvlogExpressOptions): RequestHandler;
+//#endregion
+export { EvlogExpressOptions, evlog, useLogger };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/express/index.ts"],"mappings":";;;;UAQiB,mBAAA;;EAEf,OAAA;EAFkC;EAIlC,OAAA;EAEwB;EAAxB,MAAA,GAAS,MAAA,SAAe,WAAA;EAKV;;;;EAAd,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAUM;;;;EAL5C,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAVxC;;;;EAeA,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;AAAA;AAAA;EAAA,UAIlC,OAAA;IACR,GAAA,EAAK,aAAA;EAAA;AAAA;;;;;;;AAJR;;;;;;;;iBAsBe,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;;AAAvF;;;;;;;;;;;;;;AA6BA;;;iBAAgB,KAAA,CAAM,OAAA,GAAS,mBAAA,GAA2B,cAAA"}

package/dist/express/index.mjs

@@ -0,0 +1,66 @@
+import { n as extractSafeNodeHeaders, r as createMiddlewareLogger } from "../headers-CXOd5EyZ.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/express/index.ts
+const storage = new AsyncLocalStorage();
+/**
+* Get the request-scoped logger from anywhere in the call stack.
+* Must be called inside a request handled by the `evlog()` middleware.
+*
+* @example
+* ```ts
+* import { useLogger } from 'evlog/express'
+*
+* function findUser(id: string) {
+*   const log = useLogger()
+*   log.set({ user: { id } })
+* }
+* ```
+*/
+function useLogger() {
+	const logger = storage.getStore();
+	if (!logger) throw new Error("[evlog] useLogger() was called outside of an evlog middleware context. Make sure app.use(evlog()) is registered before your routes.");
+	return logger;
+}
+/**
+* Create an evlog middleware for Express.
+*
+* @example
+* ```ts
+* import express from 'express'
+* import { evlog } from 'evlog/express'
+* import { createAxiomDrain } from 'evlog/axiom'
+*
+* const app = express()
+* app.use(evlog({
+*   drain: createAxiomDrain(),
+*   enrich: (ctx) => {
+*     ctx.event.region = process.env.FLY_REGION
+*   },
+* }))
+* ```
+*/
+function evlog(options = {}) {
+	return (req, res, next) => {
+		const { logger, finish, skipped } = createMiddlewareLogger({
+			method: req.method,
+			path: req.path,
+			requestId: req.get("x-request-id") || crypto.randomUUID(),
+			headers: extractSafeNodeHeaders(req.headers),
+			...options
+		});
+		if (skipped) {
+			next();
+			return;
+		}
+		req.log = logger;
+		res.on("finish", () => {
+			finish({ status: res.statusCode }).catch(() => {});
+		});
+		storage.run(logger, () => next());
+	};
+}
+
+//#endregion
+export { evlog, useLogger };
+//# sourceMappingURL=index.mjs.map

package/dist/express/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/express/index.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { Request, Response, NextFunction, RequestHandler } from 'express'\nimport type { DrainContext, EnrichContext, RequestLogger, RouteConfig, TailSamplingContext } from '../types'\nimport { createMiddlewareLogger } from '../shared/middleware'\nimport { extractSafeNodeHeaders } from '../shared/headers'\n\nconst storage = new AsyncLocalStorage<RequestLogger>()\n\nexport interface EvlogExpressOptions {\n  /** Route patterns to include in logging (glob). If not set, all routes are logged */\n  include?: string[]\n  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */\n  exclude?: string[]\n  /** Route-specific service configuration */\n  routes?: Record<string, RouteConfig>\n  /**\n   * Drain callback called with every emitted event.\n   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.\n   */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /**\n   * Enrich callback called after emit, before drain.\n   * Use to add derived context (geo, deployment info, user agent, etc.).\n   */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\n  /**\n   * Custom tail sampling callback.\n   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.\n   */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n}\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log: RequestLogger\n  }\n}\n\n/**\n * Get the request-scoped logger from anywhere in the call stack.\n * Must be called inside a request handled by the `evlog()` middleware.\n *\n * @example\n * ```ts\n * import { useLogger } from 'evlog/express'\n *\n * function findUser(id: string) {\n *   const log = useLogger()\n *   log.set({ user: { id } })\n * }\n * ```\n */\nexport function useLogger<T extends object = Record<string, unknown>>(): RequestLogger<T> {\n  const logger = storage.getStore()\n  if (!logger) {\n    throw new Error(\n      '[evlog] useLogger() was called outside of an evlog middleware context. '\n      + 'Make sure app.use(evlog()) is registered before your routes.',\n    )\n  }\n  return logger as RequestLogger<T>\n}\n\n/**\n * Create an evlog middleware for Express.\n *\n * @example\n * ```ts\n * import express from 'express'\n * import { evlog } from 'evlog/express'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * const app = express()\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: EvlogExpressOptions = {}): RequestHandler {\n  return (req: Request, res: Response, next: NextFunction) => {\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: req.method,\n      path: req.path,\n      requestId: req.get('x-request-id') || crypto.randomUUID(),\n      headers: extractSafeNodeHeaders(req.headers),\n      ...options,\n    })\n\n    if (skipped) {\n      next()\n      return\n    }\n\n    req.log = logger\n\n    res.on('finish', () => {\n      finish({ status: res.statusCode }).catch(() => {})\n    })\n\n    storage.run(logger, () => next())\n  }\n}\n"],"mappings":";;;;AAMA,MAAM,UAAU,IAAI,mBAAkC;;;;;;;;;;;;;;;AA8CtD,SAAgB,YAA0E;CACxF,MAAM,SAAS,QAAQ,UAAU;AACjC,KAAI,CAAC,OACH,OAAM,IAAI,MACR,sIAED;AAEH,QAAO;;;;;;;;;;;;;;;;;;;;AAqBT,SAAgB,MAAM,UAA+B,EAAE,EAAkB;AACvE,SAAQ,KAAc,KAAe,SAAuB;EAC1D,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,IAAI;GACZ,MAAM,IAAI;GACV,WAAW,IAAI,IAAI,eAAe,IAAI,OAAO,YAAY;GACzD,SAAS,uBAAuB,IAAI,QAAQ;GAC5C,GAAG;GACJ,CAAC;AAEF,MAAI,SAAS;AACX,SAAM;AACN;;AAGF,MAAI,MAAM;AAEV,MAAI,GAAG,gBAAgB;AACrB,UAAO,EAAE,QAAQ,IAAI,YAAY,CAAC,CAAC,YAAY,GAAG;IAClD;AAEF,UAAQ,IAAI,cAAc,MAAM,CAAC"}

package/dist/headers-CXOd5EyZ.mjs

@@ -0,0 +1,141 @@
+import { filterSafeHeaders } from "./utils.mjs";
+import { createRequestLogger, isEnabled, shouldKeep } from "./logger.mjs";
+import { n as shouldLog, t as getServiceForPath } from "./routes-BNbrnm14.mjs";
+import { t as extractErrorStatus } from "./nitro-Da8tEfJ3.mjs";
+
+//#region src/shared/middleware.ts
+const noopResult = {
+	logger: {
+		set() {},
+		error() {},
+		info() {},
+		warn() {},
+		emit() {
+			return null;
+		},
+		getContext() {
+			return {};
+		}
+	},
+	finish: () => Promise.resolve(null),
+	skipped: true
+};
+async function runEnrichAndDrain(emittedEvent, options, requestInfo, responseStatus) {
+	if (options.enrich) {
+		const enrichCtx = {
+			event: emittedEvent,
+			request: requestInfo,
+			headers: options.headers,
+			response: { status: responseStatus }
+		};
+		try {
+			await options.enrich(enrichCtx);
+		} catch (err) {
+			console.error("[evlog] enrich failed:", err);
+		}
+	}
+	if (options.drain) {
+		const drainCtx = {
+			event: emittedEvent,
+			request: requestInfo,
+			headers: options.headers
+		};
+		try {
+			await options.drain(drainCtx);
+		} catch (err) {
+			console.error("[evlog] drain failed:", err);
+		}
+	}
+}
+/**
+* Create a middleware-aware request logger with full lifecycle management.
+*
+* Handles the complete pipeline shared across all framework integrations:
+* route filtering, logger creation, service overrides, duration tracking,
+* tail sampling evaluation, event emission, enrichment, and draining.
+*
+* Framework adapters only need to:
+* 1. Extract method/path/requestId/headers from the framework request
+* 2. Call `createMiddlewareLogger()` with those + user options
+* 3. Check `skipped` — if true, skip to next middleware
+* 4. Store `logger` in framework-specific context (e.g., `c.set('log', logger)`)
+* 5. Call `finish({ status })` or `finish({ error })` at response end
+*/
+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
+	});
+	const routeService = getServiceForPath(path, routes);
+	if (routeService) logger.set({ service: routeService });
+	const startTime = Date.now();
+	const requestInfo = {
+		method,
+		path,
+		requestId: resolvedRequestId
+	};
+	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);
+		const forceKeep = tailCtx.shouldKeep || shouldKeep(tailCtx);
+		const emittedEvent = logger.emit({ _forceKeep: forceKeep });
+		if (emittedEvent && (options.enrich || options.drain)) await runEnrichAndDrain(emittedEvent, options, requestInfo, resolvedStatus);
+		return emittedEvent;
+	};
+	return {
+		logger,
+		finish,
+		skipped: false
+	};
+}
+
+//#endregion
+//#region src/shared/headers.ts
+/**
+* Extract headers from a Web API `Headers` object and filter out sensitive ones.
+* Works with any runtime that supports the standard `Headers` API (Hono, Elysia,
+* Nitro v3, Cloudflare Workers, Bun, Deno, etc.).
+*/
+function extractSafeHeaders(headers) {
+	const raw = {};
+	headers.forEach((value, key) => {
+		raw[key] = value;
+	});
+	return filterSafeHeaders(raw);
+}
+/**
+* Extract headers from Node.js `IncomingHttpHeaders` and filter out sensitive ones.
+* Works with Express, Fastify, and any Node.js HTTP server using `req.headers`.
+*/
+function extractSafeNodeHeaders(headers) {
+	const raw = {};
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === void 0) continue;
+		raw[key] = Array.isArray(value) ? value.join(", ") : value;
+	}
+	return filterSafeHeaders(raw);
+}
+
+//#endregion
+export { extractSafeNodeHeaders as n, createMiddlewareLogger as r, extractSafeHeaders as t };
+//# sourceMappingURL=headers-CXOd5EyZ.mjs.map

package/dist/headers-CXOd5EyZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers-CXOd5EyZ.mjs","names":[],"sources":["../src/shared/middleware.ts","../src/shared/headers.ts"],"sourcesContent":["import type { DrainContext, EnrichContext, RequestLogger, RouteConfig, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, isEnabled, shouldKeep } from '../logger'\nimport { extractErrorStatus } from '../nitro'\nimport { shouldLog, getServiceForPath } from './routes'\n\n/**\n * Base options shared by all framework integrations.\n * Each framework adapter spreads its user-facing options into this.\n */\nexport interface MiddlewareLoggerOptions {\n  method: string\n  path: string\n  requestId?: string\n  include?: string[]\n  exclude?: string[]\n  routes?: Record<string, RouteConfig>\n  /** Tail sampling callback — set `ctx.shouldKeep = true` to force-keep */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n  /** Drain callback — send events to external services */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /** Enrich callback — add derived context after emit, before drain */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\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\nasync function runEnrichAndDrain(\n  emittedEvent: WideEvent,\n  options: MiddlewareLoggerOptions,\n  requestInfo: { method: string; path: string; requestId?: string },\n  responseStatus?: number,\n): Promise<void> {\n  if (options.enrich) {\n    const enrichCtx: EnrichContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n      response: { status: responseStatus },\n    }\n    try {\n      await options.enrich(enrichCtx)\n    } catch (err) {\n      console.error('[evlog] enrich failed:', err)\n    }\n  }\n\n  if (options.drain) {\n    const drainCtx: DrainContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n    }\n    try {\n      await options.drain(drainCtx)\n    } catch (err) {\n      console.error('[evlog] drain failed:', err)\n    }\n  }\n}\n\n/**\n * Create a middleware-aware request logger with full lifecycle management.\n *\n * Handles the complete pipeline shared across all framework integrations:\n * route filtering, logger creation, service overrides, duration tracking,\n * tail sampling evaluation, event emission, enrichment, and draining.\n *\n * Framework adapters only need to:\n * 1. Extract method/path/requestId/headers from the framework request\n * 2. Call `createMiddlewareLogger()` with those + user options\n * 3. Check `skipped` — if true, skip to next middleware\n * 4. Store `logger` in framework-specific context (e.g., `c.set('log', logger)`)\n * 5. Call `finish({ status })` or `finish({ error })` at response end\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  })\n\n  const routeService = getServiceForPath(path, routes)\n  if (routeService) {\n    logger.set({ service: routeService })\n  }\n\n  const startTime = Date.now()\n  const requestInfo = { method, path, requestId: resolvedRequestId }\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\n    const forceKeep = tailCtx.shouldKeep || shouldKeep(tailCtx)\n    const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n\n    if (emittedEvent && (options.enrich || options.drain)) {\n      await runEnrichAndDrain(emittedEvent, options, requestInfo, resolvedStatus)\n    }\n\n    return emittedEvent\n  }\n\n  return { logger, finish, skipped: false }\n}\n","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"],"mappings":";;;;;;AAgCA,MAAM,aAAqC;CACzC,QAAQ;EACN,MAAM;EACN,QAAQ;EACR,OAAO;EACP,OAAO;EACP,OAAO;AACL,UAAO;;EAET,aAAa;AACX,UAAO,EAAE;;EAEZ;CACD,cAAc,QAAQ,QAAQ,KAAK;CACnC,SAAS;CACV;AAED,eAAe,kBACb,cACA,SACA,aACA,gBACe;AACf,KAAI,QAAQ,QAAQ;EAClB,MAAM,YAA2B;GAC/B,OAAO;GACP,SAAS;GACT,SAAS,QAAQ;GACjB,UAAU,EAAE,QAAQ,gBAAgB;GACrC;AACD,MAAI;AACF,SAAM,QAAQ,OAAO,UAAU;WACxB,KAAK;AACZ,WAAQ,MAAM,0BAA0B,IAAI;;;AAIhD,KAAI,QAAQ,OAAO;EACjB,MAAM,WAAyB;GAC7B,OAAO;GACP,SAAS;GACT,SAAS,QAAQ;GAClB;AACD,MAAI;AACF,SAAM,QAAQ,MAAM,SAAS;WACtB,KAAK;AACZ,WAAQ,MAAM,yBAAyB,IAAI;;;;;;;;;;;;;;;;;;AAmBjD,SAAgB,uBAAuB,SAA0D;AAC/F,KAAI,CAAC,WAAW,CAAE,QAAO;CAEzB,MAAM,EAAE,QAAQ,MAAM,WAAW,SAAS,SAAS,QAAQ,SAAS;AAEpE,KAAI,CAAC,UAAU,MAAM,SAAS,QAAQ,CACpC,QAAO;CAGT,MAAM,oBAAoB,aAAa,OAAO,YAAY;CAE1D,MAAM,SAAS,oBAAoB;EACjC;EACA;EACA,WAAW;EACZ,CAAC;CAEF,MAAM,eAAe,kBAAkB,MAAM,OAAO;AACpD,KAAI,aACF,QAAO,IAAI,EAAE,SAAS,cAAc,CAAC;CAGvC,MAAM,YAAY,KAAK,KAAK;CAC5B,MAAM,cAAc;EAAE;EAAQ;EAAM,WAAW;EAAmB;CAElE,MAAM,SAAS,OAAO,SAAyE;EAC7F,MAAM,EAAE,QAAQ,UAAU,QAAQ,EAAE;AAEpC,MAAI,OAAO;AACT,UAAO,MAAM,MAAM;GACnB,MAAM,cAAc,mBAAmB,MAAM;AAC7C,UAAO,IAAI,EAAE,QAAQ,aAAa,CAAC;aAC1B,WAAW,OACpB,QAAO,IAAI,EAAE,QAAQ,CAAC;EAGxB,MAAM,aAAa,KAAK,KAAK,GAAG;EAEhC,MAAM,iBAAiB,QACnB,mBAAmB,MAAM,GACzB,UAAW,OAAO,YAAY,CAAC;EAEnC,MAAM,UAA+B;GACnC,QAAQ;GACR,UAAU;GACV;GACA;GACA,SAAS,OAAO,YAAY;GAC5B,YAAY;GACb;AAED,MAAI,KACF,OAAM,KAAK,QAAQ;EAGrB,MAAM,YAAY,QAAQ,cAAc,WAAW,QAAQ;EAC3D,MAAM,eAAe,OAAO,KAAK,EAAE,YAAY,WAAW,CAAC;AAE3D,MAAI,iBAAiB,QAAQ,UAAU,QAAQ,OAC7C,OAAM,kBAAkB,cAAc,SAAS,aAAa,eAAe;AAG7E,SAAO;;AAGT,QAAO;EAAE;EAAQ;EAAQ,SAAS;EAAO;;;;;;;;;;AC3J3C,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,OAAW;AACzB,MAAI,OAAO,MAAM,QAAQ,MAAM,GAAG,MAAM,KAAK,KAAK,GAAG;;AAEvD,QAAO,kBAAkB,IAAI"}

package/dist/hono/index.d.mts

@@ -0,0 +1,68 @@
+import { DrainContext, EnrichContext, RequestLogger, RouteConfig, TailSamplingContext } from "../types.mjs";
+import { MiddlewareHandler } from "hono";
+
+//#region src/hono/index.d.ts
+interface EvlogHonoOptions {
+  /** Route patterns to include in logging (glob). If not set, all routes are logged */
+  include?: string[];
+  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */
+  exclude?: string[];
+  /** Route-specific service configuration */
+  routes?: Record<string, RouteConfig>;
+  /**
+   * Drain callback called with every emitted event.
+   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.
+   */
+  drain?: (ctx: DrainContext) => void | Promise<void>;
+  /**
+   * Enrich callback called after emit, before drain.
+   * Use to add derived context (geo, deployment info, user agent, etc.).
+   */
+  enrich?: (ctx: EnrichContext) => void | Promise<void>;
+  /**
+   * Custom tail sampling callback.
+   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.
+   */
+  keep?: (ctx: TailSamplingContext) => void | Promise<void>;
+}
+/**
+ * Hono variables type for typed `c.get('log')` access.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono<EvlogVariables>()
+ * app.use(evlog())
+ * app.get('/api/users', (c) => {
+ *   const log = c.get('log')
+ *   log.set({ users: { count: 42 } })
+ *   return c.json({ users: [] })
+ * })
+ * ```
+ */
+type EvlogVariables = {
+  Variables: {
+    log: RequestLogger;
+  };
+};
+/**
+ * Create an evlog middleware for Hono.
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { evlog, type EvlogVariables } from 'evlog/hono'
+ * import { createAxiomDrain } from 'evlog/axiom'
+ *
+ * const app = new Hono<EvlogVariables>()
+ * app.use(evlog({
+ *   drain: createAxiomDrain(),
+ *   enrich: (ctx) => {
+ *     ctx.event.region = process.env.FLY_REGION
+ *   },
+ * }))
+ * ```
+ */
+declare function evlog(options?: EvlogHonoOptions): MiddlewareHandler;
+//#endregion
+export { EvlogHonoOptions, EvlogVariables, evlog };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/hono/index.ts"],"mappings":";;;;UAKiB,gBAAA;;EAEf,OAAA;EAF+B;EAI/B,OAAA;EAEwB;EAAxB,MAAA,GAAS,MAAA,SAAe,WAAA;EAKV;;;;EAAd,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAUM;;;;EAL5C,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAVxC;;;;EAeA,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;AAAA;;;;;;;;;;;;AAiB9C;;;KAAY,cAAA;EAAmB,SAAA;IAAa,GAAA,EAAK,aAAA;EAAA;AAAA;;AAoBjD;;;;;;;;;;;;;;;;;iBAAgB,KAAA,CAAM,OAAA,GAAS,gBAAA,GAAwB,iBAAA"}

package/dist/hono/index.mjs

@@ -0,0 +1,48 @@
+import { r as createMiddlewareLogger, t as extractSafeHeaders } from "../headers-CXOd5EyZ.mjs";
+
+//#region src/hono/index.ts
+/**
+* Create an evlog middleware for Hono.
+*
+* @example
+* ```ts
+* import { Hono } from 'hono'
+* import { evlog, type EvlogVariables } from 'evlog/hono'
+* import { createAxiomDrain } from 'evlog/axiom'
+*
+* const app = new Hono<EvlogVariables>()
+* app.use(evlog({
+*   drain: createAxiomDrain(),
+*   enrich: (ctx) => {
+*     ctx.event.region = process.env.FLY_REGION
+*   },
+* }))
+* ```
+*/
+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
+		});
+		if (skipped) {
+			await next();
+			return;
+		}
+		c.set("log", logger);
+		try {
+			await next();
+			await finish({ status: c.res.status });
+		} catch (error) {
+			await finish({ error });
+			throw error;
+		}
+	};
+}
+
+//#endregion
+export { evlog };
+//# sourceMappingURL=index.mjs.map

package/dist/hono/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/hono/index.ts"],"sourcesContent":["import type { MiddlewareHandler } from 'hono'\nimport type { DrainContext, EnrichContext, RequestLogger, RouteConfig, TailSamplingContext } from '../types'\nimport { createMiddlewareLogger } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\n\nexport interface EvlogHonoOptions {\n  /** Route patterns to include in logging (glob). If not set, all routes are logged */\n  include?: string[]\n  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */\n  exclude?: string[]\n  /** Route-specific service configuration */\n  routes?: Record<string, RouteConfig>\n  /**\n   * Drain callback called with every emitted event.\n   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.\n   */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /**\n   * Enrich callback called after emit, before drain.\n   * Use to add derived context (geo, deployment info, user agent, etc.).\n   */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\n  /**\n   * Custom tail sampling callback.\n   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.\n   */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n}\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":";;;;;;;;;;;;;;;;;;;;;AA+DA,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"}

package/dist/nitro/module.d.mts

@@ -1,5 +1,5 @@
 import { useLogger } from "../runtime/server/useLogger.mjs";
-import { t as NitroModuleOptions } from "../nitro-mfub2f8G.mjs";
+import { t as NitroModuleOptions } from "../nitro-Nxg6qcXd.mjs";
 import { Nitro } from "nitropack";
 
 //#region src/nitro/module.d.ts

package/dist/nitro/v3/module.d.mts

@@ -1,4 +1,4 @@
-import { t as NitroModuleOptions } from "../../nitro-mfub2f8G.mjs";
+import { t as NitroModuleOptions } from "../../nitro-Nxg6qcXd.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro-v3/module.d.ts

package/dist/{nitro-mfub2f8G.d.mts → nitro-Nxg6qcXd.d.mts}

@@ -39,4 +39,4 @@ interface NitroModuleOptions {
 }
 //#endregion
 export { NitroModuleOptions as t };
-//# sourceMappingURL=nitro-mfub2f8G.d.mts.map
+//# sourceMappingURL=nitro-Nxg6qcXd.d.mts.map

package/dist/{nitro-mfub2f8G.d.mts.map → nitro-Nxg6qcXd.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"nitro-mfub2f8G.d.mts","names":[],"sources":["../src/nitro.ts"],"mappings":";;;UAIiB,kBAAA;EAAA;;;;EAKf,OAAA;EA8BwB;;;EAzBxB,GAAA,GAAM,OAAA,CAAQ,kBAAA;EA8BW;;;;EAxBzB,MAAA;EAAA;;;;;EAOA,OAAA;EAiBA;;;;;EAVA,OAAA;;;;EAKA,MAAA,GAAS,MAAA,SAAe,WAAA;;;;EAKxB,QAAA,GAAW,cAAA;AAAA"}
+{"version":3,"file":"nitro-Nxg6qcXd.d.mts","names":[],"sources":["../src/nitro.ts"],"mappings":";;;UAIiB,kBAAA;EAAA;;;;EAKf,OAAA;EA8BwB;;;EAzBxB,GAAA,GAAM,OAAA,CAAQ,kBAAA;EA8BW;;;;EAxBzB,MAAA;EAAA;;;;;EAOA,OAAA;EAiBA;;;;;EAVA,OAAA;;;;EAKA,MAAA,GAAS,MAAA,SAAe,WAAA;;;;EAKxB,QAAA,GAAW,cAAA;AAAA"}

package/dist/nuxt/module.mjs

@@ -2,7 +2,7 @@ import { addImports, addPlugin, addServerHandler, addServerImports, addServerPlu
 
 //#region package.json
 var name = "evlog";
-var version = "2.1.0";
+var version = "2.3.0";
 
 //#endregion
 //#region src/nuxt/module.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evlog",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Wide event logging library with structured error handling. Inspired by LoggingSucks.",
   "author": "HugoRCD <contact@hrcd.fr>",
   "homepage": "https://evlog.dev",
@@ -20,6 +20,9 @@
     "nitro",
     "nextjs",
     "tanstack-start",
+    "express",
+    "hono",
+    "elysia",
     "typescript"
   ],
   "license": "MIT",
@@ -85,6 +88,18 @@
     "./next/client": {
       "types": "./dist/next/client.d.mts",
       "import": "./dist/next/client.mjs"
+    },
+    "./hono": {
+      "types": "./dist/hono/index.d.mts",
+      "import": "./dist/hono/index.mjs"
+    },
+    "./express": {
+      "types": "./dist/express/index.d.mts",
+      "import": "./dist/express/index.mjs"
+    },
+    "./elysia": {
+      "types": "./dist/elysia/index.d.mts",
+      "import": "./dist/elysia/index.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -135,6 +150,15 @@
       ],
       "next/client": [
         "./dist/next/client.d.mts"
+      ],
+      "hono": [
+        "./dist/hono/index.d.mts"
+      ],
+      "express": [
+        "./dist/express/index.d.mts"
+      ],
+      "elysia": [
+        "./dist/elysia/index.d.mts"
       ]
     }
   },
@@ -154,19 +178,24 @@
     "typecheck": "echo 'Typecheck handled by build'"
   },
   "devDependencies": {
-    "ufo": "^1.6.3",
     "@nuxt/devtools": "^3.2.2",
     "@nuxt/schema": "^4.3.1",
     "@nuxt/test-utils": "^4.0.0",
+    "@types/express": "^5.0.6",
+    "@types/supertest": "^7.2.0",
     "changelogen": "^0.6.2",
     "consola": "^3.4.2",
+    "elysia": "^1.4.27",
+    "express": "^5.2.1",
     "h3": "^1.15.5",
-    "happy-dom": "^20.7.0",
+    "happy-dom": "^20.7.2",
     "nitro": "^3.0.1-alpha.2",
     "nitropack": "^2.13.1",
     "nuxt": "^4.3.1",
+    "supertest": "^7.2.2",
     "tsdown": "^0.20.3",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "ufo": "^1.6.3"
   },
   "peerDependencies": {
     "@nuxt/kit": "^4.3.1",
@@ -175,7 +204,10 @@
     "ofetch": "^1.5.1",
     "nitro": "^3.0.1-alpha.2",
     "next": ">=16.1.6",
-    "react": ">=19.2.4"
+    "react": ">=19.2.4",
+    "hono": "",
+    "express": ">=4.21.0",
+    "elysia": ">=1.0.0"
   },
   "peerDependenciesMeta": {
     "@nuxt/kit": {
@@ -198,6 +230,15 @@
     },
     "react": {
       "optional": true
+    },
+    "hono": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    },
+    "elysia": {
+      "optional": true
     }
   }
 }