evlog 1.1.0 → 1.2.0

package/dist/error.d.mts

@@ -16,16 +16,23 @@ import { ErrorOptions } from './types.mjs';
  * ```
  */
 declare class EvlogError extends Error {
+    /** HTTP status code */
     readonly status: number;
     readonly why?: string;
     readonly fix?: string;
     readonly link?: string;
     constructor(options: ErrorOptions | string);
+    /** HTTP status text (alias for message) */
+    get statusText(): string;
+    /** HTTP status code (alias for compatibility) */
     get statusCode(): number;
+    /** HTTP status message (alias for compatibility) */
+    get statusMessage(): string;
+    /** Structured data for serialization */
     get data(): {
-        why: string | undefined;
-        fix: string | undefined;
-        link: string | undefined;
+        why?: string;
+        fix?: string;
+        link?: string;
     } | undefined;
     toString(): string;
     toJSON(): Record<string, unknown>;
@@ -34,7 +41,7 @@ declare class EvlogError extends Error {
  * Create a structured error with context for debugging and user-facing messages.
  *
  * @param options - Error message string or full options object
- * @returns EvlogError instance compatible with Nitro's error handling
+ * @returns EvlogError with HTTP metadata (`status`, `statusText`) and `data`; also includes `statusCode` and `statusMessage` for legacy compatibility
  *
  * @example
  * ```ts
@@ -52,6 +59,5 @@ declare class EvlogError extends Error {
  * ```
  */
 declare function createError(options: ErrorOptions | string): EvlogError;
-declare const createEvlogError: typeof createError;
 
-export { EvlogError, createError, createEvlogError };
+export { EvlogError, createError, createError as createEvlogError };

package/dist/error.d.ts

@@ -16,16 +16,23 @@ import { ErrorOptions } from './types.js';
  * ```
  */
 declare class EvlogError extends Error {
+    /** HTTP status code */
     readonly status: number;
     readonly why?: string;
     readonly fix?: string;
     readonly link?: string;
     constructor(options: ErrorOptions | string);
+    /** HTTP status text (alias for message) */
+    get statusText(): string;
+    /** HTTP status code (alias for compatibility) */
     get statusCode(): number;
+    /** HTTP status message (alias for compatibility) */
+    get statusMessage(): string;
+    /** Structured data for serialization */
     get data(): {
-        why: string | undefined;
-        fix: string | undefined;
-        link: string | undefined;
+        why?: string;
+        fix?: string;
+        link?: string;
     } | undefined;
     toString(): string;
     toJSON(): Record<string, unknown>;
@@ -34,7 +41,7 @@ declare class EvlogError extends Error {
  * Create a structured error with context for debugging and user-facing messages.
  *
  * @param options - Error message string or full options object
- * @returns EvlogError instance compatible with Nitro's error handling
+ * @returns EvlogError with HTTP metadata (`status`, `statusText`) and `data`; also includes `statusCode` and `statusMessage` for legacy compatibility
  *
  * @example
  * ```ts
@@ -52,6 +59,5 @@ declare class EvlogError extends Error {
  * ```
  */
 declare function createError(options: ErrorOptions | string): EvlogError;
-declare const createEvlogError: typeof createError;
 
-export { EvlogError, createError, createEvlogError };
+export { EvlogError, createError, createError as createEvlogError };

package/dist/error.mjs

@@ -1,6 +1,7 @@
 import { colors, isServer } from './utils.mjs';
 
 class EvlogError extends Error {
+  /** HTTP status code */
   status;
   why;
   fix;
@@ -17,11 +18,24 @@ class EvlogError extends Error {
       Error.captureStackTrace(this, EvlogError);
     }
   }
+  /** HTTP status text (alias for message) */
+  get statusText() {
+    return this.message;
+  }
+  /** HTTP status code (alias for compatibility) */
   get statusCode() {
     return this.status;
   }
+  /** HTTP status message (alias for compatibility) */
+  get statusMessage() {
+    return this.message;
+  }
+  /** Structured data for serialization */
   get data() {
-    return this.why || this.fix || this.link ? { why: this.why, fix: this.fix, link: this.link } : void 0;
+    if (this.why || this.fix || this.link) {
+      return { why: this.why, fix: this.fix, link: this.link };
+    }
+    return void 0;
   }
   toString() {
     const useColors = isServer();
@@ -48,21 +62,20 @@ class EvlogError extends Error {
     return lines.join("\n");
   }
   toJSON() {
+    const { data } = this;
     return {
       name: this.name,
       message: this.message,
       status: this.status,
-      why: this.why,
-      fix: this.fix,
-      link: this.link,
-      cause: this.cause instanceof Error ? { name: this.cause.name, message: this.cause.message } : void 0,
-      stack: this.stack
+      ...data && { data },
+      ...this.cause instanceof Error && {
+        cause: { name: this.cause.name, message: this.cause.message }
+      }
     };
   }
 }
 function createError(options) {
   return new EvlogError(options);
 }
-const createEvlogError = createError;
 
-export { EvlogError, createError, createEvlogError };
+export { EvlogError, createError, createError as createEvlogError };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-export { EvlogError, createError, createEvlogError } from './error.mjs';
+export { EvlogError, createError, createError as createEvlogError } from './error.mjs';
 export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep } from './logger.mjs';
 export { useLogger } from './runtime/server/useLogger.mjs';
 export { parseError } from './runtime/utils/parseError.mjs';
-export { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, WideEvent } from './types.mjs';
+export { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, IngestPayload, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent } from './types.mjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { EvlogError, createError, createEvlogError } from './error.js';
+export { EvlogError, createError, createError as createEvlogError } from './error.js';
 export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep } from './logger.js';
 export { useLogger } from './runtime/server/useLogger.js';
 export { parseError } from './runtime/utils/parseError.js';
-export { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, WideEvent } from './types.js';
+export { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, IngestPayload, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent } from './types.js';

package/dist/index.mjs

@@ -1,5 +1,6 @@
-export { EvlogError, createError, createEvlogError } from './error.mjs';
+export { EvlogError, createError, createError as createEvlogError } from './error.mjs';
 export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep } from './logger.mjs';
 export { useLogger } from './runtime/server/useLogger.mjs';
 export { parseError } from './runtime/utils/parseError.mjs';
 import './utils.mjs';
