evlog 2.3.0 → 2.4.0

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 { 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"}
+{"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"}

package/dist/middleware-BoVCgsfQ.d.mts

@@ -0,0 +1,36 @@
+import { DrainContext, EnrichContext, RouteConfig, TailSamplingContext } from "./types.mjs";
+
+//#region src/shared/middleware.d.ts
+/**
+ * Base options shared by all framework integrations.
+ *
+ * Every framework-specific options interface (e.g. `EvlogExpressOptions`)
+ * extends this type. If a framework needs extra fields it can add them
+ * on top; otherwise the base is used as-is.
+ */
+interface BaseEvlogOptions {
+  /** 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>;
+}
+//#endregion
+export { BaseEvlogOptions as t };
+//# sourceMappingURL=middleware-BoVCgsfQ.d.mts.map

package/dist/middleware-BoVCgsfQ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-BoVCgsfQ.d.mts","names":[],"sources":["../src/shared/middleware.ts"],"mappings":";;;;;AAYA;;;;;UAAiB,gBAAA;EAWuB;EATtC,OAAA;EAcwC;EAZxC,OAAA;EAiB4C;EAf5C,MAAA,GAAS,MAAA,SAAe,WAAA;EAe2B;;;;EAVnD,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EALd;;;;EAUxB,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAAxC;;;;EAKA,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;AAAA"}

package/dist/nestjs/index.d.mts

@@ -0,0 +1,83 @@
+import { RequestLogger } from "../types.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BoVCgsfQ.mjs";
+import { DynamicModule, MiddlewareConsumer, NestModule } from "@nestjs/common";
+
+//#region src/nestjs/index.d.ts
+declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+type EvlogNestJSOptions = BaseEvlogOptions;
+interface EvlogModuleAsyncOptions {
+  /** Modules to import (for dependency injection into the factory) */
+  imports?: any[];
+  /** Factory function that returns evlog options. Can be async. */
+  useFactory: (...args: any[]) => EvlogNestJSOptions | Promise<EvlogNestJSOptions>;
+  /** Injection tokens to resolve and pass to the factory */
+  inject?: any[];
+}
+declare module 'http' {
+  interface IncomingMessage {
+    log?: RequestLogger;
+  }
+}
+declare module 'express-serve-static-core' {
+  interface Request {
+    log?: RequestLogger;
+  }
+}
+/**
+ * NestJS module for evlog wide event logging.
+ *
+ * Registers a global middleware that creates a request-scoped logger
+ * for every incoming request. Use `useLogger()` to access it anywhere
+ * in the call stack, or `req.log` directly in controllers.
+ *
+ * @example
+ * ```ts
+ * import { Module } from '@nestjs/common'
+ * import { EvlogModule } from 'evlog/nestjs'
+ * import { createAxiomDrain } from 'evlog/axiom'
+ *
+ * @Module({
+ *   imports: [
+ *     EvlogModule.forRoot({
+ *       drain: createAxiomDrain(),
+ *       exclude: ['/health'],
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class EvlogModule implements NestModule {
+  private static options;
+  /**
+   * Register evlog with static configuration.
+   *
+   * @example
+   * ```ts
+   * EvlogModule.forRoot({
+   *   drain: createAxiomDrain(),
+   *   enrich: (ctx) => { ctx.event.region = process.env.FLY_REGION },
+   * })
+   * ```
+   */
+  static forRoot(options?: EvlogNestJSOptions): DynamicModule;
+  /**
+   * Register evlog with async configuration (e.g. from `ConfigService`).
+   *
+   * @example
+   * ```ts
+   * EvlogModule.forRootAsync({
+   *   imports: [ConfigModule],
+   *   inject: [ConfigService],
+   *   useFactory: (config: ConfigService) => ({
+   *     drain: createAxiomDrain({ token: config.get('AXIOM_TOKEN') }),
+   *   }),
+   * })
+   * ```
+   */
+  static forRootAsync(asyncOptions: EvlogModuleAsyncOptions): DynamicModule;
+  configure(consumer: MiddlewareConsumer): void;
+}
+//#endregion
+export { EvlogModule, EvlogModuleAsyncOptions, EvlogNestJSOptions, useLogger };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/nestjs/index.ts"],"mappings":";;;;;cAOiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,kBAAA,GAAqB,gBAAA;AAAA,UAIhB,uBAAA;EANhB;EAQC,OAAA;EAVwB;EAYxB,UAAA,MAAgB,IAAA,YAAgB,kBAAA,GAAqB,OAAA,CAAQ,kBAAA;EAZrC;EAcxB,MAAA;AAAA;AAAA;EAAA,UAIU,eAAA;IACR,GAAA,GAAM,aAAA;EAAA;AAAA;AAAA;EAAA,UAKE,OAAA;IACR,GAAA,GAAM,aAAA;EAAA;AAAA;AAjBV;;;;;;;;;;;;;;;;;AAOC;;;;;;;AAPD,cA0Ea,WAAA,YAAuB,UAAA;EAAA,eAEnB,OAAA;EAjEM;AAAA;;;;;;;;;;EAAA,OA8Ed,OAAA,CAAQ,OAAA,GAAS,kBAAA,GAA0B,aAAA;EAf3B;;;;;;;;;;;;;;EAAA,OAqChB,YAAA,CAAa,YAAA,EAAc,uBAAA,GAA0B,aAAA;EAkB5D,SAAA,CAAU,QAAA,EAAU,kBAAA;AAAA"}

