evlog 2.1.0 → 2.4.0

package/README.md

@@ -375,43 +375,116 @@ Notes:
 
 ## Hono
 
-Use the standalone API to create one wide event per request from a Hono middleware.
-
 ```typescript
 // src/index.ts
-import { serve } from '@hono/node-server'
 import { Hono } from 'hono'
-import { createRequestLogger, initLogger } from 'evlog'
+import { initLogger } from 'evlog'
+import { evlog, type EvlogVariables } from 'evlog/hono'
 
-initLogger({
-  env: { service: 'hono-api' },
+initLogger({ env: { service: 'hono-api' } })
+
+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: [] })
 })
+```
 
-const app = new Hono()
+See the full [hono example](https://github.com/HugoRCD/evlog/tree/main/examples/hono) for a complete working project.
 
-app.use('*', async (c, next) => {
-  const startedAt = Date.now()
-  const log = createRequestLogger({ method: c.req.method, path: c.req.path })
+## Express
 
-  try {
-    await next()
-  } catch (error) {
-    log.error(error as Error)
-    throw error
-  } finally {
-    log.emit({
-      status: c.res.status,
-      duration: Date.now() - startedAt,
-    })
-  }
+```typescript
+// src/index.ts
+import express from 'express'
+import { initLogger } from 'evlog'
+import { evlog, useLogger } from 'evlog/express'
+
+initLogger({ env: { service: 'express-api' } })
+
+const app = express()
+app.use(evlog())
+
+app.get('/api/users', (req, res) => {
+  req.log.set({ users: { count: 42 } })
+  res.json({ users: [] })
 })
+```
+
+Use `useLogger()` to access the logger from anywhere in the call stack without passing `req`.
+
+See the full [express example](https://github.com/HugoRCD/evlog/tree/main/examples/express) for a complete working project.
+
+## Fastify
+
+```typescript
+// src/index.ts
+import Fastify from 'fastify'
+import { initLogger } from 'evlog'
+import { evlog, useLogger } from 'evlog/fastify'
+
+initLogger({ env: { service: 'fastify-api' } })
 
-app.get('/health', (c) => c.json({ ok: true }))
+const app = Fastify({ logger: false })
+await app.register(evlog)
 
-serve({ fetch: app.fetch, port: 3000 })
+app.get('/api/users', async (request) => {
+  request.log.set({ users: { count: 42 } })
+  return { users: [] }
+})
 ```
 
-See the full [hono example](https://github.com/HugoRCD/evlog/tree/main/examples/hono) for a complete working project.
+`request.log` is the evlog wide-event logger (shadows Fastify's built-in pino logger on the request). Use `useLogger()` to access the logger from anywhere in the call stack.
+
+See the full [fastify example](https://github.com/HugoRCD/evlog/tree/main/examples/fastify) for a complete working project.
+
+## Elysia
+
+```typescript
+// src/index.ts
+import { Elysia } from 'elysia'
+import { initLogger } from 'evlog'
+import { evlog, useLogger } from 'evlog/elysia'
+
+initLogger({ env: { service: 'elysia-api' } })
+
+const app = new Elysia()
+  .use(evlog())
+  .get('/api/users', ({ log }) => {
+    log.set({ users: { count: 42 } })
+    return { users: [] }
+  })
+  .listen(3000)
+```
+
+Use `useLogger()` to access the logger from anywhere in the call stack.
+
+See the full [elysia example](https://github.com/HugoRCD/evlog/tree/main/examples/elysia) for a complete working project.
+
+## NestJS
+
+```typescript
+// src/app.module.ts
+import { Module } from '@nestjs/common'
+import { EvlogModule } from 'evlog/nestjs'
+
+@Module({
+  imports: [EvlogModule.forRoot()],
+})
+export class AppModule {}
+
+// In any controller or service:
+import { useLogger } from 'evlog/nestjs'
+const log = useLogger()
+log.set({ users: { count: 42 } })
+```
+
+`EvlogModule.forRoot()` registers a global middleware that creates a request-scoped logger for every request. Use `useLogger()` to access it anywhere in the call stack, or `req.log` directly. Supports `forRootAsync()` for async configuration.
+
+See the full [nestjs example](https://github.com/HugoRCD/evlog/tree/main/examples/nestjs) for a complete working project.
 
 ## Browser
 
@@ -991,12 +1064,19 @@ try {
 |-----------|-------------|
 | **Nuxt** | `modules: ['evlog/nuxt']` |
 | **Next.js** | `createEvlog()` factory with `import { createEvlog } from 'evlog/next'` ([example](./examples/nextjs)) |
+| **SvelteKit** | `export const { handle, handleError } = createEvlogHooks()` with `import { createEvlogHooks } from 'evlog/sveltekit'` ([example](./examples/sveltekit)) |
 | **Nitro v3** | `modules: [evlog()]` with `import evlog from 'evlog/nitro/v3'` |
 | **Nitro v2** | `modules: [evlog()]` with `import evlog from 'evlog/nitro'` |
+| **TanStack Start** | Nitro v3 module setup ([example](./examples/tanstack-start)) |
+| **NestJS** | `EvlogModule.forRoot()` with `import { EvlogModule } from 'evlog/nestjs'` ([example](./examples/nestjs)) |
+| **Express** | `app.use(evlog())` with `import { evlog } from 'evlog/express'` ([example](./examples/express)) |
+| **Hono** | `app.use(evlog())` with `import { evlog } from 'evlog/hono'` ([example](./examples/hono)) |
+| **Fastify** | `app.register(evlog)` with `import { evlog } from 'evlog/fastify'` ([example](./examples/fastify)) |
+| **Elysia** | `.use(evlog())` with `import { evlog } from 'evlog/elysia'` ([example](./examples/elysia)) |
+| **Cloudflare Workers** | Manual setup with `import { initLogger, createRequestLogger } from 'evlog'` ([example](./examples/workers)) |
 | **Analog** | Nitro v2 module setup |
 | **Vinxi** | Nitro v2 module setup |
 | **SolidStart** | Nitro v2 module setup ([example](./examples/solidstart)) |
-| **TanStack Start** | Nitro v3 module setup ([example](./examples/tanstack-start)) |
 
 ## Agent Skills
 

package/dist/elysia/index.d.mts

@@ -0,0 +1,58 @@
+import { RequestLogger } from "../types.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BoVCgsfQ.mjs";
+import { Elysia } from "elysia";
+
+//#region src/elysia/index.d.ts
+type EvlogElysiaOptions = BaseEvlogOptions;
+/**
+ * Get the request-scoped logger from anywhere in the call stack.
+ * Must be called inside a request handled by the `evlog()` plugin.
+ *
+ * Unlike other frameworks, Elysia uses `storage.enterWith()` which persists
+ * beyond the request lifecycle. This accessor additionally checks `activeLoggers`
+ * to ensure the logger belongs to an in-flight request.
+ *
+ * @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":";;;;;KAcY,kBAAA,GAAqB,gBAAA;;AAAjC;;;;;AAoBA;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAA,GAA4B,aAAA,CAAc,CAAA;AAAA,iBAwCvE,KAAA,CAAM,OAAA,GAAS,kBAAA,GAAuB,MAAA"}

package/dist/elysia/index.mjs

@@ -0,0 +1,72 @@
+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();
+const activeLoggers = /* @__PURE__ */ new WeakSet();
+/**
+* Get the request-scoped logger from anywhere in the call stack.
+* Must be called inside a request handled by the `evlog()` plugin.
+*
+* Unlike other frameworks, Elysia uses `storage.enterWith()` which persists
+* beyond the request lifecycle. This accessor additionally checks `activeLoggers`
+* to ensure the logger belongs to an in-flight request.
+*
+* @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 || !activeLoggers.has(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
+		});
+		if (!skipped) activeLoggers.add(logger);
+		storage.enterWith(logger);
+		requestState.set(request, {
+			finish,
+			skipped,
+			logger
+		});
+		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 });
+		activeLoggers.delete(state.logger);
+		storage.enterWith(void 0);
+	}).onError({ as: "global" }, async ({ request, error }) => {
+		const state = requestState.get(request);
+		if (!state || state.skipped || emitted.has(request)) return;
+		emitted.add(request);
+		const err = error instanceof Error ? error : new Error(String(error));
+		state.logger.error(err);
+		await state.finish({ error: err });
+		activeLoggers.delete(state.logger);
+		storage.enterWith(void 0);
+	});
+}
+
+//#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 { RequestLogger } from '../types'\nimport { createMiddlewareLogger, type BaseEvlogOptions } from '../shared/middleware'\nimport { extractSafeHeaders } from '../shared/headers'\n\nconst storage = new AsyncLocalStorage<RequestLogger>()\n\n// Tracks loggers that are currently active (within a live request).\n// Elysia uses storage.enterWith() which persists in the async context\n// even after the request ends, so we use this set to distinguish\n// an in-flight logger from a stale one.\nconst activeLoggers = new WeakSet<RequestLogger>()\n\nexport type EvlogElysiaOptions = BaseEvlogOptions\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 * Unlike other frameworks, Elysia uses `storage.enterWith()` which persists\n * beyond the request lifecycle. This accessor additionally checks `activeLoggers`\n * to ensure the logger belongs to an in-flight request.\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 || !activeLoggers.has(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  logger: RequestLogger\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      if (!skipped) activeLoggers.add(logger)\n      storage.enterWith(logger)\n      requestState.set(request, { finish, skipped, logger })\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      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as RequestLogger)\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 err = error instanceof Error ? error : new Error(String(error))\n      state.logger.error(err)\n      await state.finish({ error: err })\n      activeLoggers.delete(state.logger)\n      storage.enterWith(undefined as unknown as RequestLogger)\n    })\n}\n"],"mappings":";;;;;AAMA,MAAM,UAAU,IAAI,mBAAkC;AAMtD,MAAM,gCAAgB,IAAI,SAAwB;;;;;;;;;;;;;;;;;;;AAsBlD,SAAgB,YAA0E;CACxF,MAAM,SAAS,QAAQ,UAAU;AACjC,KAAI,CAAC,UAAU,CAAC,cAAc,IAAI,OAAO,CACvC,OAAM,IAAI,MACR,kIAED;AAEH,QAAO;;AAgCT,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,MAAI,CAAC,QAAS,eAAc,IAAI,OAAO;AACvC,UAAQ,UAAU,OAAO;AACzB,eAAa,IAAI,SAAS;GAAE;GAAQ;GAAS;GAAQ,CAAC;AAEtD,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;AAC3D,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,OAAsC;GACxD,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,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,QAAM,OAAO,MAAM,IAAI;AACvB,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;AAClC,gBAAc,OAAO,MAAM,OAAO;AAClC,UAAQ,UAAU,OAAsC;GACxD"}

package/dist/express/index.d.mts

@@ -0,0 +1,34 @@
+import { RequestLogger } from "../types.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BoVCgsfQ.mjs";
+import { RequestHandler } from "express";
+
+//#region src/express/index.d.ts
+declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+type EvlogExpressOptions = BaseEvlogOptions;
+declare module 'express-serve-static-core' {
+  interface Request {
+    log: RequestLogger;
+  }
+}
+/**
+ * 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":";;;;;cAMiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,mBAAA,GAAsB,gBAAA;AAAA;EAAA,UAKtB,OAAA;IACR,GAAA,EAAK,aAAA;EAAA;AAAA;;;;;;;;;AANT;;;;;AAEoB;;;;;iBA0BJ,KAAA,CAAM,OAAA,GAAS,mBAAA,GAA2B,cAAA"}

package/dist/express/index.mjs

@@ -0,0 +1,47 @@
+import { n as extractSafeNodeHeaders, r as createMiddlewareLogger } from "../headers-CXOd5EyZ.mjs";
+import { t as createLoggerStorage } from "../storage-Dd3PHiMh.mjs";
+
+//#region src/express/index.ts
+const { storage, useLogger } = createLoggerStorage("middleware context. Make sure app.use(evlog()) is registered before your routes.");
+/**
+* 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 type { Request, Response, NextFunction, RequestHandler } from 'express'\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 app.use(evlog()) is registered before your routes.',\n)\n\nexport type EvlogExpressOptions = BaseEvlogOptions\n\nexport { useLogger }\n\ndeclare module 'express-serve-static-core' {\n  interface Request {\n    log: RequestLogger\n  }\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,EAAE,SAAS,cAAc,oBAC7B,mFACD;;;;;;;;;;;;;;;;;;;AA8BD,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/fastify/index.d.mts

@@ -0,0 +1,37 @@
+import { RequestLogger } from "../types.mjs";
+import { t as BaseEvlogOptions } from "../middleware-BoVCgsfQ.mjs";
+import { FastifyPluginCallback } from "fastify";
+
+//#region src/fastify/index.d.ts
+declare const useLogger: <T extends object = Record<string, unknown>>() => RequestLogger<T>;
+type EvlogFastifyOptions = BaseEvlogOptions;
+declare module 'fastify' {
+  interface FastifyRequest {
+    log: any;
+  }
+}
+/**
+ * Create an evlog plugin for Fastify.
+ *
+ * @example
+ * ```ts
+ * import Fastify from 'fastify'
+ * import { initLogger } from 'evlog'
+ * import { evlog } from 'evlog/fastify'
+ * import { createAxiomDrain } from 'evlog/axiom'
+ *
+ * initLogger({ env: { service: 'fastify-api' } })
+ *
+ * const app = Fastify()
+ * await app.register(evlog, {
+ *   drain: createAxiomDrain(),
+ *   enrich: (ctx) => {
+ *     ctx.event.region = process.env.FLY_REGION
+ *   },
+ * })
+ * ```
+ */
+declare const evlog: FastifyPluginCallback<BaseEvlogOptions>;
+//#endregion
+export { EvlogFastifyOptions, evlog, useLogger };
+//# sourceMappingURL=index.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/fastify/index.ts"],"mappings":";;;;;cAMiB,SAAA,sBAAS,MAAA,wBAAA,aAAA,CAAA,CAAA;AAAA,KAId,mBAAA,GAAsB,gBAAA;AAAA;EAAA,UAKtB,cAAA;IAER,GAAA;EAAA;AAAA;;;;;;;;;AAPJ;;;;;AAEoB;;;;;;AAyFpB;;cAAa,KAAA,EAAK,qBAAA,CAAA,gBAAA"}

package/dist/fastify/index.mjs

@@ -0,0 +1,73 @@
+import { n as extractSafeNodeHeaders, r as createMiddlewareLogger } from "../headers-CXOd5EyZ.mjs";
+import { t as createLoggerStorage } from "../storage-Dd3PHiMh.mjs";
+
+//#region src/fastify/index.ts
+const { storage, useLogger } = createLoggerStorage("plugin context. Make sure app.register(evlog) is called before your routes.");
+const evlogPlugin = (fastify, options, done) => {
+	const emitted = /* @__PURE__ */ new WeakSet();
+	const requestState = /* @__PURE__ */ new WeakMap();
+	fastify.addHook("onRequest", (request, _reply, done) => {
+		const headers = extractSafeNodeHeaders(request.headers);
+		const path = new URL(request.url, "http://localhost").pathname;
+		const { logger, finish, skipped } = createMiddlewareLogger({
+			method: request.method,
+			path,
+			requestId: headers["x-request-id"] || crypto.randomUUID(),
+			headers,
+			...options
+		});
+		if (skipped) {
+			done();
+			return;
+		}
+		const req = request;
+		req.log = logger;
+		requestState.set(request, { finish });
+		storage.run(logger, () => done());
+	});
+	fastify.addHook("onResponse", async (request, reply) => {
+		const state = requestState.get(request);
+		if (!state || emitted.has(request)) return;
+		emitted.add(request);
+		await state.finish({ status: reply.statusCode });
+	});
+	fastify.addHook("onError", async (request, _reply, error) => {
+		const state = requestState.get(request);
+		if (!state || emitted.has(request)) return;
+		emitted.add(request);
+		const logger = request.log;
+		const err = error instanceof Error ? error : new Error(String(error));
+		if (logger && typeof logger.error === "function") logger.error(err);
+		await state.finish({ error: err });
+	});
+	done();
+};
+const plugin = evlogPlugin;
+plugin[Symbol.for("skip-override")] = true;
+plugin[Symbol.for("fastify.display-name")] = "evlog";
+/**
+* Create an evlog plugin for Fastify.
+*
+* @example
+* ```ts
+* import Fastify from 'fastify'
+* import { initLogger } from 'evlog'
+* import { evlog } from 'evlog/fastify'
+* import { createAxiomDrain } from 'evlog/axiom'
+*
+* initLogger({ env: { service: 'fastify-api' } })
+*
+* const app = Fastify()
+* await app.register(evlog, {
+*   drain: createAxiomDrain(),
+*   enrich: (ctx) => {
+*     ctx.event.region = process.env.FLY_REGION
+*   },
+* })
+* ```
+*/
+const evlog = evlogPlugin;
+
+//#endregion
+export { evlog, useLogger };
+//# sourceMappingURL=index.mjs.map

package/dist/fastify/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/fastify/index.ts"],"sourcesContent":["import type { FastifyPluginCallback } from 'fastify'\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  'plugin context. Make sure app.register(evlog) is called before your routes.',\n)\n\nexport type EvlogFastifyOptions = BaseEvlogOptions\n\nexport { useLogger }\n\ndeclare module 'fastify' {\n  interface FastifyRequest {\n    // Overrides Fastify's built-in pino logger on the request with evlog's RequestLogger.\n    log: any\n  }\n}\n\ninterface RequestState {\n  finish: (opts?: { status?: number; error?: Error }) => Promise<unknown>\n}\n\nconst evlogPlugin: FastifyPluginCallback<EvlogFastifyOptions> = (fastify, options, done) => {\n  const emitted = new WeakSet<object>()\n  const requestState = new WeakMap<object, RequestState>()\n\n  fastify.addHook('onRequest', (request, _reply, done) => {\n    const headers = extractSafeNodeHeaders(request.headers)\n    const path = new URL(request.url, 'http://localhost').pathname\n\n    const { logger, finish, skipped } = createMiddlewareLogger({\n      method: request.method,\n      path,\n      requestId: headers['x-request-id'] || crypto.randomUUID(),\n      headers,\n      ...options,\n    })\n\n    if (skipped) {\n      done()\n      return\n    }\n\n    // Shadow Fastify's built-in pino logger with evlog's request-scoped logger\n    const req = request as any\n    req.log = logger\n    requestState.set(request, { finish })\n\n    storage.run(logger, () => done())\n  })\n\n  fastify.addHook('onResponse', async (request, reply) => {\n    const state = requestState.get(request)\n    if (!state || emitted.has(request)) return\n    emitted.add(request)\n    await state.finish({ status: reply.statusCode })\n  })\n\n  fastify.addHook('onError', async (request, _reply, error) => {\n    const state = requestState.get(request)\n    if (!state || emitted.has(request)) return\n    emitted.add(request)\n    const logger = (request as any).log\n    const err = error instanceof Error ? error : new Error(String(error))\n    if (logger && typeof logger.error === 'function') logger.error(err)\n    await state.finish({ error: err })\n  })\n\n  done()\n}\n\n// Break Fastify plugin encapsulation without a runtime dependency on fastify-plugin.\n// This is the same mechanism fastify-plugin uses internally.\nconst plugin = evlogPlugin as any\nplugin[Symbol.for('skip-override')] = true\nplugin[Symbol.for('fastify.display-name')] = 'evlog'\n\n/**\n * Create an evlog plugin for Fastify.\n *\n * @example\n * ```ts\n * import Fastify from 'fastify'\n * import { initLogger } from 'evlog'\n * import { evlog } from 'evlog/fastify'\n * import { createAxiomDrain } from 'evlog/axiom'\n *\n * initLogger({ env: { service: 'fastify-api' } })\n *\n * const app = Fastify()\n * await app.register(evlog, {\n *   drain: createAxiomDrain(),\n *   enrich: (ctx) => {\n *     ctx.event.region = process.env.FLY_REGION\n *   },\n * })\n * ```\n */\nexport const evlog = evlogPlugin\n"],"mappings":";;;;AAMA,MAAM,EAAE,SAAS,cAAc,oBAC7B,8EACD;AAiBD,MAAM,eAA2D,SAAS,SAAS,SAAS;CAC1F,MAAM,0BAAU,IAAI,SAAiB;CACrC,MAAM,+BAAe,IAAI,SAA+B;AAExD,SAAQ,QAAQ,cAAc,SAAS,QAAQ,SAAS;EACtD,MAAM,UAAU,uBAAuB,QAAQ,QAAQ;EACvD,MAAM,OAAO,IAAI,IAAI,QAAQ,KAAK,mBAAmB,CAAC;EAEtD,MAAM,EAAE,QAAQ,QAAQ,YAAY,uBAAuB;GACzD,QAAQ,QAAQ;GAChB;GACA,WAAW,QAAQ,mBAAmB,OAAO,YAAY;GACzD;GACA,GAAG;GACJ,CAAC;AAEF,MAAI,SAAS;AACX,SAAM;AACN;;EAIF,MAAM,MAAM;AACZ,MAAI,MAAM;AACV,eAAa,IAAI,SAAS,EAAE,QAAQ,CAAC;AAErC,UAAQ,IAAI,cAAc,MAAM,CAAC;GACjC;AAEF,SAAQ,QAAQ,cAAc,OAAO,SAAS,UAAU;EACtD,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,QAAQ,IAAI,QAAQ,CAAE;AACpC,UAAQ,IAAI,QAAQ;AACpB,QAAM,MAAM,OAAO,EAAE,QAAQ,MAAM,YAAY,CAAC;GAChD;AAEF,SAAQ,QAAQ,WAAW,OAAO,SAAS,QAAQ,UAAU;EAC3D,MAAM,QAAQ,aAAa,IAAI,QAAQ;AACvC,MAAI,CAAC,SAAS,QAAQ,IAAI,QAAQ,CAAE;AACpC,UAAQ,IAAI,QAAQ;EACpB,MAAM,SAAU,QAAgB;EAChC,MAAM,MAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC;AACrE,MAAI,UAAU,OAAO,OAAO,UAAU,WAAY,QAAO,MAAM,IAAI;AACnE,QAAM,MAAM,OAAO,EAAE,OAAO,KAAK,CAAC;GAClC;AAEF,OAAM;;AAKR,MAAM,SAAS;AACf,OAAO,OAAO,IAAI,gBAAgB,IAAI;AACtC,OAAO,OAAO,IAAI,uBAAuB,IAAI;;;;;;;;;;;;;;;;;;;;;;AAuB7C,MAAa,QAAQ"}

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