evlog 1.4.0 → 1.6.0

package/README.md

@@ -431,6 +431,23 @@ Set environment variables:
 NUXT_OTLP_ENDPOINT=http://localhost:4318
 ```
 
+### Sentry
+
+```typescript
+// server/plugins/evlog-drain.ts
+import { createSentryDrain } from 'evlog/sentry'
+
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook('evlog:drain', createSentryDrain())
+})
+```
+
+Set environment variables:
+
+```bash
+NUXT_SENTRY_DSN=https://public@o0.ingest.sentry.io/123
+```
+
 ### Multiple Destinations
 
 Send logs to multiple services:

package/dist/adapters/axiom.mjs

@@ -1,11 +1,5 @@
-function getRuntimeConfig() {
-  try {
-    const { useRuntimeConfig } = require("nitropack/runtime");
-    return useRuntimeConfig();
-  } catch {
-    return void 0;
-  }
-}
+import { g as getRuntimeConfig } from '../shared/evlog.Bc35pxiY.mjs';
+
 function createAxiomDrain(overrides) {
   return async (ctx) => {
     const runtimeConfig = getRuntimeConfig();

package/dist/adapters/otlp.mjs

@@ -1,3 +1,5 @@
+import { g as getRuntimeConfig } from '../shared/evlog.Bc35pxiY.mjs';
+
 const SEVERITY_MAP = {
   debug: 5,
   // DEBUG
@@ -14,14 +16,6 @@ const SEVERITY_TEXT_MAP = {
   warn: "WARN",
   error: "ERROR"
 };
-function getRuntimeConfig() {
-  try {
-    const { useRuntimeConfig } = require("nitropack/runtime");
-    return useRuntimeConfig();
-  } catch {
-    return void 0;
-  }
-}
 function toAttributeValue(value) {
   if (typeof value === "boolean") {
     return { boolValue: value };

package/dist/adapters/posthog.d.mts

@@ -0,0 +1,72 @@
+import { DrainContext, WideEvent } from '../types.mjs';
+
+interface PostHogConfig {
+    /** PostHog project API key */
+    apiKey: string;
+    /** PostHog host URL. Default: https://us.i.posthog.com */
+    host?: string;
+    /** PostHog event name. Default: evlog_wide_event */
+    eventName?: string;
+    /** Override distinct_id (defaults to event.service) */
+    distinctId?: string;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/** PostHog event structure for the batch API */
+interface PostHogEvent {
+    event: string;
+    distinct_id: string;
+    timestamp: string;
+    properties: Record<string, unknown>;
+}
+/**
+ * Convert a WideEvent to a PostHog event format.
+ */
+declare function toPostHogEvent(event: WideEvent, config: PostHogConfig): PostHogEvent;
+/**
+ * Create a drain function for sending logs to PostHog.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createPostHogDrain()
+ * 2. runtimeConfig.evlog.posthog
+ * 3. runtimeConfig.posthog
+ * 4. Environment variables: NUXT_POSTHOG_*, POSTHOG_*
+ *
+ * @example
+ * ```ts
+ * // Zero config - just set NUXT_POSTHOG_API_KEY env var
+ * nitroApp.hooks.hook('evlog:drain', createPostHogDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createPostHogDrain({
+ *   apiKey: 'phc_...',
+ *   host: 'https://eu.i.posthog.com',
+ * }))
+ * ```
+ */
+declare function createPostHogDrain(overrides?: Partial<PostHogConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to PostHog.
+ *
+ * @example
+ * ```ts
+ * await sendToPostHog(event, {
+ *   apiKey: process.env.POSTHOG_API_KEY!,
+ * })
+ * ```
+ */
+declare function sendToPostHog(event: WideEvent, config: PostHogConfig): Promise<void>;
+/**
+ * Send a batch of events to PostHog.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToPostHog(events, {
+ *   apiKey: process.env.POSTHOG_API_KEY!,
+ * })
+ * ```
+ */
+declare function sendBatchToPostHog(events: WideEvent[], config: PostHogConfig): Promise<void>;
+
+export { createPostHogDrain, sendBatchToPostHog, sendToPostHog, toPostHogEvent };
+export type { PostHogConfig, PostHogEvent };

package/dist/adapters/posthog.d.ts