package/dist/nestjs/index.mjs

@@ -0,0 +1,109 @@
+import { n as extractSafeNodeHeaders, r as createMiddlewareLogger } from "../headers-CXOd5EyZ.mjs";
+import { t as createLoggerStorage } from "../storage-Dd3PHiMh.mjs";
+
+//#region src/nestjs/index.ts
+const { storage, useLogger } = createLoggerStorage("middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.");
+function createEvlogMiddleware(getOptions) {
+	return (req, res, next) => {
+		const options = getOptions();
+		const headers = extractSafeNodeHeaders(req.headers);
+		const url = new URL(req.url || "/", "http://localhost");
+		const { logger, finish, skipped } = createMiddlewareLogger({
+			method: req.method || "GET",
+			path: url.pathname,
+			requestId: headers["x-request-id"] || crypto.randomUUID(),
+			headers,
+			...options
+		});
+		if (skipped) {
+			next();
+			return;
+		}
+		req.log = logger;
+		res.on("finish", () => {
+			finish({ status: res.statusCode }).catch(() => {});
+		});
+		storage.run(logger, () => next());
+	};
+}
+/**
+* NestJS module for evlog wide event logging.
+*
+* Registers a global middleware that creates a request-scoped logger
+* for every incoming request. Use `useLogger()` to access it anywhere
+* in the call stack, or `req.log` directly in controllers.
+*
+* @example
+* ```ts
+* import { Module } from '@nestjs/common'
+* import { EvlogModule } from 'evlog/nestjs'
+* import { createAxiomDrain } from 'evlog/axiom'
+*
+* @Module({
+*   imports: [
+*     EvlogModule.forRoot({
+*       drain: createAxiomDrain(),
+*       exclude: ['/health'],
+*     }),
+*   ],
+* })
+* export class AppModule {}
+* ```
+*/
+var EvlogModule = class EvlogModule {
+	static options = {};
+	/**
+	* Register evlog with static configuration.
+	*
+	* @example
+	* ```ts
+	* EvlogModule.forRoot({
+	*   drain: createAxiomDrain(),
+	*   enrich: (ctx) => { ctx.event.region = process.env.FLY_REGION },
+	* })
+	* ```
+	*/
+	static forRoot(options = {}) {
+		EvlogModule.options = options;
+		return {
+			module: EvlogModule,
+			global: true
+		};
+	}
+	/**
+	* Register evlog with async configuration (e.g. from `ConfigService`).
+	*
+	* @example
+	* ```ts
+	* EvlogModule.forRootAsync({
+	*   imports: [ConfigModule],
+	*   inject: [ConfigService],
+	*   useFactory: (config: ConfigService) => ({
+	*     drain: createAxiomDrain({ token: config.get('AXIOM_TOKEN') }),
+	*   }),
+	* })
+	* ```
+	*/
+	static forRootAsync(asyncOptions) {
+		return {
+			module: EvlogModule,
+			imports: asyncOptions.imports || [],
+			providers: [{
+				provide: "EVLOG_OPTIONS",
+				useFactory: async (...args) => {
+					EvlogModule.options = await asyncOptions.useFactory(...args);
+					return EvlogModule.options;
+				},
+				inject: asyncOptions.inject || []
+			}],
+			global: true
+		};
+	}
+	configure(consumer) {
+		consumer.apply(createEvlogMiddleware(() => EvlogModule.options)).forRoutes("*");
+	}
+};
+
+//#endregion
+export { EvlogModule, useLogger };
+//# sourceMappingURL=index.mjs.map