+import 'defu';

package/dist/logger.mjs

@@ -1,3 +1,4 @@
+import { defu } from 'defu';
 import { isDev, detectEnvironment, formatDuration, matchesPattern, getConsoleMethod, colors, getLevelColor } from './utils.mjs';
 
 let globalEnv = {
@@ -149,13 +150,12 @@ function createRequestLogger(options = {}) {
   let hasError = false;
   return {
     set(data) {
-      context = { ...context, ...data };
+      context = defu(data, context);
     },
     error(error, errorContext) {
       hasError = true;
       const err = typeof error === "string" ? new Error(error) : error;
-      context = {
-        ...context,
+      const errorData = {
         ...errorContext,
         error: {
           name: err.name,
@@ -163,6 +163,7 @@ function createRequestLogger(options = {}) {
           stack: err.stack
         }
       };
+      context = defu(errorData, context);
     },
     emit(overrides) {
       const durationMs = Date.now() - startTime;

package/dist/nitro/errorHandler.d.mts

@@ -0,0 +1,13 @@
+import * as nitropack from 'nitropack';
+
+/**
+ * Custom Nitro error handler that properly serializes EvlogError.
+ * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved
+ * in the JSON response regardless of the underlying HTTP framework.
+ *
+ * For non-EvlogError, it preserves Nitro's default response shape while
+ * sanitizing internal error details in production for 5xx errors.
+ */
+declare const _default: nitropack.NitroErrorHandler;
+
+export { _default as default };

package/dist/nitro/errorHandler.d.ts

@@ -0,0 +1,13 @@
+import * as nitropack from 'nitropack';
+
+/**
+ * Custom Nitro error handler that properly serializes EvlogError.
+ * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved
+ * in the JSON response regardless of the underlying HTTP framework.
+ *
+ * For non-EvlogError, it preserves Nitro's default response shape while
+ * sanitizing internal error details in production for 5xx errors.
+ */
+declare const _default: nitropack.NitroErrorHandler;
+
+export { _default as default };

package/dist/nitro/errorHandler.mjs

@@ -0,0 +1,41 @@
+import { defineNitroErrorHandler } from 'nitropack/runtime';
+import { getRequestURL, setResponseStatus, setResponseHeader, send } from 'h3';
+
+const errorHandler = defineNitroErrorHandler((error, event) => {
+  const evlogError = error.name === "EvlogError" ? error : error.cause?.name === "EvlogError" ? error.cause : null;
+  const isDev = process.env.NODE_ENV === "development";
+  const url = getRequestURL(event, { xForwardedHost: true }).pathname;
+  if (!evlogError) {
+    const status2 = error.statusCode ?? error.status ?? 500;
+    const rawMessage = (error.statusText ?? error.statusMessage ?? error.message) || "Internal Server Error";
+    const message = isDev ? rawMessage : status2 >= 500 ? "Internal Server Error" : rawMessage;
+    setResponseStatus(event, status2);
+    setResponseHeader(event, "Content-Type", "application/json");
+    return send(event, JSON.stringify({
+      url,
+      status: status2,
+      statusCode: status2,
+      statusText: message,
+      statusMessage: message,
+      message,
+      error: true
+    }));
+  }
+  const status = evlogError.status ?? evlogError.statusCode ?? 500;
+  setResponseStatus(event, status);
+  setResponseHeader(event, "Content-Type", "application/json");
+  const { data } = evlogError;
+  const statusMessage = evlogError.statusMessage || evlogError.message;
+  return send(event, JSON.stringify({
+    url,
+    status,
+    statusCode: status,
+    statusText: statusMessage,
+    statusMessage,
+    message: evlogError.message,
+    error: true,
+    ...data !== void 0 && { data }
+  }));
+});
+
+export { errorHandler as default };

package/dist/nitro/plugin.mjs

@@ -1,13 +1,38 @@
 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) {
+function shouldLog(path, include, exclude) {
+  if (exclude && exclude.length > 0) {
+    if (exclude.some((pattern) => matchesPattern(path, pattern))) {
+      return false;
+    }
+  }
   if (!include || include.length === 0) {
     return true;
   }
   return include.some((pattern) => matchesPattern(path, pattern));
 }
+const SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "proxy-authorization"
+];
+function getSafeHeaders(event) {
+  const allHeaders = getHeaders(event);
+  const safeHeaders = {};
+  for (const [key, value] of Object.entries(allHeaders)) {
+    if (!SENSITIVE_HEADERS.includes(key.toLowerCase())) {
+      safeHeaders[key] = value;
+    }
+  }
+  return safeHeaders;
+}
 function getResponseStatus(event) {
   if (event.node?.res?.statusCode) {
     return event.node.res.statusCode;
@@ -24,7 +49,8 @@ function callDrainHook(nitroApp, emittedEvent, event) {
   if (emittedEvent) {
     nitroApp.hooks.callHook("evlog:drain", {
       event: emittedEvent,
-      request: { method: event.method, path: event.path, requestId: event.context.requestId }
+      request: { method: event.method, path: event.path, requestId: event.context.requestId },
+      headers: getSafeHeaders(event)
     }).catch((err) => {
       console.error("[evlog] drain failed:", err);
     });
@@ -40,7 +66,7 @@ const plugin = defineNitroPlugin((nitroApp) => {
   });
   nitroApp.hooks.hook("request", (event) => {
     const e = event;
-    if (!shouldLog(e.path, evlogConfig?.include)) {
+    if (!shouldLog(e.path, evlogConfig?.include, evlogConfig?.exclude)) {
       return;
     }
     e.context._evlogStartTime = Date.now();

package/dist/nuxt/module.d.mts

@@ -1,5 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { EnvironmentContext, SamplingConfig } from '../types.mjs';
+import { EnvironmentContext, SamplingConfig, TransportConfig } from '../types.mjs';
 
 interface ModuleOptions {
     /**
@@ -18,6 +18,13 @@ interface ModuleOptions {
      * @example ['/api/**', '/auth/**']
      */
     include?: string[];
+    /**
+     * Route patterns to exclude from logging.
+     * Supports glob patterns like '/api/_nuxt_icon/**'.
+     * Exclusions take precedence over inclusions.
+     * @example ['/api/_nuxt_icon/**', '/health']
+     */
+    exclude?: string[];
     /**
      * Sampling configuration for filtering logs.
      * Allows configuring what percentage of logs to keep per level.
@@ -35,6 +42,18 @@ interface ModuleOptions {
      * ```
      */
     sampling?: SamplingConfig;
+    /**
+     * Transport configuration for sending client logs to the server.
+     *
+     * @example
+     * ```ts
+     * transport: {
+     *   enabled: true,  // Send logs to server API
+     *   endpoint: '/api/_evlog/ingest'  // Custom endpoint
+     * }
+     * ```
+     */
+    transport?: TransportConfig;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/nuxt/module.d.ts

@@ -1,5 +1,5 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { EnvironmentContext, SamplingConfig } from '../types.js';
+import { EnvironmentContext, SamplingConfig, TransportConfig } from '../types.js';
 
 interface ModuleOptions {
     /**
@@ -18,6 +18,13 @@ interface ModuleOptions {
      * @example ['/api/**', '/auth/**']
      */
     include?: string[];
+    /**
+     * Route patterns to exclude from logging.
+     * Supports glob patterns like '/api/_nuxt_icon/**'.
+     * Exclusions take precedence over inclusions.
+     * @example ['/api/_nuxt_icon/**', '/health']
+     */
+    exclude?: string[];
     /**
      * Sampling configuration for filtering logs.
      * Allows configuring what percentage of logs to keep per level.
@@ -35,6 +42,18 @@ interface ModuleOptions {
      * ```
      */
     sampling?: SamplingConfig;
+    /**
+     * Transport configuration for sending client logs to the server.
+     *
+     * @example
+     * ```ts
+     * transport: {
+     *   enabled: true,  // Send logs to server API
+     *   endpoint: '/api/_evlog/ingest'  // Custom endpoint
+     * }
+     * ```
+     */
+    transport?: TransportConfig;
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/nuxt/module.mjs

@@ -1,4 +1,4 @@
-import { defineNuxtModule, createResolver, addServerPlugin, addPlugin, addImports, addServerImports } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addServerHandler, addServerPlugin, addPlugin, addImports, addServerImports } from '@nuxt/kit';
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -9,10 +9,26 @@ const module$1 = defineNuxtModule({
   defaults: {},
   setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
+    const transportEnabled = options.transport?.enabled ?? false;
+    const transportEndpoint = options.transport?.endpoint ?? "/api/_evlog/ingest";
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.errorHandler = nitroConfig.errorHandler || resolver.resolve("../nitro/errorHandler");
+    });
     nuxt.options.runtimeConfig.evlog = options;
     nuxt.options.runtimeConfig.public.evlog = {
-      pretty: options.pretty
+      pretty: options.pretty,
+      transport: {
+        enabled: transportEnabled,
+        endpoint: transportEndpoint
+      }
     };
+    if (transportEnabled) {
+      addServerHandler({
+        route: transportEndpoint,
+        method: "post",
+        handler: resolver.resolve("../runtime/server/routes/_evlog/ingest.post")
+      });
+    }
     addServerPlugin(resolver.resolve("../nitro/plugin"));
     addPlugin({
       src: resolver.resolve("../runtime/client/plugin"),

package/dist/runtime/client/log.d.mts

@@ -1,8 +1,9 @@
-import { Log } from '../../types.mjs';
+import { TransportConfig, Log } from '../../types.mjs';
 
 declare function initLog(options?: {
     pretty?: boolean;
     service?: string;
+    transport?: TransportConfig;
 }): void;
 declare const log: Log;
 

package/dist/runtime/client/log.d.ts

@@ -1,8 +1,9 @@
-import { Log } from '../../types.js';
+import { TransportConfig, Log } from '../../types.js';
 
 declare function initLog(options?: {
     pretty?: boolean;
     service?: string;
+    transport?: TransportConfig;
 }): void;
 declare const log: Log;
 

package/dist/runtime/client/log.mjs

@@ -3,6 +3,8 @@ import { getConsoleMethod } from '../../utils.mjs';
 const isClient = typeof window !== "undefined";
 let clientPretty = true;
 let clientService = "client";
+let transportEnabled = false;
+let transportEndpoint = "/api/_evlog/ingest";
 const LEVEL_COLORS = {
   error: "color: #ef4444; font-weight: bold",
   warn: "color: #f59e0b; font-weight: bold",
@@ -12,6 +14,21 @@ const LEVEL_COLORS = {
 function initLog(options = {}) {
   clientPretty = options.pretty ?? true;
   clientService = options.service ?? "client";
+  transportEnabled = options.transport?.enabled ?? false;
+  transportEndpoint = options.transport?.endpoint ?? "/api/_evlog/ingest";
+}
+async function sendToServer(event) {
+  if (!transportEnabled) return;
+  try {
+    await fetch(transportEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(event),
+      keepalive: true,
+      credentials: "same-origin"
+    });
+  } catch {
+  }
 }
 function emitLog(level, event) {
   const formatted = {
@@ -27,10 +44,18 @@ function emitLog(level, event) {
   } else {
     console[method](JSON.stringify(formatted));
   }
+  sendToServer(formatted);
 }
 function emitTaggedLog(level, tag, message) {
   if (clientPretty) {
     console[getConsoleMethod(level)](`%c[${tag}]%c ${message}`, LEVEL_COLORS[level] || "", "color: inherit");
+    sendToServer({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      service: clientService,
+      tag,
+      message
+    });
   } else {
     emitLog(level, { tag, message });
   }

package/dist/runtime/client/plugin.mjs

@@ -7,7 +7,8 @@ const plugin = defineNuxtPlugin(() => {
   const evlogConfig = config.public?.evlog;
   initLog({
     pretty: evlogConfig?.pretty ?? import.meta.dev,
-    service: "client"
+    service: "client",
+    transport: evlogConfig?.transport
   });
 });
 

package/dist/runtime/server/routes/_evlog/ingest.post.d.mts

@@ -0,0 +1,5 @@
+import * as h3 from 'h3';
+
+declare const _default: h3.EventHandler<h3.EventHandlerRequest, Promise<null>>;
+
+export { _default as default };

package/dist/runtime/server/routes/_evlog/ingest.post.d.ts

@@ -0,0 +1,5 @@
+import * as h3 from 'h3';
+
+declare const _default: h3.EventHandler<h3.EventHandlerRequest, Promise<null>>;
+
+export { _default as default };

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

@@ -0,0 +1,87 @@
+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"];
+function validateOrigin(event) {
+  const origin = getHeader(event, "origin");
+  const referer = getHeader(event, "referer");
+  const host = getRequestHost(event);
+  const requestOrigin = origin || (referer ? new URL(referer).origin : null);
+  if (!requestOrigin) {
+    throw createError({ statusCode: 403, message: "Missing origin header" });
+  }
+  const originHost = new URL(requestOrigin).host;
+  if (originHost !== host) {
+    throw createError({ statusCode: 403, message: "Invalid origin" });
+  }
+}
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/;
+function isValidISOTimestamp(value) {
+  if (!ISO_8601_REGEX.test(value)) return false;
+  const date = new Date(value);
+  return !Number.isNaN(date.getTime());
+}
+function validatePayload(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    throw createError({ statusCode: 400, message: "Invalid request body" });
+  }
+  const payload = body;
+  if (payload.timestamp === void 0 || payload.timestamp === null) {
+    throw createError({ statusCode: 400, message: "Missing required field: timestamp" });
+  }
+  const { timestamp: rawTimestamp } = payload;
+  let timestamp;
+  if (typeof rawTimestamp === "number") {
+    const minTimestamp = (/* @__PURE__ */ new Date("2000-01-01")).getTime();
+    const maxTimestamp = Date.now() + 24 * 60 * 60 * 1e3;
+    if (rawTimestamp < minTimestamp || rawTimestamp > maxTimestamp) {
+      throw createError({ statusCode: 400, message: "Invalid timestamp: value out of reasonable range" });
+    }
+    timestamp = new Date(rawTimestamp).toISOString();
+  } else if (typeof rawTimestamp === "string") {
+    if (!isValidISOTimestamp(rawTimestamp)) {
+      throw createError({ statusCode: 400, message: "Invalid timestamp: must be a valid ISO 8601 datetime string" });
+    }
+    timestamp = rawTimestamp;
+  } else {
+    throw createError({ statusCode: 400, message: "Invalid timestamp: must be string or number" });
+  }
+  if (!payload.level || typeof payload.level !== "string") {
+    throw createError({ statusCode: 400, message: "Missing required field: level" });
+  }
+  if (!VALID_LEVELS.includes(payload.level)) {
+    throw createError({ statusCode: 400, message: `Invalid level: must be one of ${VALID_LEVELS.join(", ")}` });
+  }
+  return {
+    ...payload,
+    timestamp,
+    level: payload.level
+  };
+}
+const ingest_post = defineEventHandler(async (event) => {
+  validateOrigin(event);
+  const body = await readBody(event);
+  const payload = validatePayload(body);
+  const nitroApp = useNitroApp();
+  const env = getEnvironment();
+  const { service: _clientService, ...sanitizedPayload } = payload;
+  const wideEvent = {
+    ...sanitizedPayload,
+    ...env,
+    source: "client"
+  };
+  try {
+    await nitroApp.hooks.callHook("evlog:drain", {
+      event: wideEvent,
+      request: { method: "POST", path: event.path }
+    });
+  } catch {
+  }
+  setResponseStatus(event, 204);
+  return null;
+});
+
+export { ingest_post as default };

package/dist/runtime/utils/parseError.mjs

@@ -1,10 +1,12 @@
 function parseError(error) {
   if (error && typeof error === "object" && "data" in error) {
-    const { data, message: fetchMessage, statusCode: fetchStatusCode } = error;
-    const evlogData = data?.data;
+    const { data, message: fetchMessage, statusCode: fetchStatusCode, status: fetchStatus } = error;
+    const evlogData = data?.data ?? data;
     return {
-      message: data?.message || fetchMessage || "An error occurred",
-      status: data?.statusCode || fetchStatusCode || 500,
+      // Prefer statusText, then statusMessage (or message) for the error message
+      message: data?.statusText || data?.statusMessage || data?.message || fetchMessage || "An error occurred",
+      // Prefer status, then statusCode for the status value
+      status: data?.status || data?.statusCode || fetchStatus || fetchStatusCode || 500,
       why: evlogData?.why,
       fix: evlogData?.fix,
       link: evlogData?.link,

package/dist/types.d.mts

@@ -33,6 +33,29 @@ declare module 'nitropack/types' {
         'evlog:drain': (ctx: DrainContext) => void | Promise<void>;
     }
 }
+/**
+ * Transport configuration for sending client logs to the server
+ */
+interface TransportConfig {
+    /**
+     * Enable sending logs to the server API
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * API endpoint for log ingestion
+     * @default '/api/_evlog/ingest'
+     */
+    endpoint?: string;
+}
+/**
+ * Payload sent from client to server for log ingestion
+ */
+interface IngestPayload {
+    timestamp: string;
+    level: 'info' | 'error' | 'warn' | 'debug';
+    [key: string]: unknown;
+}
 /**
  * Sampling rates per log level (0-100 percentage)
  */
@@ -92,6 +115,8 @@ interface DrainContext {
         path?: string;
         requestId?: string;
     };
+    /** HTTP headers from the original request (useful for correlation with external services) */
+    headers?: Record<string, string>;
 }
 /**
  * Sampling configuration for filtering logs
@@ -190,7 +215,7 @@ type WideEvent = BaseWideEvent & Record<string, unknown>;
  */
 interface RequestLogger {
     /**
-     * Add context to the wide event (shallow merge)
+     * Add context to the wide event (deep merge via defu)
      */
     set: <T extends Record<string, unknown>>(context: T) => void;
     /**
@@ -314,4 +339,4 @@ interface ParsedError {
     raw: unknown;
 }
 
-export type { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, WideEvent };
+export type { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, IngestPayload, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent };

package/dist/types.d.ts

@@ -33,6 +33,29 @@ declare module 'nitropack/types' {
         'evlog:drain': (ctx: DrainContext) => void | Promise<void>;
     }
 }
+/**
+ * Transport configuration for sending client logs to the server
+ */
+interface TransportConfig {
+    /**
+     * Enable sending logs to the server API
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * API endpoint for log ingestion
+     * @default '/api/_evlog/ingest'
+     */
+    endpoint?: string;
+}
+/**
+ * Payload sent from client to server for log ingestion
+ */
+interface IngestPayload {
+    timestamp: string;
+    level: 'info' | 'error' | 'warn' | 'debug';
+    [key: string]: unknown;
+}
 /**
  * Sampling rates per log level (0-100 percentage)
  */
@@ -92,6 +115,8 @@ interface DrainContext {
         path?: string;
         requestId?: string;
     };
+    /** HTTP headers from the original request (useful for correlation with external services) */
+    headers?: Record<string, string>;
 }
 /**
  * Sampling configuration for filtering logs
@@ -190,7 +215,7 @@ type WideEvent = BaseWideEvent & Record<string, unknown>;
  */
 interface RequestLogger {
     /**
-     * Add context to the wide event (shallow merge)
+     * Add context to the wide event (deep merge via defu)
      */
     set: <T extends Record<string, unknown>>(context: T) => void;
     /**
@@ -314,4 +339,4 @@ interface ParsedError {
     raw: unknown;
 }
 
-export type { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, WideEvent };
+export type { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, IngestPayload, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evlog",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Wide event logging library with structured error handling. Inspired by LoggingSucks.",
   "author": "HugoRCD <contact@hrcd.fr>",
   "homepage": "https://evlog.dev",
@@ -67,7 +67,8 @@
     "typecheck": "echo 'Typecheck handled by build'"
   },
   "dependencies": {
-    "@nuxt/kit": "^4.3.0"
+    "@nuxt/kit": "^4.3.0",
+    "defu": "^6.1.4"
   },
   "devDependencies": {
     "@nuxt/devtools": "^3.1.1",