@@ -0,0 +1,72 @@
+import { DrainContext, WideEvent } from '../types.js';
+
+interface PostHogConfig {
+    /** PostHog project API key */
+    apiKey: string;
+    /** PostHog host URL. Default: https://us.i.posthog.com */
+    host?: string;
+    /** PostHog event name. Default: evlog_wide_event */
+    eventName?: string;
+    /** Override distinct_id (defaults to event.service) */
+    distinctId?: string;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/** PostHog event structure for the batch API */
+interface PostHogEvent {
+    event: string;
+    distinct_id: string;
+    timestamp: string;
+    properties: Record<string, unknown>;
+}
+/**
+ * Convert a WideEvent to a PostHog event format.
+ */
+declare function toPostHogEvent(event: WideEvent, config: PostHogConfig): PostHogEvent;
+/**
+ * Create a drain function for sending logs to PostHog.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createPostHogDrain()
+ * 2. runtimeConfig.evlog.posthog
+ * 3. runtimeConfig.posthog
+ * 4. Environment variables: NUXT_POSTHOG_*, POSTHOG_*
+ *
+ * @example
+ * ```ts
+ * // Zero config - just set NUXT_POSTHOG_API_KEY env var
+ * nitroApp.hooks.hook('evlog:drain', createPostHogDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createPostHogDrain({
+ *   apiKey: 'phc_...',
+ *   host: 'https://eu.i.posthog.com',
+ * }))
+ * ```
+ */
+declare function createPostHogDrain(overrides?: Partial<PostHogConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to PostHog.
+ *
+ * @example
+ * ```ts
+ * await sendToPostHog(event, {
+ *   apiKey: process.env.POSTHOG_API_KEY!,
+ * })
+ * ```
+ */
+declare function sendToPostHog(event: WideEvent, config: PostHogConfig): Promise<void>;
+/**
+ * Send a batch of events to PostHog.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToPostHog(events, {
+ *   apiKey: process.env.POSTHOG_API_KEY!,
+ * })
+ * ```
+ */
+declare function sendBatchToPostHog(events: WideEvent[], config: PostHogConfig): Promise<void>;
+
+export { createPostHogDrain, sendBatchToPostHog, sendToPostHog, toPostHogEvent };
+export type { PostHogConfig, PostHogEvent };

package/dist/adapters/posthog.mjs

@@ -0,0 +1,73 @@
+import { g as getRuntimeConfig } from '../shared/evlog.Bc35pxiY.mjs';
+
+function toPostHogEvent(event, config) {
+  const { timestamp, level, service, ...rest } = event;
+  return {
+    event: config.eventName ?? "evlog_wide_event",
+    distinct_id: config.distinctId ?? service,
+    timestamp,
+    properties: {
+      level,
+      service,
+      ...rest
+    }
+  };
+}
+function createPostHogDrain(overrides) {
+  return async (ctx) => {
+    const runtimeConfig = getRuntimeConfig();
+    const evlogPostHog = runtimeConfig?.evlog?.posthog;
+    const rootPostHog = runtimeConfig?.posthog;
+    const config = {
+      apiKey: overrides?.apiKey ?? evlogPostHog?.apiKey ?? rootPostHog?.apiKey ?? process.env.NUXT_POSTHOG_API_KEY ?? process.env.POSTHOG_API_KEY,
+      host: overrides?.host ?? evlogPostHog?.host ?? rootPostHog?.host ?? process.env.NUXT_POSTHOG_HOST ?? process.env.POSTHOG_HOST,
+      eventName: overrides?.eventName ?? evlogPostHog?.eventName ?? rootPostHog?.eventName,
+      distinctId: overrides?.distinctId ?? evlogPostHog?.distinctId ?? rootPostHog?.distinctId,
+      timeout: overrides?.timeout ?? evlogPostHog?.timeout ?? rootPostHog?.timeout
+    };
+    if (!config.apiKey) {
+      console.error("[evlog/posthog] Missing apiKey. Set NUXT_POSTHOG_API_KEY/POSTHOG_API_KEY env var or pass to createPostHogDrain()");
+      return;
+    }
+    try {
+      await sendToPostHog(ctx.event, config);
+    } catch (error) {
+      console.error("[evlog/posthog] Failed to send event:", error);
+    }
+  };
+}
+async function sendToPostHog(event, config) {
+  await sendBatchToPostHog([event], config);
+}
+async function sendBatchToPostHog(events, config) {
+  if (events.length === 0) return;
+  const host = (config.host ?? "https://us.i.posthog.com").replace(/\/$/, "");
+  const timeout = config.timeout ?? 5e3;
+  const url = `${host}/batch/`;
+  const batch = events.map((event) => toPostHogEvent(event, config));
+  const payload = {
+    api_key: config.apiKey,
+    batch
+  };
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload),
+      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(`PostHog API error: ${response.status} ${response.statusText} - ${safeText}`);
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+export { createPostHogDrain, sendBatchToPostHog, sendToPostHog, toPostHogEvent };

package/dist/adapters/sentry.d.mts

@@ -0,0 +1,78 @@
+import { DrainContext, WideEvent } from '../types.mjs';
+
+interface SentryConfig {
+    /** Sentry DSN */
+    dsn: string;
+    /** Environment override (defaults to event.environment) */
+    environment?: string;
+    /** Release version override (defaults to event.version) */
+    release?: string;
+    /** Additional tags to attach as attributes */
+    tags?: Record<string, string>;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/** Sentry Log attribute value with type annotation */
+interface SentryAttributeValue {
+    value: string | number | boolean;
+    type: 'string' | 'integer' | 'double' | 'boolean';
+}
+/** Sentry Structured Log payload */
+interface SentryLog {
+    timestamp: number;
+    trace_id: string;
+    level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    body: string;
+    severity_number: number;
+    attributes?: Record<string, SentryAttributeValue>;
+}
+declare function toSentryLog(event: WideEvent, config: SentryConfig): SentryLog;
+/**
+ * Create a drain function for sending logs to Sentry.
+ *
+ * Sends wide events as Sentry Structured Logs, visible in Explore > Logs
+ * in the Sentry dashboard.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createSentryDrain()
+ * 2. runtimeConfig.evlog.sentry
+ * 3. runtimeConfig.sentry
+ * 4. Environment variables: NUXT_SENTRY_*, SENTRY_*
+ *
+ * @example
+ * ```ts
+ * // Zero config - just set NUXT_SENTRY_DSN env var
+ * nitroApp.hooks.hook('evlog:drain', createSentryDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createSentryDrain({
+ *   dsn: 'https://public@o0.ingest.sentry.io/123',
+ * }))
+ * ```
+ */
+declare function createSentryDrain(overrides?: Partial<SentryConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to Sentry as a structured log.
+ *
+ * @example
+ * ```ts
+ * await sendToSentry(event, {
+ *   dsn: process.env.SENTRY_DSN!,
+ * })
+ * ```
+ */
+declare function sendToSentry(event: WideEvent, config: SentryConfig): Promise<void>;
+/**
+ * Send a batch of events to Sentry as structured logs via the Envelope endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToSentry(events, {
+ *   dsn: process.env.SENTRY_DSN!,
+ * })
+ * ```
+ */
+declare function sendBatchToSentry(events: WideEvent[], config: SentryConfig): Promise<void>;
+
+export { createSentryDrain, sendBatchToSentry, sendToSentry, toSentryLog };
+export type { SentryAttributeValue, SentryConfig, SentryLog };

package/dist/adapters/sentry.d.ts

@@ -0,0 +1,78 @@
+import { DrainContext, WideEvent } from '../types.js';
+
+interface SentryConfig {
+    /** Sentry DSN */
+    dsn: string;
+    /** Environment override (defaults to event.environment) */
+    environment?: string;
+    /** Release version override (defaults to event.version) */
+    release?: string;
+    /** Additional tags to attach as attributes */
+    tags?: Record<string, string>;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/** Sentry Log attribute value with type annotation */
+interface SentryAttributeValue {
+    value: string | number | boolean;
+    type: 'string' | 'integer' | 'double' | 'boolean';
+}
+/** Sentry Structured Log payload */
+interface SentryLog {
+    timestamp: number;
+    trace_id: string;
+    level: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    body: string;
+    severity_number: number;
+    attributes?: Record<string, SentryAttributeValue>;
+}
+declare function toSentryLog(event: WideEvent, config: SentryConfig): SentryLog;
+/**
+ * Create a drain function for sending logs to Sentry.
+ *
+ * Sends wide events as Sentry Structured Logs, visible in Explore > Logs
+ * in the Sentry dashboard.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createSentryDrain()
+ * 2. runtimeConfig.evlog.sentry
+ * 3. runtimeConfig.sentry
+ * 4. Environment variables: NUXT_SENTRY_*, SENTRY_*
+ *
+ * @example
+ * ```ts
+ * // Zero config - just set NUXT_SENTRY_DSN env var
+ * nitroApp.hooks.hook('evlog:drain', createSentryDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createSentryDrain({
+ *   dsn: 'https://public@o0.ingest.sentry.io/123',
+ * }))
+ * ```
+ */
+declare function createSentryDrain(overrides?: Partial<SentryConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to Sentry as a structured log.
+ *
+ * @example
+ * ```ts
+ * await sendToSentry(event, {
+ *   dsn: process.env.SENTRY_DSN!,
+ * })
+ * ```
+ */
+declare function sendToSentry(event: WideEvent, config: SentryConfig): Promise<void>;
+/**
+ * Send a batch of events to Sentry as structured logs via the Envelope endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToSentry(events, {
+ *   dsn: process.env.SENTRY_DSN!,
+ * })
+ * ```
+ */
+declare function sendBatchToSentry(events: WideEvent[], config: SentryConfig): Promise<void>;
+
+export { createSentryDrain, sendBatchToSentry, sendToSentry, toSentryLog };
+export type { SentryAttributeValue, SentryConfig, SentryLog };

package/dist/adapters/sentry.mjs

@@ -0,0 +1,176 @@
+import { g as getRuntimeConfig } from '../shared/evlog.Bc35pxiY.mjs';
+
+const SEVERITY_MAP = {
+  debug: 5,
+  info: 9,
+  warn: 13,
+  error: 17
+};
+function parseSentryDsn(dsn) {
+  const url = new URL(dsn);
+  const publicKey = url.username;
+  if (!publicKey) {
+    throw new Error("Invalid Sentry DSN: missing public key");
+  }
+  const secretKey = url.password || void 0;
+  const pathParts = url.pathname.split("/").filter(Boolean);
+  const projectId = pathParts.pop();
+  if (!projectId) {
+    throw new Error("Invalid Sentry DSN: missing project ID");
+  }
+  const basePath = pathParts.length > 0 ? `/${pathParts.join("/")}` : "";
+  return {
+    publicKey,
+    secretKey,
+    projectId,
+    origin: `${url.protocol}//${url.host}`,
+    basePath
+  };
+}
+function getSentryEnvelopeUrl(dsn) {
+  const { publicKey, secretKey, projectId, origin, basePath } = parseSentryDsn(dsn);
+  const url = `${origin}${basePath}/api/${projectId}/envelope/`;
+  let authHeader = `Sentry sentry_version=7, sentry_key=${publicKey}, sentry_client=evlog`;
+  if (secretKey) {
+    authHeader += `, sentry_secret=${secretKey}`;
+  }
+  return { url, authHeader };
+}
+function createTraceId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID().replace(/-/g, "");
+  }
+  return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+function getFirstStringValue(event, keys) {
+  for (const key of keys) {
+    const value = event[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return void 0;
+}
+function toAttributeValue(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return { value, type: "string" };
+  }
+  if (typeof value === "boolean") {
+    return { value, type: "boolean" };
+  }
+  if (typeof value === "number") {
+    if (Number.isInteger(value)) {
+      return { value, type: "integer" };
+    }
+    return { value, type: "double" };
+  }
+  return { value: JSON.stringify(value), type: "string" };
+}
+function toSentryLog(event, config) {
+  const { timestamp, level, service, environment, version, ...rest } = event;
+  const body = getFirstStringValue(event, ["message", "action", "path"]) ?? "evlog wide event";
+  const traceId = typeof event.traceId === "string" && event.traceId.length > 0 ? event.traceId : createTraceId();
+  const attributes = {};
+  const env = config.environment ?? environment;
+  if (env) {
+    attributes["sentry.environment"] = { value: env, type: "string" };
+  }
+  const rel = config.release ?? version;
+  if (typeof rel === "string" && rel.length > 0) {
+    attributes["sentry.release"] = { value: rel, type: "string" };
+  }
+  attributes["service"] = { value: service, type: "string" };
+  if (config.tags) {
+    for (const [key, value] of Object.entries(config.tags)) {
+      attributes[key] = { value, type: "string" };
+    }
+  }
+  for (const [key, value] of Object.entries(rest)) {
+    if (key === "traceId" || key === "spanId") continue;
+    if (value === void 0 || value === null) continue;
+    const attr = toAttributeValue(value);
+    if (attr) {
+      attributes[key] = attr;
+    }
+  }
+  return {
+    timestamp: new Date(timestamp).getTime() / 1e3,
+    trace_id: traceId,
+    level,
+    body,
+    severity_number: SEVERITY_MAP[level] ?? 9,
+    attributes
+  };
+}
+function buildEnvelopeBody(logs, dsn) {
+  const envelopeHeader = JSON.stringify({
+    dsn,
+    sent_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const itemHeader = JSON.stringify({
+    type: "log",
+    item_count: logs.length,
+    content_type: "application/vnd.sentry.items.log+json"
+  });
+  const itemPayload = JSON.stringify({ items: logs });
+  return `${envelopeHeader}
+${itemHeader}
+${itemPayload}
+`;
+}
+function createSentryDrain(overrides) {
+  return async (ctx) => {
+    const runtimeConfig = getRuntimeConfig();
+    const evlogSentry = runtimeConfig?.evlog?.sentry;
+    const rootSentry = runtimeConfig?.sentry;
+    const config = {
+      dsn: overrides?.dsn ?? evlogSentry?.dsn ?? rootSentry?.dsn ?? process.env.NUXT_SENTRY_DSN ?? process.env.SENTRY_DSN,
+      environment: overrides?.environment ?? evlogSentry?.environment ?? rootSentry?.environment ?? process.env.NUXT_SENTRY_ENVIRONMENT ?? process.env.SENTRY_ENVIRONMENT,
+      release: overrides?.release ?? evlogSentry?.release ?? rootSentry?.release ?? process.env.NUXT_SENTRY_RELEASE ?? process.env.SENTRY_RELEASE,
+      tags: overrides?.tags ?? evlogSentry?.tags ?? rootSentry?.tags,
+      timeout: overrides?.timeout ?? evlogSentry?.timeout ?? rootSentry?.timeout
+    };
+    if (!config.dsn) {
+      console.error("[evlog/sentry] Missing DSN. Set NUXT_SENTRY_DSN/SENTRY_DSN env var or pass to createSentryDrain()");
+      return;
+    }
+    try {
+      await sendToSentry(ctx.event, config);
+    } catch (error) {
+      console.error("[evlog/sentry] Failed to send log:", error);
+    }
+  };
+}
+async function sendToSentry(event, config) {
+  await sendBatchToSentry([event], config);
+}
+async function sendBatchToSentry(events, config) {
+  if (events.length === 0) return;
+  const { url, authHeader } = getSentryEnvelopeUrl(config.dsn);
+  const timeout = config.timeout ?? 5e3;
+  const logs = events.map((event) => toSentryLog(event, config));
+  const body = buildEnvelopeBody(logs, config.dsn);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-sentry-envelope",
+        "X-Sentry-Auth": authHeader
+      },
+      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(`Sentry API error: ${response.status} ${response.statusText} - ${safeText}`);
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+export { createSentryDrain, sendBatchToSentry, sendToSentry, toSentryLog };

package/dist/index.mjs

@@ -3,4 +3,3 @@ export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep } from
 export { useLogger } from './runtime/server/useLogger.mjs';
 export { parseError } from './runtime/utils/parseError.mjs';
 import './utils.mjs';
-import 'defu';

package/dist/logger.mjs

@@ -1,6 +1,21 @@
-import { defu } from 'defu';
 import { isDev, detectEnvironment, formatDuration, matchesPattern, getConsoleMethod, colors, getLevelColor } from './utils.mjs';
 
+function isPlainObject(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function deepDefaults(base, defaults) {
+  const result = { ...base };
+  for (const key in defaults) {
+    const baseVal = result[key];
+    const defaultVal = defaults[key];
+    if (baseVal === void 0 || baseVal === null) {
+      result[key] = defaultVal;
+    } else if (isPlainObject(baseVal) && isPlainObject(defaultVal)) {
+      result[key] = deepDefaults(baseVal, defaultVal);
+    }
+  }
+  return result;
+}
 let globalEnv = {
   service: "app",
   environment: "development"
@@ -154,7 +169,7 @@ function createRequestLogger(options = {}) {
   let hasError = false;
   return {
     set(data) {
-      context = defu(data, context);
+      context = deepDefaults(data, context);
     },
     error(error, errorContext) {
       hasError = true;
@@ -167,7 +182,7 @@ function createRequestLogger(options = {}) {
           stack: err.stack
         }
       };
-      context = defu(errorData, context);
+      context = deepDefaults(errorData, context);
     },
     emit(overrides) {
       const durationMs = Date.now() - startTime;

package/dist/nitro/plugin.mjs

@@ -2,7 +2,6 @@ import { defineNitroPlugin, useRuntimeConfig } from 'nitropack/runtime';
 import { getHeaders } from 'h3';
 import { initLogger, createRequestLogger } from '../logger.mjs';
 import { matchesPattern } from '../utils.mjs';
-import 'defu';
 
 function shouldLog(path, include, exclude) {
   if (exclude && exclude.length > 0) {
@@ -63,9 +62,9 @@ function callDrainHook(nitroApp, emittedEvent, event) {
   }).catch((err) => {
     console.error("[evlog] drain failed:", err);
   });
-  const waitUntil = event.context.cloudflare?.context?.waitUntil ?? event.context.waitUntil;
-  if (typeof waitUntil === "function") {
-    waitUntil(drainPromise);
+  const waitUntilCtx = event.context.cloudflare?.context ?? event.context;
+  if (typeof waitUntilCtx?.waitUntil === "function") {
+    waitUntilCtx.waitUntil(drainPromise);
   }
 }
 const plugin = defineNitroPlugin((nitroApp) => {
@@ -82,10 +81,15 @@ const plugin = defineNitroPlugin((nitroApp) => {
       return;
     }
     e.context._evlogStartTime = Date.now();
+    let requestIdOverride = void 0;
+    if (globalThis.navigator?.userAgent === "Cloudflare-Workers") {
+      const cfRay = getSafeHeaders(event)?.["cf-ray"];
+      if (cfRay) requestIdOverride = cfRay;
+    }
     const log = createRequestLogger({
       method: e.method,
       path: e.path,
-      requestId: e.context.requestId || crypto.randomUUID()
+      requestId: requestIdOverride || e.context.requestId || crypto.randomUUID()
     });
     const routeService = getServiceForPath(e.path, evlogConfig?.routes);
     if (routeService) {

package/dist/nuxt/module.d.mts

@@ -118,6 +118,52 @@ interface ModuleOptions {
         /** Request timeout in milliseconds. Default: 5000 */
         timeout?: number;
     };
+    /**
+     * PostHog adapter configuration.
+     * When configured, use `createPostHogDrain()` from `evlog/posthog` to send logs.
+     *
+     * @example
+     * ```ts
+     * posthog: {
+     *   apiKey: process.env.POSTHOG_API_KEY,
+     * }
+     * ```
+     */
+    posthog?: {
+        /** PostHog project API key */
+        apiKey: string;
+        /** PostHog host URL. Default: https://us.i.posthog.com */
+        host?: string;
+        /** PostHog event name. Default: evlog_wide_event */
+        eventName?: string;
+        /** Override distinct_id (defaults to event.service) */
+        distinctId?: string;
+        /** Request timeout in milliseconds. Default: 5000 */
+        timeout?: number;
+    };
+    /**
+     * Sentry adapter configuration.
+     * When configured, use `createSentryDrain()` from `evlog/sentry` to send logs.
+     *
+     * @example
+     * ```ts
+     * sentry: {
+     *   dsn: process.env.SENTRY_DSN,
+     * }
+     * ```
+     */
+    sentry?: {
+        /** Sentry DSN */
+        dsn: string;
+        /** Environment override (defaults to event.environment) */
+        environment?: string;
+        /** Release version override (defaults to event.version) */
+        release?: string;
+        /** Additional tags to attach as attributes */
+        tags?: Record<string, string>;
+        /** Request timeout in milliseconds. Default: 5000 */
+        timeout?: number;
+    };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/nuxt/module.d.ts

@@ -118,6 +118,52 @@ interface ModuleOptions {
         /** Request timeout in milliseconds. Default: 5000 */
         timeout?: number;
     };
+    /**
+     * PostHog adapter configuration.
+     * When configured, use `createPostHogDrain()` from `evlog/posthog` to send logs.
+     *
+     * @example
+     * ```ts
+     * posthog: {
+     *   apiKey: process.env.POSTHOG_API_KEY,
+     * }
+     * ```
+     */
+    posthog?: {
+        /** PostHog project API key */
+        apiKey: string;
+        /** PostHog host URL. Default: https://us.i.posthog.com */
+        host?: string;
+        /** PostHog event name. Default: evlog_wide_event */
+        eventName?: string;
+        /** Override distinct_id (defaults to event.service) */
+        distinctId?: string;
+        /** Request timeout in milliseconds. Default: 5000 */
+        timeout?: number;
+    };
+    /**
+     * Sentry adapter configuration.
+     * When configured, use `createSentryDrain()` from `evlog/sentry` to send logs.
+     *
+     * @example
+     * ```ts
+     * sentry: {
+     *   dsn: process.env.SENTRY_DSN,
+     * }
+     * ```
+     */
+    sentry?: {
+        /** Sentry DSN */
+        dsn: string;
+        /** Environment override (defaults to event.environment) */
+        environment?: string;
+        /** Release version override (defaults to event.version) */
+        release?: string;
+        /** Additional tags to attach as attributes */
+        tags?: Record<string, string>;
+        /** Request timeout in milliseconds. Default: 5000 */
+        timeout?: number;
+    };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/runtime/server/routes/_evlog/ingest.post.mjs

@@ -1,7 +1,6 @@
 import { defineEventHandler, readBody, setResponseStatus, getHeader, getRequestHost, createError } from 'h3';
 import { useNitroApp } from 'nitropack/runtime';
 import { getEnvironment } from '../../../../logger.mjs';
-import 'defu';
 import '../../../../utils.mjs';
 
 const VALID_LEVELS = ["info", "error", "warn", "debug"];

package/dist/shared/evlog.Bc35pxiY.mjs

@@ -0,0 +1,10 @@
+function getRuntimeConfig() {
+  try {
+    const { useRuntimeConfig } = require("nitropack/runtime");
+    return useRuntimeConfig();
+  } catch {
+    return void 0;
+  }
+}
+
+export { getRuntimeConfig as g };

package/dist/workers.mjs

@@ -1,5 +1,4 @@
 import { createRequestLogger, initLogger } from './logger.mjs';
-import 'defu';
 import './utils.mjs';
 
 function isRecord(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evlog",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Wide event logging library with structured error handling. Inspired by LoggingSucks.",
   "author": "HugoRCD <contact@hrcd.fr>",
   "homepage": "https://evlog.dev",
@@ -46,6 +46,14 @@
     "./otlp": {
       "types": "./dist/adapters/otlp.d.mts",
       "import": "./dist/adapters/otlp.mjs"
+    },
+    "./posthog": {
+      "types": "./dist/adapters/posthog.d.mts",
+      "import": "./dist/adapters/posthog.mjs"
+    },
+    "./sentry": {
+      "types": "./dist/adapters/sentry.d.mts",
+      "import": "./dist/adapters/sentry.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -69,6 +77,12 @@
       ],
       "otlp": [
         "./dist/adapters/otlp.d.mts"
+      ],
+      "posthog": [
+        "./dist/adapters/posthog.d.mts"
+      ],
+      "sentry": [
+        "./dist/adapters/sentry.d.mts"
       ]
     }
   },
@@ -87,27 +101,27 @@
     "test:coverage": "vitest run --coverage",
     "typecheck": "echo 'Typecheck handled by build'"
   },
-  "dependencies": {
-    "@nuxt/kit": "^4.3.0",
-    "defu": "^6.1.4"
-  },
   "devDependencies": {
     "@nuxt/devtools": "^3.1.1",
-    "@nuxt/schema": "^4.3.0",
+    "@nuxt/schema": "^4.3.1",
     "@nuxt/test-utils": "^3.23.0",
     "changelogen": "^0.6.2",
     "h3": "^1.15.5",
     "nitropack": "^2.13.1",
-    "nuxt": "^4.3.0",
+    "nuxt": "^4.3.1",
     "typescript": "^5.9.3",
     "unbuild": "^3.6.1"
   },
   "peerDependencies": {
+    "@nuxt/kit": "^4.3.1",
     "h3": "^1.15.5",
     "nitropack": "^2.13.1",
     "ofetch": "^1.5.1"
   },
   "peerDependenciesMeta": {
+    "@nuxt/kit": {
+      "optional": true
+    },
     "h3": {
       "optional": true
     },