package/dist/nestjs/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/nestjs/index.ts"],"sourcesContent":["import type { IncomingMessage, ServerResponse } from 'node:http'\nimport type { DynamicModule, MiddlewareConsumer, NestModule } from '@nestjs/common'\nimport type { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeNodeHeaders } from '../shared/headers'\nimport { createLoggerStorage } from '../shared/storage'\n\nconst { storage, useLogger } = createLoggerStorage(\n  'middleware context. Make sure EvlogModule.forRoot() is imported in your AppModule.',\n)\n\nexport type EvlogNestJSOptions = BaseEvlogOptions\n\nexport { useLogger }\n\nexport interface EvlogModuleAsyncOptions {\n  /** Modules to import (for dependency injection into the factory) */\n  imports?: any[]\n  /** Factory function that returns evlog options. Can be async. */\n  useFactory: (...args: any[]) => EvlogNestJSOptions | Promise<EvlogNestJSOptions>\n  /** Injection tokens to resolve and pass to the factory */\n  inject?: any[]\n}\n\ndeclare module 'http' {\n  interface IncomingMessage {\n    log?: RequestLogger\n  }\n}\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log?: RequestLogger\n  }\n}\n\nfunction createEvlogMiddleware(getOptions: () => EvlogNestJSOptions) {\n  return (req: IncomingMessage, res: ServerResponse, next: () => void) => {\n    const options = getOptions()\n    const headers = extractSafeNodeHeaders(req.headers)\n    const url = new URL(req.url || '/', 'http://localhost')\n\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: req.method || 'GET',\n      path: url.pathname,\n      requestId: headers['x-request-id'] || crypto.randomUUID(),\n      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\n/**\n * NestJS module for evlog wide event logging.\n *\n * Registers a global middleware that creates a request-scoped logger\n * for every incoming request. Use `useLogger()` to access it anywhere\n * in the call stack, or `req.log` directly in controllers.\n *\n * @example\n * ```ts\n * import { Module } from '@nestjs/common'\n * import { EvlogModule } from 'evlog/nestjs'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * @Module({\n *   imports: [\n *     EvlogModule.forRoot({\n *       drain: createAxiomDrain(),\n *       exclude: ['/health'],\n *     }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n */\nexport class EvlogModule implements NestModule {\n\n  private static options: EvlogNestJSOptions = {}\n\n  /**\n   * Register evlog with static configuration.\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRoot({\n   *   drain: createAxiomDrain(),\n   *   enrich: (ctx) => { ctx.event.region = process.env.FLY_REGION },\n   * })\n   * ```\n   */\n  static forRoot(options: EvlogNestJSOptions = {}): DynamicModule {\n    EvlogModule.options = options\n    return {\n      module: EvlogModule,\n      global: true,\n    }\n  }\n\n  /**\n   * Register evlog with async configuration (e.g. from `ConfigService`).\n   *\n   * @example\n   * ```ts\n   * EvlogModule.forRootAsync({\n   *   imports: [ConfigModule],\n   *   inject: [ConfigService],\n   *   useFactory: (config: ConfigService) => ({\n   *     drain: createAxiomDrain({ token: config.get('AXIOM_TOKEN') }),\n   *   }),\n   * })\n   * ```\n   */\n  static forRootAsync(asyncOptions: EvlogModuleAsyncOptions): DynamicModule {\n    return {\n      module: EvlogModule,\n      imports: asyncOptions.imports || [],\n      providers: [\n        {\n          provide: 'EVLOG_OPTIONS',\n          useFactory: async (...args: any[]) => {\n            EvlogModule.options = await asyncOptions.useFactory(...args)\n            return EvlogModule.options\n          },\n          inject: asyncOptions.inject || [],\n        },\n      ],\n      global: true,\n    }\n  }\n\n  configure(consumer: MiddlewareConsumer): void {\n    consumer\n      .apply(createEvlogMiddleware(() => EvlogModule.options))\n      .forRoutes('*')\n  }\n\n}\n"],"mappings":";;;;AAOA,MAAM,EAAE,SAAS,cAAc,oBAC7B,qFACD;AA2BD,SAAS,sBAAsB,YAAsC;AACnE,SAAQ,KAAsB,KAAqB,SAAqB;EACtE,MAAM,UAAU,YAAY;EAC5B,MAAM,UAAU,uBAAuB,IAAI,QAAQ;EACnD,MAAM,MAAM,IAAI,IAAI,IAAI,OAAO,KAAK,mBAAmB;EAEvD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,IAAI,UAAU;GACtB,MAAM,IAAI;GACV,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GACzD;GACA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BrC,IAAa,cAAb,MAAa,YAAkC;CAE7C,OAAe,UAA8B,EAAE;;;;;;;;;;;;CAa/C,OAAO,QAAQ,UAA8B,EAAE,EAAiB;AAC9D,cAAY,UAAU;AACtB,SAAO;GACL,QAAQ;GACR,QAAQ;GACT;;;;;;;;;;;;;;;;CAiBH,OAAO,aAAa,cAAsD;AACxE,SAAO;GACL,QAAQ;GACR,SAAS,aAAa,WAAW,EAAE;GACnC,WAAW,CACT;IACE,SAAS;IACT,YAAY,OAAO,GAAG,SAAgB;AACpC,iBAAY,UAAU,MAAM,aAAa,WAAW,GAAG,KAAK;AAC5D,YAAO,YAAY;;IAErB,QAAQ,aAAa,UAAU,EAAE;IAClC,CACF;GACD,QAAQ;GACT;;CAGH,UAAU,UAAoC;AAC5C,WACG,MAAM,4BAA4B,YAAY,QAAQ,CAAC,CACvD,UAAU,IAAI"}

package/dist/next/index.d.mts

@@ -1,10 +1,11 @@
-import { DrainContext, EnrichContext, EnvironmentContext, Log, RequestLogger, RouteConfig, SamplingConfig, TailSamplingContext } from "../types.mjs";
+import { EnvironmentContext, Log, RequestLogger, SamplingConfig } from "../types.mjs";
 import { createError } from "../error.mjs";
 import { log as _log } from "../logger.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BoVCgsfQ.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/next/types.d.ts
-interface NextEvlogOptions {
+interface NextEvlogOptions extends BaseEvlogOptions {
   /**
    * Service name for all logged events.
    * @default auto-detected from SERVICE_NAME env or 'app'
@@ -28,38 +29,6 @@ interface NextEvlogOptions {
    * Sampling configuration for filtering logs.
    */
   sampling?: SamplingConfig;
-  /**
-   * Route patterns to include in logging.
-   * Supports glob patterns like '/api/**'.
-   * If not set, all routes are logged.
-   */
-  include?: string[];
-  /**
-   * Route patterns to exclude from logging.
-   * Supports glob patterns like '/_next/**'.
-   * Exclusions take precedence over inclusions.
-   */
-  exclude?: string[];
-  /**
-   * Route-specific service configuration.
-   */
-  routes?: Record<string, RouteConfig>;
-  /**
-   * Drain callback called with every emitted event (fire-and-forget).
-   * Compatible with drain adapters and pipeline-wrapped drains.
-   */
-  drain?: (ctx: DrainContext) => void | Promise<void>;
-  /**
-   * Enrich callback called after emit, before drain.
-   * Use this to add derived context (e.g. geo, deployment info).
-   */
-  enrich?: (ctx: EnrichContext) => void | Promise<void>;
-  /**
-   * Custom tail sampling callback called before emit.
-   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.
-   * Equivalent to Nuxt's `evlog:emit:keep` hook.
-   */
-  keep?: (ctx: TailSamplingContext) => void | Promise<void>;
   /**
    * When pretty is disabled, emit JSON strings (default) or raw objects.
    * @default true

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/next/types.ts","../../src/next/storage.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"mappings":";;;;;;UAEiB,gBAAA;;;;;EAKf,OAAA;EALe;;;EAUf,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAAR;;;;EAMN,MAAA;EAoCsC;;;;EA9BtC,OAAA;EA2CmD;;;EAtCnD,QAAA,GAAW,cAAA;EAjBL;;;;;EAwBN,OAAA;EAAA;;;;;EAOA,OAAA;EAWc;;;EANd,MAAA,GAAS,MAAA,SAAe,WAAA;EAYT;;;;EANf,KAAA,IAAS,GAAA,EAAK,YAAA,YAAwB,OAAA;EAa9B;;;;EAPR,MAAA,IAAU,GAAA,EAAK,aAAA,YAAyB,OAAA;EAgBzB;;;;;EATf,IAAA,IAAQ,GAAA,EAAK,mBAAA,YAA+B,OAAA;;;AC/C9C;;EDqDE,SAAA;AAAA;AAAA,UAGe,qBAAA;ECxDwD;;;;ED6DvE,OAAA;EC7DuE;;;;EDmEvE,OAAA;AAAA;;;;;;;AArFF;;;;;;;;;;;iBCkBgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;;;KCjBlF,WAAA;EACH,OAAA;IAAW,QAAA;EAAA;EACX,OAAA;IAAW,GAAA,CAAI,IAAA;EAAA;AAAA;AAAA,KAGZ,YAAA;EACH,OAAA;IAAW,GAAA,CAAI,IAAA,UAAc,KAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAoBf,eAAA,CAAgB,MAAA,GAAS,qBAAA,IACzB,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCYpB,WAAA,CAAY,OAAA,GAAS,gBAAA;6DAWg8D,IAAA,EAAA,KAAA,KAAA,OAAA,SAAkC,IAAA,EAAA,KAAA,KAAA,OAAA,CAAA,OAAA,CAAA,OAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/next/types.ts","../../src/next/storage.ts","../../src/next/middleware.ts","../../src/next/index.ts"],"mappings":";;;;;;;UAGiB,gBAAA,SAAyB,gBAAA;;;;;EAKxC,OAAA;EALe;;;EAUf,GAAA,GAAM,OAAA,CAAQ,kBAAA;EAAR;;;;EAMN,MAAA;EAhBwC;;;;EAsBxC,OAAA;EANA;;;EAWA,QAAA,GAAW,cAAA;EAMX;;;AAGF;EAHE,SAAA;AAAA;AAAA,UAGe,qBAAA;EAWR;;;;EANP,OAAA;ECxBuB;;;;ED8BvB,OAAA;AAAA;;;;;;;;AA/CF;;;;;;;;;;iBCiBgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;;;KCjBlF,WAAA;EACH,OAAA;IAAW,QAAA;EAAA;EACX,OAAA;IAAW,GAAA,CAAI,IAAA;EAAA;AAAA;AAAA,KAGZ,YAAA;EACH,OAAA;IAAW,GAAA,CAAI,IAAA,UAAc,KAAA;EAAA;AAAA;;;;;;;;;;;;;;iBAoBf,eAAA,CAAgB,MAAA,GAAS,qBAAA,IACzB,OAAA,EAAS,WAAA,KAAW,OAAA,CAAA,YAAA;;;AF3BpC;;;;;;;;;;;;;;;;;;;;;AAoCA;;;;;;;;AApCA,iBGuCgB,WAAA,CAAY,OAAA,GAAS,gBAAA;6DAWg8D,IAAA,EAAA,KAAA,KAAA,OAAA,SAAkC,IAAA,EAAA,KAAA,KAAA,OAAA,CAAA,OAAA,CAAA,OAAA"}

package/dist/nitro/module.d.mts

@@ -1,5 +1,5 @@
 import { useLogger } from "../runtime/server/useLogger.mjs";
-import { t as NitroModuleOptions } from "../nitro-Nxg6qcXd.mjs";
+import { t as NitroModuleOptions } from "../nitro-BRisWfGy.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-Nxg6qcXd.mjs";
+import { t as NitroModuleOptions } from "../../nitro-BRisWfGy.mjs";
 import { Nitro } from "nitro/types";
 
 //#region src/nitro-v3/module.d.ts

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

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

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"nitro-BRisWfGy.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.3.0";
+var version = "2.4.0";
 
 //#endregion
 //#region src/nuxt/module.ts

package/dist/storage-Dd3PHiMh.mjs

@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/shared/storage.ts
+/**
+* Create a request-scoped `AsyncLocalStorage` and a matching `useLogger` accessor.
+*
+* Every framework that needs `useLogger()` (Express, Fastify, NestJS, SvelteKit)
+* calls this once at module level to get its own isolated storage + accessor pair.
+*
+* @param contextHint - Human-readable hint appended to the error message when
+*   `useLogger()` is called outside of a request (e.g.
+*   `"middleware context. Make sure app.use(evlog()) is registered before your routes."`).
+*/
+function createLoggerStorage(contextHint) {
+	const storage = new AsyncLocalStorage();
+	function useLogger() {
+		const logger = storage.getStore();
+		if (!logger) throw new Error(`[evlog] useLogger() was called outside of an evlog ${contextHint}`);
+		return logger;
+	}
+	return {
+		storage,
+		useLogger
+	};
+}
+
+//#endregion
+export { createLoggerStorage as t };
+//# sourceMappingURL=storage-Dd3PHiMh.mjs.map

package/dist/storage-Dd3PHiMh.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-Dd3PHiMh.mjs","names":[],"sources":["../src/shared/storage.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { RequestLogger } from '../types'\n\n/**\n * Create a request-scoped `AsyncLocalStorage` and a matching `useLogger` accessor.\n *\n * Every framework that needs `useLogger()` (Express, Fastify, NestJS, SvelteKit)\n * calls this once at module level to get its own isolated storage + accessor pair.\n *\n * @param contextHint - Human-readable hint appended to the error message when\n *   `useLogger()` is called outside of a request (e.g.\n *   `\"middleware context. Make sure app.use(evlog()) is registered before your routes.\"`).\n */\nexport function createLoggerStorage(contextHint: string) {\n  const storage = new AsyncLocalStorage<RequestLogger>()\n\n  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 ${contextHint}`,\n      )\n    }\n    return logger as RequestLogger<T>\n  }\n\n  return { storage, useLogger }\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,oBAAoB,aAAqB;CACvD,MAAM,UAAU,IAAI,mBAAkC;CAEtD,SAAS,YAA0E;EACjF,MAAM,SAAS,QAAQ,UAAU;AACjC,MAAI,CAAC,OACH,OAAM,IAAI,MACR,sDAAsD,cACvD;AAEH,SAAO;;AAGT,QAAO;EAAE;EAAS;EAAW"}

package/dist/sveltekit/index.d.mts

@@ -0,0 +1,128 @@
+import { RequestLogger } from "../types.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BoVCgsfQ.mjs";
+
+//#region src/sveltekit/index.d.ts
+declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+type EvlogSvelteKitOptions = BaseEvlogOptions;
+/**
+ * SvelteKit `Handle` function signature — avoids a hard dependency on `@sveltejs/kit`.
+ */
+type SvelteKitHandle = (input: {
+  event: {
+    request: Request;
+    url: URL;
+    locals: Record<string, any>;
+  };
+  resolve: (event: any) => Promise<Response>;
+}) => Promise<Response>;
+/**
+ * SvelteKit `HandleServerError` signature — avoids a hard dependency on `@sveltejs/kit`.
+ */
+type SvelteKitHandleServerError = (input: {
+  error: unknown;
+  event: {
+    request: Request;
+    url: URL;
+    locals: Record<string, any>;
+  };
+  status: number;
+  message: string;
+}) => MaybePromise<void | AppError>;
+type MaybePromise<T> = T | Promise<T>;
+/** Minimal SvelteKit `App.Error` shape */
+interface AppError {
+  message: string;
+  [key: string]: unknown;
+}
+/**
+ * Create an evlog handle hook for SvelteKit.
+ *
+ * Add it to your `src/hooks.server.ts` using SvelteKit's `sequence` helper
+ * or as the sole handle export.
+ *
+ * @example
+ * ```ts
+ * // src/hooks.server.ts
+ * import { initLogger } from 'evlog'
+ * import { evlog } from 'evlog/sveltekit'
+ * import { createAxiomDrain } from 'evlog/axiom'
+ *
+ * initLogger({ env: { service: 'my-sveltekit-app' } })
+ *
+ * export const handle = evlog({
+ *   drain: createAxiomDrain(),
+ *   enrich: (ctx) => {
+ *     ctx.event.region = process.env.FLY_REGION
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Compose with other hooks using sequence
+ * import { sequence } from '@sveltejs/kit/hooks'
+ * import { evlog } from 'evlog/sveltekit'
+ *
+ * export const handle = sequence(evlog(), yourOtherHook)
+ * ```
+ */
+declare function evlog(options?: EvlogSvelteKitOptions): SvelteKitHandle;
+/**
+ * Create an evlog error handler for SvelteKit.
+ *
+ * Logs unhandled errors via `event.locals.log` (if available) and returns
+ * structured error responses for `EvlogError` instances. For non-evlog errors,
+ * returns a generic error response with sanitized messages in production.
+ *
+ * @example
+ * ```ts
+ * // src/hooks.server.ts
+ * import { evlog, evlogHandleError } from 'evlog/sveltekit'
+ *
+ * export const handle = evlog()
+ * export const handleError = evlogHandleError()
+ * ```
+ */
+declare function evlogHandleError(): SvelteKitHandleServerError;
+/**
+ * Create both `handle` and `handleError` hooks in a single call.
+ *
+ * This is the recommended setup for SvelteKit — it returns both hooks
+ * pre-configured and ready to export from `hooks.server.ts`.
+ *
+ * @example
+ * ```ts
+ * // src/hooks.server.ts
+ * import { initLogger } from 'evlog'
+ * import { createEvlogHooks } from 'evlog/sveltekit'
+ * import { createAxiomDrain } from 'evlog/axiom'
+ *
+ * initLogger({ env: { service: 'my-app' } })
+ *
+ * export const { handle, handleError } = createEvlogHooks({
+ *   drain: createAxiomDrain(),
+ *   enrich: (ctx) => {
+ *     ctx.event.region = process.env.FLY_REGION
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Compose with other hooks using sequence
+ * import { sequence } from '@sveltejs/kit/hooks'
+ * import { createEvlogHooks } from 'evlog/sveltekit'
+ *
+ * const evlogHooks = createEvlogHooks()
+ *
+ * export const handle = sequence(evlogHooks.handle, yourOtherHook)
+ * export const handleError = evlogHooks.handleError
+ * ```
+ */
+declare function createEvlogHooks(options?: EvlogSvelteKitOptions): {
+  handle: SvelteKitHandle;
+  handleError: SvelteKitHandleServerError;
+};
+//#endregion
+export { EvlogSvelteKitOptions, createEvlogHooks, evlog, evlogHandleError, useLogger };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/sveltekit/index.ts"],"mappings":";;;;cAOiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,qBAAA,GAAwB,gBAAA;;;;KAO/B,eAAA,IAAmB,KAAA;EACtB,KAAA;IAAS,OAAA,EAAS,OAAA;IAAS,GAAA,EAAK,GAAA;IAAK,MAAA,EAAQ,MAAA;EAAA;EAC7C,OAAA,GAAU,KAAA,UAAe,OAAA,CAAQ,QAAA;AAAA,MAC7B,OAAA,CAAQ,QAAA;;;AAVd;KAeK,0BAAA,IAA8B,KAAA;EACjC,KAAA;EACA,KAAA;IAAS,OAAA,EAAS,OAAA;IAAS,GAAA,EAAK,GAAA;IAAK,MAAA,EAAQ,MAAA;EAAA;EAC7C,MAAA;EACA,OAAA;AAAA,MACI,YAAA,QAAoB,QAAA;AAAA,KAErB,YAAA,MAAkB,CAAA,GAAI,OAAA,CAAQ,CAAA;;UAGzB,QAAA;EACR,OAAA;EAAA,CACC,GAAA;AAAA;;;;;;;;;;;;;;;;;AAjBmB;;;;;;;;;;;;;;;;iBAoDN,KAAA,CAAM,OAAA,GAAS,qBAAA,GAA6B,eAAA;;;;;;;;;AA1C1B;;;;;;;;iBAkHlB,gBAAA,CAAA,GAAoB,0BAAA;;;;;;AAhHA;;;;;AAwCpC;;;;;;;;;AAwEA;;;;;AA6DA;;;;;;;;;;;iBAAgB,gBAAA,CAAiB,OAAA,GAAS,qBAAA"}