evlog 1.7.0 → 1.9.0

package/README.md

@@ -4,13 +4,12 @@
 [![npm downloads](https://img.shields.io/npm/dm/evlog?color=black)](https://npm.chart.dev/evlog)
 [![CI](https://img.shields.io/github/actions/workflow/status/HugoRCD/evlog/ci.yml?branch=main&color=black)](https://github.com/HugoRCD/evlog/actions/workflows/ci.yml)
 [![TypeScript](https://img.shields.io/badge/TypeScript-black?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
-[![Nuxt](https://img.shields.io/badge/Nuxt-black?logo=nuxt&logoColor=white)](https://nuxt.com/)
 [![Documentation](https://img.shields.io/badge/Documentation-black?logo=readme&logoColor=white)](https://evlog.dev)
 [![license](https://img.shields.io/github/license/HugoRCD/evlog?color=black)](https://github.com/HugoRCD/evlog/blob/main/LICENSE)
 
 **Your logs are lying to you.**
 
-A single request generates 10+ log lines. When production breaks at 3am, you're grep-ing through noise, praying you'll find signal. Your errors say "Something went wrong" – thanks, very helpful.
+A single request generates 10+ log lines. When production breaks at 3am, you're grep-ing through noise, praying you'll find signal. Your errors say "Something went wrong" -- thanks, very helpful.
 
 **evlog fixes this.** One log per request. All context included. Errors that explain themselves.
 
@@ -21,13 +20,13 @@ A single request generates 10+ log lines. When production breaks at 3am, you're
 ```typescript
 // server/api/checkout.post.ts
 
-// ❌ Scattered logs - impossible to debug
+// Scattered logs - impossible to debug
 console.log('Request received')
 console.log('User:', user.id)
 console.log('Cart loaded')
 console.log('Payment failed')  // Good luck finding this at 3am
 
-throw new Error('Something went wrong')  // 🤷‍♂️
+throw new Error('Something went wrong')
 ```
 
 ### The Solution
@@ -36,7 +35,7 @@ throw new Error('Something went wrong')  // 🤷‍♂️
 // server/api/checkout.post.ts
 import { useLogger } from 'evlog'
 
-// ✅ One comprehensive event per request
+// One comprehensive event per request
 export default defineEventHandler(async (event) => {
   const log = useLogger(event)  // Auto-injected by evlog
 
@@ -176,18 +175,43 @@ The wide event emitted at the end contains **everything**:
 
 Works with **any framework powered by Nitro**: Nuxt, Analog, Vinxi, SolidStart, TanStack Start, and more.
 
+### Nitro v3
+
+```typescript
+// nitro.config.ts
+import { defineConfig } from 'nitro'
+import evlog from 'evlog/nitro/v3'
+
+export default defineConfig({
+  modules: [
+    evlog({ env: { service: 'my-api' } })
+  ],
+})
+```
+
+### Nitro v2
+
 ```typescript
 // nitro.config.ts
+import { defineNitroConfig } from 'nitropack/config'
+import evlog from 'evlog/nitro'
+
 export default defineNitroConfig({
-  plugins: ['evlog/nitro'],
+  modules: [
+    evlog({ env: { service: 'my-api' } })
+  ],
 })
 ```
 
-Same API, same wide events:
+Then use `useLogger` in any route. Import from `evlog/nitro/v3` (v3) or `evlog/nitro` (v2):
 
 ```typescript
 // routes/api/documents/[id]/export.post.ts
-import { useLogger, createError } from 'evlog'
+// Nitro v3: import { defineHandler } from 'nitro/h3' + import { useLogger } from 'evlog/nitro/v3'
+// Nitro v2: import { defineEventHandler } from 'h3' + import { useLogger } from 'evlog/nitro'
+import { defineEventHandler } from 'h3'
+import { useLogger } from 'evlog/nitro'
+import { createError } from 'evlog'
 
 export default defineEventHandler(async (event) => {
   const log = useLogger(event)
@@ -248,47 +272,6 @@ Output when the export completes:
 }
 ```
 
-## Structured Errors
-
-Errors should tell you **what** happened, **why**, and **how to fix it**.
-
-```typescript
-// server/api/repos/sync.post.ts
-import { useLogger, createError } from 'evlog'
-
-export default defineEventHandler(async (event) => {
-  const log = useLogger(event)
-
-  log.set({ repo: { owner: 'acme', name: 'my-project' } })
-
-  try {
-    const result = await syncWithGitHub()
-    log.set({ sync: { commits: result.commits, files: result.files } })
-    return result
-  } catch (error) {
-    log.error(error, { step: 'github-sync' })
-
-    throw createError({
-      message: 'Failed to sync repository',
-      status: 503,
-      why: 'GitHub API rate limit exceeded',
-      fix: 'Wait 1 hour or use a different token',
-      link: 'https://docs.github.com/en/rest/rate-limit',
-      cause: error,
-    })
-  }
-})
-```
-
-Console output (development):
-
-```
-Error: Failed to sync repository
-Why: GitHub API rate limit exceeded
-Fix: Wait 1 hour or use a different token
-More info: https://docs.github.com/en/rest/rate-limit
-```
-
 ## Standalone TypeScript
 
 For scripts, workers, or any TypeScript project:
@@ -390,6 +373,130 @@ Notes:
 - `request.cf` is included (colo, country, asn) unless disabled
 - Use `headerAllowlist` to avoid logging sensitive headers
 
+## 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'
+
+initLogger({
+  env: { service: 'hono-api' },
+})
+
+const app = new Hono()
+
+app.use('*', async (c, next) => {
+  const startedAt = Date.now()
+  const log = createRequestLogger({ method: c.req.method, path: c.req.path })
+
+  try {
+    await next()
+  } catch (error) {
+    log.error(error as Error)
+    throw error
+  } finally {
+    log.emit({
+      status: c.res.status,
+      duration: Date.now() - startedAt,
+    })
+  }
+})
+
+app.get('/health', (c) => c.json({ ok: true }))
+
+serve({ fetch: app.fetch, port: 3000 })
+```
+
+See the full [hono example](https://github.com/HugoRCD/evlog/tree/main/examples/hono) for a complete working project.
+
+## Browser
+
+Use the `log` API on the client side for structured browser logging:
+
+```typescript
+import { log } from 'evlog/browser'
+
+log.info('checkout', 'User initiated checkout')
+log.error({ action: 'payment', error: 'validation_failed' })
+```
+
+In Nuxt, `log` is auto-imported -- no import needed in Vue components:
+
+```vue
+<script setup>
+log.info('checkout', 'User initiated checkout')
+</script>
+```
+
+Client logs output to the browser console with colored tags in development.
+
+### Client Transport
+
+To send client logs to the server for centralized logging, enable the transport:
+
+```typescript
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['evlog/nuxt'],
+  evlog: {
+    transport: {
+      enabled: true,  // Send client logs to server
+    },
+  },
+})
+```
+
+When enabled:
+1. Client logs are sent to `/api/_evlog/ingest` via POST
+2. Server enriches with environment context (service, version, etc.)
+3. `evlog:drain` hook is called with `source: 'client'`
+4. External services receive the log
+
+## Structured Errors
+
+Errors should tell you **what** happened, **why**, and **how to fix it**.
+
+```typescript
+// server/api/repos/sync.post.ts
+import { useLogger, createError } from 'evlog'
+
+export default defineEventHandler(async (event) => {
+  const log = useLogger(event)
+
+  log.set({ repo: { owner: 'acme', name: 'my-project' } })
+
+  try {
+    const result = await syncWithGitHub()
+    log.set({ sync: { commits: result.commits, files: result.files } })
+    return result
+  } catch (error) {
+    log.error(error, { step: 'github-sync' })
+
+    throw createError({
+      message: 'Failed to sync repository',
+      status: 503,
+      why: 'GitHub API rate limit exceeded',
+      fix: 'Wait 1 hour or use a different token',
+      link: 'https://docs.github.com/en/rest/rate-limit',
+      cause: error,
+    })
+  }
+})
+```
+
+Console output (development):
+
+```
+Error: Failed to sync repository
+Why: GitHub API rate limit exceeded
+Fix: Wait 1 hour or use a different token
+More info: https://docs.github.com/en/rest/rate-limit
+```
+
 ## Enrichment Hook
 
 Use the `evlog:enrich` hook to add derived context after emit, before drain.
@@ -428,6 +535,58 @@ export default defineNitroPlugin((nitroApp) => {
 })
 ```
 
+Each enricher adds a specific field to the event:
+
+| Enricher | Event Field | Shape |
+|----------|-------------|-------|
+| `createUserAgentEnricher()` | `event.userAgent` | `{ raw, browser?: { name, version? }, os?: { name, version? }, device?: { type } }` |
+| `createGeoEnricher()` | `event.geo` | `{ country?, region?, regionCode?, city?, latitude?, longitude? }` |
+| `createRequestSizeEnricher()` | `event.requestSize` | `{ requestBytes?, responseBytes? }` |
+| `createTraceContextEnricher()` | `event.traceContext` + `event.traceId` + `event.spanId` | `{ traceparent?, tracestate?, traceId?, spanId? }` |
+
+All enrichers accept an optional `{ overwrite?: boolean }` option. By default (`overwrite: false`), user-provided data on the event takes precedence over enricher-computed values. Set `overwrite: true` to always replace existing fields.
+
+> **Cloudflare geo note:** Only `cf-ipcountry` is a real Cloudflare HTTP header. The `cf-region`, `cf-city`, `cf-latitude`, `cf-longitude` headers are NOT standard -- they are properties of `request.cf`. For full geo data on Cloudflare, write a custom enricher that reads `request.cf`, or use a Workers middleware to forward `cf` properties as custom headers.
+
+### Custom Enrichers
+
+The `evlog:enrich` hook receives an `EnrichContext` with these fields:
+
+```typescript
+interface EnrichContext {
+  event: WideEvent        // The emitted wide event (mutable -- modify it directly)
+  request?: {             // Request metadata
+    method?: string
+    path?: string
+    requestId?: string
+  }
+  headers?: Record<string, string>  // Safe HTTP headers (sensitive headers filtered)
+  response?: {            // Response metadata
+    status?: number
+    headers?: Record<string, string>
+  }
+}
+```
+
+Example custom enricher:
+
+```typescript
+// server/plugins/evlog-enrich.ts
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook('evlog:enrich', (ctx) => {
+    // Add deployment metadata
+    ctx.event.deploymentId = process.env.DEPLOYMENT_ID
+    ctx.event.region = process.env.FLY_REGION
+
+    // Extract data from headers
+    const tenantId = ctx.headers?.['x-tenant-id']
+    if (tenantId) {
+      ctx.event.tenantId = tenantId
+    }
+  })
+})
+```
+
 ## Adapters
 
 Send your logs to external observability platforms with built-in adapters.
@@ -469,6 +628,24 @@ Set environment variables:
 NUXT_OTLP_ENDPOINT=http://localhost:4318
 ```
 
+### PostHog
+
+```typescript
+// server/plugins/evlog-drain.ts
+import { createPostHogDrain } from 'evlog/posthog'
+
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook('evlog:drain', createPostHogDrain())
+})
+```
+
+Set environment variables:
+
+```bash
+NUXT_POSTHOG_API_KEY=phc_your-key
+NUXT_POSTHOG_HOST=https://us.i.posthog.com  # Optional: for EU or self-hosted
+```
+
 ### Sentry
 
 ```typescript
@@ -486,6 +663,23 @@ Set environment variables:
 NUXT_SENTRY_DSN=https://public@o0.ingest.sentry.io/123
 ```
 
+### Better Stack
+
+```typescript
+// server/plugins/evlog-drain.ts
+import { createBetterStackDrain } from 'evlog/better-stack'
+
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook('evlog:drain', createBetterStackDrain())
+})
+```
+
+Set environment variables:
+
+```bash
+NUXT_BETTER_STACK_SOURCE_TOKEN=your-source-token
+```
+
 ### Multiple Destinations
 
 Send logs to multiple services:
@@ -571,15 +765,15 @@ export default defineNitroPlugin((nitroApp) => {
 | `retry.initialDelayMs` | `1000` | Base delay for first retry |
 | `retry.maxDelayMs` | `30000` | Upper bound for any retry delay |
 | `maxBufferSize` | `1000` | Max buffered events before dropping oldest |
-| `onDropped` | — | Callback when events are dropped |
+| `onDropped` | -- | Callback when events are dropped |
 
 ### Returned drain function
 
 The function returned by `pipeline(drain)` is hook-compatible and exposes:
 
-- **`drain(ctx)`** — Push a single event into the buffer
-- **`drain.flush()`** — Force-flush all buffered events (call on server shutdown)
-- **`drain.pending`** — Number of events currently buffered
+- **`drain(ctx)`** -- Push a single event into the buffer
+- **`drain.flush()`** -- Force-flush all buffered events (call on server shutdown)
+- **`drain.pending`** -- Number of events currently buffered
 
 ## API Reference
 
@@ -589,6 +783,7 @@ Initialize the logger. Required for standalone usage, automatic with Nuxt/Nitro
 
 ```typescript
 initLogger({
+  enabled: boolean       // Optional. Enable/disable all logging (default: true)
   env: {
     service: string      // Service name
     environment: string  // 'production' | 'development' | 'test'
@@ -679,9 +874,9 @@ In development, evlog uses a compact tree format:
 
 ```
 16:45:31.060 INFO [my-app] GET /api/checkout 200 in 234ms
-  ├─ user: id=123 plan=premium
-  ├─ cart: items=3 total=9999
-  └─ payment: id=pay_xyz method=card
+  |- user: id=123 plan=premium
+  |- cart: items=3 total=9999
+  +- payment: id=pay_xyz method=card
 ```
 
 In production (`pretty: false`), logs are emitted as JSON for machine parsing.
@@ -797,11 +992,12 @@ evlog works with any framework powered by [Nitro](https://nitro.unjs.io/):
 | Framework | Integration |
 |-----------|-------------|
 | **Nuxt** | `modules: ['evlog/nuxt']` |
-| **Analog** | `plugins: ['evlog/nitro']` |
-| **Vinxi** | `plugins: ['evlog/nitro']` |
-| **SolidStart** | `plugins: ['evlog/nitro']` |
-| **TanStack Start** | `plugins: ['evlog/nitro']` |
-| **Standalone Nitro** | `plugins: ['evlog/nitro']` |
+| **Nitro v3** | `modules: [evlog()]` with `import evlog from 'evlog/nitro/v3'` |
+| **Nitro v2** | `modules: [evlog()]` with `import evlog from 'evlog/nitro'` |
+| **Analog** | Nitro v2 module setup |
+| **Vinxi** | Nitro v2 module setup |
+| **SolidStart** | Nitro v2 module setup ([example](./examples/solidstart)) |
+| **TanStack Start** | Nitro v2 module setup |
 
 ## Agent Skills
 

package/dist/_http-DVDwNag0.mjs

@@ -0,0 +1,76 @@
+import { createRequire } from "node:module";
+
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/adapters/_config.ts
+/**
+* Try to get runtime config from Nitro/Nuxt environment.
+* Returns undefined if not in a Nitro context.
+*/
+function getRuntimeConfig() {
+	try {
+		const { useRuntimeConfig } = __require("nitropack/runtime");
+		return useRuntimeConfig();
+	} catch {
+		return;
+	}
+}
+function resolveAdapterConfig(namespace, fields, overrides) {
+	const runtimeConfig = getRuntimeConfig();
+	const evlogNs = runtimeConfig?.evlog?.[namespace];
+	const rootNs = runtimeConfig?.[namespace];
+	const config = {};
+	for (const { key, env } of fields) config[key] = overrides?.[key] ?? evlogNs?.[key] ?? rootNs?.[key] ?? resolveEnv(env);
+	return config;
+}
+function resolveEnv(envKeys) {
+	if (!envKeys) return void 0;
+	for (const key of envKeys) {
+		const val = process.env[key];
+		if (val) return val;
+	}
+}
+
+//#endregion
+//#region src/adapters/_drain.ts
+function defineDrain(options) {
+	return async (ctx) => {
+		const contexts = Array.isArray(ctx) ? ctx : [ctx];
+		if (contexts.length === 0) return;
+		const config = options.resolve();
+		if (!config) return;
+		try {
+			await options.send(contexts.map((c) => c.event), config);
+		} catch (error) {
+			console.error(`[evlog/${options.name}] Failed to send events:`, error);
+		}
+	};
+}
+
+//#endregion
+//#region src/adapters/_http.ts
+async function httpPost({ url, headers, body, timeout, label }) {
+	const controller = new AbortController();
+	const timeoutId = setTimeout(() => controller.abort(), timeout);
+	try {
+		const response = await fetch(url, {
+			method: "POST",
+			headers,
+			body,
+			signal: controller.signal
+		});
+		if (!response.ok) {
+			const text = await response.text().catch(() => "Unknown error");
+			const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text;
+			throw new Error(`${label} API error: ${response.status} ${response.statusText} - ${safeText}`);
+		}
+	} finally {
+		clearTimeout(timeoutId);
+	}
+}
+
+//#endregion
+export { defineDrain as n, resolveAdapterConfig as r, httpPost as t };
+//# sourceMappingURL=_http-DVDwNag0.mjs.map

package/dist/_http-DVDwNag0.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_http-DVDwNag0.mjs","names":[],"sources":["../src/adapters/_config.ts","../src/adapters/_drain.ts","../src/adapters/_http.ts"],"sourcesContent":["/**\n * Try to get runtime config from Nitro/Nuxt environment.\n * Returns undefined if not in a Nitro context.\n */\nexport function getRuntimeConfig(): Record<string, any> | undefined {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { useRuntimeConfig } = require('nitropack/runtime')\n    return useRuntimeConfig()\n  } catch {\n    return undefined\n  }\n}\n\nexport interface ConfigField<T> {\n  key: keyof T & string\n  env?: string[]\n}\n\nexport function resolveAdapterConfig<T>(\n  namespace: string,\n  fields: ConfigField<T>[],\n  overrides?: Partial<T>,\n): Partial<T> {\n  const runtimeConfig = getRuntimeConfig()\n  const evlogNs = runtimeConfig?.evlog?.[namespace]\n  const rootNs = runtimeConfig?.[namespace]\n\n  const config: Record<string, unknown> = {}\n\n  for (const { key, env } of fields) {\n    config[key] =\n      overrides?.[key]\n      ?? evlogNs?.[key]\n      ?? rootNs?.[key]\n      ?? resolveEnv(env)\n  }\n\n  return config as Partial<T>\n}\n\nfunction resolveEnv(envKeys?: string[]): string | undefined {\n  if (!envKeys) return undefined\n  for (const key of envKeys) {\n    const val = process.env[key]\n    if (val) return val\n  }\n  return undefined\n}\n","import type { DrainContext, WideEvent } from '../types'\n\nexport interface DrainOptions<TConfig> {\n  name: string\n  resolve: () => TConfig | null\n  send: (events: WideEvent[], config: TConfig) => Promise<void>\n}\n\nexport function defineDrain<TConfig>(options: DrainOptions<TConfig>): (ctx: DrainContext | DrainContext[]) => Promise<void> {\n  return async (ctx: DrainContext | DrainContext[]) => {\n    const contexts = Array.isArray(ctx) ? ctx : [ctx]\n    if (contexts.length === 0) return\n\n    const config = options.resolve()\n    if (!config) return\n\n    try {\n      await options.send(contexts.map(c => c.event), config)\n    } catch (error) {\n      console.error(`[evlog/${options.name}] Failed to send events:`, error)\n    }\n  }\n}\n","export interface HttpPostOptions {\n  url: string\n  headers: Record<string, string>\n  body: string\n  timeout: number\n  label: string\n}\n\nexport async function httpPost({ url, headers, body, timeout, label }: HttpPostOptions): Promise<void> {\n  const controller = new AbortController()\n  const timeoutId = setTimeout(() => controller.abort(), timeout)\n\n  try {\n    const response = await fetch(url, {\n      method: 'POST',\n      headers,\n      body,\n      signal: controller.signal,\n    })\n\n    if (!response.ok) {\n      const text = await response.text().catch(() => 'Unknown error')\n      const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text\n      throw new Error(`${label} API error: ${response.status} ${response.statusText} - ${safeText}`)\n    }\n  } finally {\n    clearTimeout(timeoutId)\n  }\n}\n"],"mappings":";;;;;;;;;;;AAIA,SAAgB,mBAAoD;AAClE,KAAI;EAEF,MAAM,EAAE,+BAA6B,oBAAoB;AACzD,SAAO,kBAAkB;SACnB;AACN;;;AASJ,SAAgB,qBACd,WACA,QACA,WACY;CACZ,MAAM,gBAAgB,kBAAkB;CACxC,MAAM,UAAU,eAAe,QAAQ;CACvC,MAAM,SAAS,gBAAgB;CAE/B,MAAM,SAAkC,EAAE;AAE1C,MAAK,MAAM,EAAE,KAAK,SAAS,OACzB,QAAO,OACL,YAAY,QACT,UAAU,QACV,SAAS,QACT,WAAW,IAAI;AAGtB,QAAO;;AAGT,SAAS,WAAW,SAAwC;AAC1D,KAAI,CAAC,QAAS,QAAO;AACrB,MAAK,MAAM,OAAO,SAAS;EACzB,MAAM,MAAM,QAAQ,IAAI;AACxB,MAAI,IAAK,QAAO;;;;;;ACrCpB,SAAgB,YAAqB,SAAuF;AAC1H,QAAO,OAAO,QAAuC;EACnD,MAAM,WAAW,MAAM,QAAQ,IAAI,GAAG,MAAM,CAAC,IAAI;AACjD,MAAI,SAAS,WAAW,EAAG;EAE3B,MAAM,SAAS,QAAQ,SAAS;AAChC,MAAI,CAAC,OAAQ;AAEb,MAAI;AACF,SAAM,QAAQ,KAAK,SAAS,KAAI,MAAK,EAAE,MAAM,EAAE,OAAO;WAC/C,OAAO;AACd,WAAQ,MAAM,UAAU,QAAQ,KAAK,2BAA2B,MAAM;;;;;;;ACX5E,eAAsB,SAAS,EAAE,KAAK,SAAS,MAAM,SAAS,SAAyC;CACrG,MAAM,aAAa,IAAI,iBAAiB;CACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,QAAQ;AAE/D,KAAI;EACF,MAAM,WAAW,MAAM,MAAM,KAAK;GAChC,QAAQ;GACR;GACA;GACA,QAAQ,WAAW;GACpB,CAAC;AAEF,MAAI,CAAC,SAAS,IAAI;GAChB,MAAM,OAAO,MAAM,SAAS,MAAM,CAAC,YAAY,gBAAgB;GAC/D,MAAM,WAAW,KAAK,SAAS,MAAM,GAAG,KAAK,MAAM,GAAG,IAAI,CAAC,kBAAkB;AAC7E,SAAM,IAAI,MAAM,GAAG,MAAM,cAAc,SAAS,OAAO,GAAG,SAAS,WAAW,KAAK,WAAW;;WAExF;AACR,eAAa,UAAU"}

package/dist/_severity-CXfyvxQi.mjs

@@ -0,0 +1,17 @@
+//#region src/adapters/_severity.ts
+const OTEL_SEVERITY_NUMBER = {
+	debug: 5,
+	info: 9,
+	warn: 13,
+	error: 17
+};
+const OTEL_SEVERITY_TEXT = {
+	debug: "DEBUG",
+	info: "INFO",
+	warn: "WARN",
+	error: "ERROR"
+};
+
+//#endregion
+export { OTEL_SEVERITY_TEXT as n, OTEL_SEVERITY_NUMBER as t };
+//# sourceMappingURL=_severity-CXfyvxQi.mjs.map

package/dist/_severity-CXfyvxQi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"_severity-CXfyvxQi.mjs","names":[],"sources":["../src/adapters/_severity.ts"],"sourcesContent":["import type { LogLevel } from '../types'\n\nexport const OTEL_SEVERITY_NUMBER: Record<LogLevel, number> = {\n  debug: 5,\n  info: 9,\n  warn: 13,\n  error: 17,\n}\n\nexport const OTEL_SEVERITY_TEXT: Record<LogLevel, string> = {\n  debug: 'DEBUG',\n  info: 'INFO',\n  warn: 'WARN',\n  error: 'ERROR',\n}\n"],"mappings":";AAEA,MAAa,uBAAiD;CAC5D,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;CACR;AAED,MAAa,qBAA+C;CAC1D,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;CACR"}

package/dist/adapters/axiom.d.mts

@@ -1,4 +1,5 @@
 import { DrainContext, WideEvent } from "../types.mjs";
+import "../index.mjs";
 
 //#region src/adapters/axiom.d.ts
 interface AxiomConfig {

package/dist/adapters/axiom.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"axiom.d.mts","names":[],"sources":["../../src/adapters/axiom.ts"],"mappings":";;;UAGiB,WAAA;;EAEf,OAAA;EAF0B;EAI1B,KAAA;EAJ0B;EAM1B,KAAA;EAFA;EAIA,OAAA;EAAA;EAEA,OAAA;AAAA;;AAuBF;;;;;;;;;;;;;;;;;;;iBAAgB,gBAAA,CAAiB,SAAA,GAAY,OAAA,CAAQ,WAAA,KAAgB,GAAA,EAAK,YAAA,GAAe,YAAA,OAAmB,OAAA;;;;;;;;;;;;iBA2CtF,WAAA,CAAY,KAAA,EAAO,SAAA,EAAW,MAAA,EAAQ,WAAA,GAAc,OAAA;;;AAe1E;;;;;;;;;iBAAsB,gBAAA,CAAiB,MAAA,EAAQ,SAAA,IAAa,MAAA,EAAQ,WAAA,GAAc,OAAA"}
+{"version":3,"file":"axiom.d.mts","names":[],"sources":["../../src/adapters/axiom.ts"],"mappings":";;;;UAMiB,WAAA;;EAEf,OAAA;EAFe;EAIf,KAAA;;EAEA,KAAA;EAJA;EAMA,OAAA;EAFA;EAIA,OAAA;AAAA;;;AA+BF;;;;;;;;;;;;;;;;;;iBAAgB,gBAAA,CAAiB,SAAA,GAAY,OAAA,CAAQ,WAAA,KAAY,GAAA,EAAb,YAAA,GAAa,YAAA,OAAA,OAAA;AA0BjE;;;;;;;;;;;AAAA,iBAAsB,WAAA,CAAY,KAAA,EAAO,SAAA,EAAW,MAAA,EAAQ,WAAA,GAAc,OAAA;;;;AAe1E;;;;;;;;iBAAsB,gBAAA,CAAiB,MAAA,EAAQ,SAAA,IAAa,MAAA,EAAQ,WAAA,GAAc,OAAA"}

package/dist/adapters/axiom.mjs

@@ -1,6 +1,25 @@
-import { t as getRuntimeConfig } from "../_utils-DZA9nou3.mjs";
+import { n as defineDrain, r as resolveAdapterConfig, t as httpPost } from "../_http-DVDwNag0.mjs";
 
 //#region src/adapters/axiom.ts
+const AXIOM_FIELDS = [
+	{
+		key: "dataset",
+		env: ["NUXT_AXIOM_DATASET", "AXIOM_DATASET"]
+	},
+	{
+		key: "token",
+		env: ["NUXT_AXIOM_TOKEN", "AXIOM_TOKEN"]
+	},
+	{
+		key: "orgId",
+		env: ["NUXT_AXIOM_ORG_ID", "AXIOM_ORG_ID"]
+	},
+	{
+		key: "baseUrl",
+		env: ["NUXT_AXIOM_URL", "AXIOM_URL"]
+	},
+	{ key: "timeout" }
+];
 /**
 * Create a drain function for sending logs to Axiom.
 *
@@ -22,29 +41,18 @@ import { t as getRuntimeConfig } from "../_utils-DZA9nou3.mjs";
 * ```
 */
 function createAxiomDrain(overrides) {
-	return async (ctx) => {
-		const contexts = Array.isArray(ctx) ? ctx : [ctx];
-		if (contexts.length === 0) return;
-		const runtimeConfig = getRuntimeConfig();
-		const evlogAxiom = runtimeConfig?.evlog?.axiom;
-		const rootAxiom = runtimeConfig?.axiom;
-		const config = {
-			dataset: overrides?.dataset ?? evlogAxiom?.dataset ?? rootAxiom?.dataset ?? process.env.NUXT_AXIOM_DATASET ?? process.env.AXIOM_DATASET,
-			token: overrides?.token ?? evlogAxiom?.token ?? rootAxiom?.token ?? process.env.NUXT_AXIOM_TOKEN ?? process.env.AXIOM_TOKEN,
-			orgId: overrides?.orgId ?? evlogAxiom?.orgId ?? rootAxiom?.orgId ?? process.env.NUXT_AXIOM_ORG_ID ?? process.env.AXIOM_ORG_ID,
-			baseUrl: overrides?.baseUrl ?? evlogAxiom?.baseUrl ?? rootAxiom?.baseUrl ?? process.env.NUXT_AXIOM_URL ?? process.env.AXIOM_URL,
-			timeout: overrides?.timeout ?? evlogAxiom?.timeout ?? rootAxiom?.timeout
-		};
-		if (!config.dataset || !config.token) {
-			console.error("[evlog/axiom] Missing dataset or token. Set NUXT_AXIOM_TOKEN/NUXT_AXIOM_DATASET env vars or pass to createAxiomDrain()");
-			return;
-		}
-		try {
-			await sendBatchToAxiom(contexts.map((c) => c.event), config);
-		} catch (error) {
-			console.error("[evlog/axiom] Failed to send events to Axiom:", error);
-		}
-	};
+	return defineDrain({
+		name: "axiom",
+		resolve: () => {
+			const config = resolveAdapterConfig("axiom", AXIOM_FIELDS, overrides);
+			if (!config.dataset || !config.token) {
+				console.error("[evlog/axiom] Missing dataset or token. Set NUXT_AXIOM_TOKEN/NUXT_AXIOM_DATASET env vars or pass to createAxiomDrain()");
+				return null;
+			}
+			return config;
+		},
+		send: sendBatchToAxiom
+	});
 }
 /**
 * Send a single event to Axiom.
@@ -72,31 +80,19 @@ async function sendToAxiom(event, config) {
 * ```
 */
 async function sendBatchToAxiom(events, config) {
-	const baseUrl = config.baseUrl ?? "https://api.axiom.co";
-	const timeout = config.timeout ?? 5e3;
-	const url = `${baseUrl}/v1/datasets/${encodeURIComponent(config.dataset)}/ingest`;
+	const url = `${config.baseUrl ?? "https://api.axiom.co"}/v1/datasets/${encodeURIComponent(config.dataset)}/ingest`;
 	const headers = {
 		"Content-Type": "application/json",
 		"Authorization": `Bearer ${config.token}`
 	};
 	if (config.orgId) headers["X-Axiom-Org-Id"] = config.orgId;
-	const controller = new AbortController();
-	const timeoutId = setTimeout(() => controller.abort(), timeout);
-	try {
-		const response = await fetch(url, {
-			method: "POST",
-			headers,
-			body: JSON.stringify(events),
-			signal: controller.signal
-		});
-		if (!response.ok) {
-			const text = await response.text().catch(() => "Unknown error");
-			const safeText = text.length > 200 ? `${text.slice(0, 200)}...[truncated]` : text;
-			throw new Error(`Axiom API error: ${response.status} ${response.statusText} - ${safeText}`);
-		}
-	} finally {
-		clearTimeout(timeoutId);
-	}
+	await httpPost({
+		url,
+		headers,
+		body: JSON.stringify(events),
+		timeout: config.timeout ?? 5e3,
+		label: "Axiom"
+	});
 }
 
 //#endregion