evlog 1.2.0 → 1.3.0

package/README.md

@@ -346,6 +346,49 @@ async function processSyncJob(job: Job) {
 }
 ```
 
+## Cloudflare Workers
+
+Use the Workers adapter for structured logs and correct platform severity.
+
+```typescript
+// src/index.ts
+import { initWorkersLogger, createWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+
+export default {
+  async fetch(request: Request) {
+    const log = createWorkersLogger(request)
+
+    try {
+      log.set({ route: 'health' })
+      const response = new Response('ok', { status: 200 })
+      log.emit({ status: response.status })
+      return response
+    } catch (error) {
+      log.error(error as Error)
+      log.emit({ status: 500 })
+      throw error
+    }
+  },
+}
+```
+
+Disable invocation logs to avoid duplicate request logs:
+
+```toml
+# wrangler.toml
+[observability.logs]
+invocation_logs = false
+```
+
+Notes:
+- `requestId` defaults to `cf-ray` when available
+- `request.cf` is included (colo, country, asn) unless disabled
+- Use `headerAllowlist` to avoid logging sensitive headers
+
 ## API Reference
 
 ### `initLogger(config)`
@@ -362,6 +405,7 @@ initLogger({
     region?: string      // Deployment region
   },
   pretty?: boolean       // Pretty print (default: true in dev)
+  stringify?: boolean    // JSON.stringify output (default: true, false for Workers)
   include?: string[]     // Route patterns to log (glob), e.g. ['/api/**']
   sampling?: {
     rates?: {            // Head sampling (random per level)
@@ -479,6 +523,34 @@ log.emit()                         // Emit final event
 log.getContext()                   // Get current context
 ```
 
+### `initWorkersLogger(options?)`
+
+Initialize evlog for Cloudflare Workers (object logs + correct severity).
+
+```typescript
+import { initWorkersLogger } from 'evlog/workers'
+
+initWorkersLogger({
+  env: { service: 'edge-api' },
+})
+```
+
+### `createWorkersLogger(request, options?)`
+
+Create a request-scoped logger for Workers. Auto-extracts `cf-ray`, `request.cf`, method, and path.
+
+```typescript
+import { createWorkersLogger } from 'evlog/workers'
+
+const log = createWorkersLogger(request, {
+  requestId: 'custom-id',      // Override cf-ray (default: cf-ray header)
+  headers: ['x-request-id'],   // Headers to include (default: none)
+})
+
+log.set({ user: { id: '123' } })
+log.emit({ status: 200 })
+```
+
 ### `createError(options)`
 
 Create a structured error with HTTP status support. Import from `evlog` directly to avoid conflicts with Nuxt/Nitro's `createError`.

package/dist/adapters/axiom.d.mts

@@ -0,0 +1,62 @@
+import { DrainContext, WideEvent } from '../types.mjs';
+
+interface AxiomConfig {
+    /** Axiom dataset name */
+    dataset: string;
+    /** Axiom API token */
+    token: string;
+    /** Organization ID (required for Personal Access Tokens) */
+    orgId?: string;
+    /** Base URL for Axiom API. Default: https://api.axiom.co */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/**
+ * Create a drain function for sending logs to Axiom.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createAxiomDrain()
+ * 2. runtimeConfig.evlog.axiom
+ * 3. runtimeConfig.axiom
+ * 4. Environment variables: NUXT_AXIOM_*, AXIOM_*
+ *
+ * @example
+ * ```ts
+ * // Zero config - just set NUXT_AXIOM_TOKEN and NUXT_AXIOM_DATASET env vars
+ * nitroApp.hooks.hook('evlog:drain', createAxiomDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createAxiomDrain({
+ *   dataset: 'my-dataset',
+ * }))
+ * ```
+ */
+declare function createAxiomDrain(overrides?: Partial<AxiomConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to Axiom.
+ *
+ * @example
+ * ```ts
+ * await sendToAxiom(event, {
+ *   dataset: 'my-logs',
+ *   token: process.env.AXIOM_TOKEN!,
+ * })
+ * ```
+ */
+declare function sendToAxiom(event: WideEvent, config: AxiomConfig): Promise<void>;
+/**
+ * Send a batch of events to Axiom.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToAxiom(events, {
+ *   dataset: 'my-logs',
+ *   token: process.env.AXIOM_TOKEN!,
+ * })
+ * ```
+ */
+declare function sendBatchToAxiom(events: WideEvent[], config: AxiomConfig): Promise<void>;
+
+export { createAxiomDrain, sendBatchToAxiom, sendToAxiom };
+export type { AxiomConfig };

package/dist/adapters/axiom.d.ts

@@ -0,0 +1,62 @@
+import { DrainContext, WideEvent } from '../types.js';
+
+interface AxiomConfig {
+    /** Axiom dataset name */
+    dataset: string;
+    /** Axiom API token */
+    token: string;
+    /** Organization ID (required for Personal Access Tokens) */
+    orgId?: string;
+    /** Base URL for Axiom API. Default: https://api.axiom.co */
+    baseUrl?: string;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/**
+ * Create a drain function for sending logs to Axiom.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createAxiomDrain()
+ * 2. runtimeConfig.evlog.axiom
+ * 3. runtimeConfig.axiom
+ * 4. Environment variables: NUXT_AXIOM_*, AXIOM_*
+ *
+ * @example
+ * ```ts
+ * // Zero config - just set NUXT_AXIOM_TOKEN and NUXT_AXIOM_DATASET env vars
+ * nitroApp.hooks.hook('evlog:drain', createAxiomDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createAxiomDrain({
+ *   dataset: 'my-dataset',
+ * }))
+ * ```
+ */
+declare function createAxiomDrain(overrides?: Partial<AxiomConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to Axiom.
+ *
+ * @example
+ * ```ts
+ * await sendToAxiom(event, {
+ *   dataset: 'my-logs',
+ *   token: process.env.AXIOM_TOKEN!,
+ * })
+ * ```
+ */
+declare function sendToAxiom(event: WideEvent, config: AxiomConfig): Promise<void>;
+/**
+ * Send a batch of events to Axiom.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToAxiom(events, {
+ *   dataset: 'my-logs',
+ *   token: process.env.AXIOM_TOKEN!,
+ * })
+ * ```
+ */
+declare function sendBatchToAxiom(events: WideEvent[], config: AxiomConfig): Promise<void>;
+
+export { createAxiomDrain, sendBatchToAxiom, sendToAxiom };
+export type { AxiomConfig };

package/dist/adapters/axiom.mjs

@@ -0,0 +1,65 @@
+function getRuntimeConfig() {
+  try {
+    const { useRuntimeConfig } = require("nitropack/runtime");
+    return useRuntimeConfig();
+  } catch {
+    return void 0;
+  }
+}
+function createAxiomDrain(overrides) {
+  return async (ctx) => {
+    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 sendToAxiom(ctx.event, config);
+    } catch (error) {
+      console.error("[evlog/axiom] Failed to send event:", error);
+    }
+  };
+}
+async function sendToAxiom(event, config) {
+  await sendBatchToAxiom([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 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);
+  }
+}
+
+export { createAxiomDrain, sendBatchToAxiom, sendToAxiom };

package/dist/adapters/otlp.d.mts

@@ -0,0 +1,83 @@
+import { DrainContext, WideEvent } from '../types.mjs';
+
+interface OTLPConfig {
+    /** OTLP HTTP endpoint (e.g., http://localhost:4318) */
+    endpoint: string;
+    /** Override service name (defaults to event.service) */
+    serviceName?: string;
+    /** Additional resource attributes */
+    resourceAttributes?: Record<string, string | number | boolean>;
+    /** Custom headers (e.g., for authentication) */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/** OTLP Log Record structure */
+interface OTLPLogRecord {
+    timeUnixNano: string;
+    severityNumber: number;
+    severityText: string;
+    body: {
+        stringValue: string;
+    };
+    attributes: Array<{
+        key: string;
+        value: {
+            stringValue?: string;
+            intValue?: string;
+            boolValue?: boolean;
+        };
+    }>;
+    traceId?: string;
+    spanId?: string;
+}
+/**
+ * Convert an evlog WideEvent to an OTLP LogRecord.
+ */
+declare function toOTLPLogRecord(event: WideEvent): OTLPLogRecord;
+/**
+ * Create a drain function for sending logs to an OTLP endpoint.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createOTLPDrain()
+ * 2. runtimeConfig.evlog.otlp (NUXT_EVLOG_OTLP_*)
+ * 3. runtimeConfig.otlp (NUXT_OTLP_*)
+ * 4. Environment variables: OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_SERVICE_NAME
+ *
+ * @example
+ * ```ts
+ * // Zero config - reads from runtimeConfig or env vars
+ * nitroApp.hooks.hook('evlog:drain', createOTLPDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createOTLPDrain({
+ *   endpoint: 'http://localhost:4318',
+ * }))
+ * ```
+ */
+declare function createOTLPDrain(overrides?: Partial<OTLPConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to an OTLP endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendToOTLP(event, {
+ *   endpoint: 'http://localhost:4318',
+ * })
+ * ```
+ */
+declare function sendToOTLP(event: WideEvent, config: OTLPConfig): Promise<void>;
+/**
+ * Send a batch of events to an OTLP endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToOTLP(events, {
+ *   endpoint: 'http://localhost:4318',
+ * })
+ * ```
+ */
+declare function sendBatchToOTLP(events: WideEvent[], config: OTLPConfig): Promise<void>;
+
+export { createOTLPDrain, sendBatchToOTLP, sendToOTLP, toOTLPLogRecord };
+export type { OTLPConfig, OTLPLogRecord };

package/dist/adapters/otlp.d.ts

@@ -0,0 +1,83 @@
+import { DrainContext, WideEvent } from '../types.js';
+
+interface OTLPConfig {
+    /** OTLP HTTP endpoint (e.g., http://localhost:4318) */
+    endpoint: string;
+    /** Override service name (defaults to event.service) */
+    serviceName?: string;
+    /** Additional resource attributes */
+    resourceAttributes?: Record<string, string | number | boolean>;
+    /** Custom headers (e.g., for authentication) */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds. Default: 5000 */
+    timeout?: number;
+}
+/** OTLP Log Record structure */
+interface OTLPLogRecord {
+    timeUnixNano: string;
+    severityNumber: number;
+    severityText: string;
+    body: {
+        stringValue: string;
+    };
+    attributes: Array<{
+        key: string;
+        value: {
+            stringValue?: string;
+            intValue?: string;
+            boolValue?: boolean;
+        };
+    }>;
+    traceId?: string;
+    spanId?: string;
+}
+/**
+ * Convert an evlog WideEvent to an OTLP LogRecord.
+ */
+declare function toOTLPLogRecord(event: WideEvent): OTLPLogRecord;
+/**
+ * Create a drain function for sending logs to an OTLP endpoint.
+ *
+ * Configuration priority (highest to lowest):
+ * 1. Overrides passed to createOTLPDrain()
+ * 2. runtimeConfig.evlog.otlp (NUXT_EVLOG_OTLP_*)
+ * 3. runtimeConfig.otlp (NUXT_OTLP_*)
+ * 4. Environment variables: OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_SERVICE_NAME
+ *
+ * @example
+ * ```ts
+ * // Zero config - reads from runtimeConfig or env vars
+ * nitroApp.hooks.hook('evlog:drain', createOTLPDrain())
+ *
+ * // With overrides
+ * nitroApp.hooks.hook('evlog:drain', createOTLPDrain({
+ *   endpoint: 'http://localhost:4318',
+ * }))
+ * ```
+ */
+declare function createOTLPDrain(overrides?: Partial<OTLPConfig>): (ctx: DrainContext) => Promise<void>;
+/**
+ * Send a single event to an OTLP endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendToOTLP(event, {
+ *   endpoint: 'http://localhost:4318',
+ * })
+ * ```
+ */
+declare function sendToOTLP(event: WideEvent, config: OTLPConfig): Promise<void>;
+/**
+ * Send a batch of events to an OTLP endpoint.
+ *
+ * @example
+ * ```ts
+ * await sendBatchToOTLP(events, {
+ *   endpoint: 'http://localhost:4318',
+ * })
+ * ```
+ */
+declare function sendBatchToOTLP(events: WideEvent[], config: OTLPConfig): Promise<void>;
+
+export { createOTLPDrain, sendBatchToOTLP, sendToOTLP, toOTLPLogRecord };
+export type { OTLPConfig, OTLPLogRecord };

package/dist/adapters/otlp.mjs

@@ -0,0 +1,202 @@
+const SEVERITY_MAP = {
+  debug: 5,
+  // DEBUG
+  info: 9,
+  // INFO
+  warn: 13,
+  // WARN
+  error: 17
+  // ERROR
+};
+const SEVERITY_TEXT_MAP = {
+  debug: "DEBUG",
+  info: "INFO",
+  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 };
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return { intValue: String(value) };
+  }
+  if (typeof value === "string") {
+    return { stringValue: value };
+  }
+  return { stringValue: JSON.stringify(value) };
+}
+function toOTLPLogRecord(event) {
+  const timestamp = new Date(event.timestamp).getTime() * 1e6;
+  const { level, traceId, spanId, ...rest } = event;
+  delete rest.timestamp;
+  delete rest.service;
+  delete rest.environment;
+  delete rest.version;
+  delete rest.commitHash;
+  delete rest.region;
+  const attributes = [];
+  for (const [key, value] of Object.entries(rest)) {
+    if (value !== void 0 && value !== null) {
+      attributes.push({
+        key,
+        value: toAttributeValue(value)
+      });
+    }
+  }
+  const record = {
+    timeUnixNano: String(timestamp),
+    severityNumber: SEVERITY_MAP[level] ?? 9,
+    severityText: SEVERITY_TEXT_MAP[level] ?? "INFO",
+    body: { stringValue: JSON.stringify(event) },
+    attributes
+  };
+  if (typeof traceId === "string") {
+    record.traceId = traceId;
+  }
+  if (typeof spanId === "string") {
+    record.spanId = spanId;
+  }
+  return record;
+}
+function buildResourceAttributes(event, config) {
+  const attributes = [];
+  attributes.push({
+    key: "service.name",
+    value: { stringValue: config.serviceName ?? event.service }
+  });
+  if (event.environment) {
+    attributes.push({
+      key: "deployment.environment",
+      value: { stringValue: event.environment }
+    });
+  }
+  if (event.version) {
+    attributes.push({
+      key: "service.version",
+      value: { stringValue: event.version }
+    });
+  }
+  if (event.region) {
+    attributes.push({
+      key: "cloud.region",
+      value: { stringValue: event.region }
+    });
+  }
+  if (event.commitHash) {
+    attributes.push({
+      key: "vcs.commit.id",
+      value: { stringValue: event.commitHash }
+    });
+  }
+  if (config.resourceAttributes) {
+    for (const [key, value] of Object.entries(config.resourceAttributes)) {
+      attributes.push({
+        key,
+        value: toAttributeValue(value)
+      });
+    }
+  }
+  return attributes;
+}
+function createOTLPDrain(overrides) {
+  return async (ctx) => {
+    const runtimeConfig = getRuntimeConfig();
+    const evlogOtlp = runtimeConfig?.evlog?.otlp;
+    const rootOtlp = runtimeConfig?.otlp;
+    const getHeadersFromEnv = () => {
+      const headersEnv = process.env.OTEL_EXPORTER_OTLP_HEADERS || process.env.NUXT_OTLP_HEADERS;
+      if (headersEnv) {
+        const headers = {};
+        const decoded = decodeURIComponent(headersEnv);
+        for (const pair of decoded.split(",")) {
+          const eqIndex = pair.indexOf("=");
+          if (eqIndex > 0) {
+            const key = pair.slice(0, eqIndex).trim();
+            const value = pair.slice(eqIndex + 1).trim();
+            if (key && value) {
+              headers[key] = value;
+            }
+          }
+        }
+        if (Object.keys(headers).length > 0) return headers;
+      }
+      const auth = process.env.NUXT_OTLP_AUTH;
+      if (auth) {
+        return { Authorization: auth };
+      }
+      return void 0;
+    };
+    const config = {
+      endpoint: overrides?.endpoint ?? evlogOtlp?.endpoint ?? rootOtlp?.endpoint ?? process.env.NUXT_OTLP_ENDPOINT ?? process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+      serviceName: overrides?.serviceName ?? evlogOtlp?.serviceName ?? rootOtlp?.serviceName ?? process.env.NUXT_OTLP_SERVICE_NAME ?? process.env.OTEL_SERVICE_NAME,
+      headers: overrides?.headers ?? evlogOtlp?.headers ?? rootOtlp?.headers ?? getHeadersFromEnv(),
+      resourceAttributes: overrides?.resourceAttributes ?? evlogOtlp?.resourceAttributes ?? rootOtlp?.resourceAttributes,
+      timeout: overrides?.timeout ?? evlogOtlp?.timeout ?? rootOtlp?.timeout
+    };
+    if (!config.endpoint) {
+      console.error("[evlog/otlp] Missing endpoint. Set NUXT_OTLP_ENDPOINT or OTEL_EXPORTER_OTLP_ENDPOINT env var, or pass to createOTLPDrain()");
+      return;
+    }
+    try {
+      await sendToOTLP(ctx.event, config);
+    } catch (error) {
+      console.error("[evlog/otlp] Failed to send event:", error);
+    }
+  };
+}
+async function sendToOTLP(event, config) {
+  await sendBatchToOTLP([event], config);
+}
+async function sendBatchToOTLP(events, config) {
+  if (events.length === 0) return;
+  const timeout = config.timeout ?? 5e3;
+  const url = `${config.endpoint.replace(/\/$/, "")}/v1/logs`;
+  const [firstEvent] = events;
+  const resourceAttributes = buildResourceAttributes(firstEvent, config);
+  const logRecords = events.map(toOTLPLogRecord);
+  const payload = {
+    resourceLogs: [
+      {
+        resource: { attributes: resourceAttributes },
+        scopeLogs: [
+          {
+            scope: { name: "evlog", version: "1.0.0" },
+            logRecords
+          }
+        ]
+      }
+    ]
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    ...config.headers
+  };
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      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(`OTLP API error: ${response.status} ${response.statusText} - ${safeText}`);
+    }
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+export { createOTLPDrain, sendBatchToOTLP, sendToOTLP, toOTLPLogRecord };

package/dist/logger.mjs

@@ -7,6 +7,7 @@ let globalEnv = {
 };
 let globalPretty = isDev();
 let globalSampling = {};
+let globalStringify = true;
 function initLogger(config = {}) {
   const detected = detectEnvironment();
   globalEnv = {
@@ -18,6 +19,7 @@ function initLogger(config = {}) {
   };
   globalPretty = config.pretty ?? isDev();
   globalSampling = config.sampling ?? {};
+  globalStringify = config.stringify ?? true;
 }
 function shouldSample(level) {
   const { rates } = globalSampling;
@@ -57,8 +59,10 @@ function emitWideEvent(level, event, skipSamplingCheck = false) {
   };
   if (globalPretty) {
     prettyPrintWideEvent(formatted);
-  } else {
+  } else if (globalStringify) {
     console[getConsoleMethod(level)](JSON.stringify(formatted));
+  } else {
+    console[getConsoleMethod(level)](formatted);
   }
   return formatted;
 }
@@ -70,9 +74,9 @@ function emitTaggedLog(level, tag, message) {
     const color = getLevelColor(level);
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
     console.log(`${colors.dim}${timestamp}${colors.reset} ${color}[${tag}]${colors.reset} ${message}`);
-  } else {
-    emitWideEvent(level, { tag, message });
+    return;
   }
+  emitWideEvent(level, { tag, message });
 }
 function formatValue(value) {
   if (value === null || value === void 0) {

package/dist/nuxt/module.d.mts

@@ -54,6 +54,56 @@ interface ModuleOptions {
      * ```
      */
     transport?: TransportConfig;
+    /**
+     * Axiom adapter configuration.
+     * When configured, use `createAxiomDrain()` from `evlog/axiom` to send logs.
+     *
+     * @example
+     * ```ts
+     * axiom: {
+     *   dataset: 'my-app-logs',
+     *   token: process.env.AXIOM_TOKEN,
+     * }
+     * ```
+     */
+    axiom?: {
+        /** Axiom dataset name */
+        dataset: string;
+        /** Axiom API token */
+        token: string;
+        /** Organization ID (required for Personal Access Tokens) */
+        orgId?: string;
+        /** Base URL for Axiom API. Default: https://api.axiom.co */
+        baseUrl?: string;
+        /** Request timeout in milliseconds. Default: 5000 */
+        timeout?: number;
+    };
+    /**
+     * OTLP adapter configuration.
+     * When configured, use `createOTLPDrain()` from `evlog/otlp` to send logs.
+     *
+     * @example
+     * ```ts
+     * otlp: {
+     *   endpoint: 'http://localhost:4318',
+     *   headers: {
+     *     'Authorization': `Basic ${process.env.GRAFANA_TOKEN}`,
+     *   },
+     * }
+     * ```
+     */
+    otlp?: {
+        /** OTLP HTTP endpoint (e.g., http://localhost:4318) */
+        endpoint: string;
+        /** Override service name (defaults to event.service) */
+        serviceName?: string;
+        /** Additional resource attributes */
+        resourceAttributes?: Record<string, string | number | boolean>;
+        /** Custom headers (e.g., for authentication) */
+        headers?: 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

@@ -54,6 +54,56 @@ interface ModuleOptions {
      * ```
      */
     transport?: TransportConfig;
+    /**
+     * Axiom adapter configuration.
+     * When configured, use `createAxiomDrain()` from `evlog/axiom` to send logs.
+     *
+     * @example
+     * ```ts
+     * axiom: {
+     *   dataset: 'my-app-logs',
+     *   token: process.env.AXIOM_TOKEN,
+     * }
+     * ```
+     */
+    axiom?: {
+        /** Axiom dataset name */
+        dataset: string;
+        /** Axiom API token */
+        token: string;
+        /** Organization ID (required for Personal Access Tokens) */
+        orgId?: string;
+        /** Base URL for Axiom API. Default: https://api.axiom.co */
+        baseUrl?: string;
+        /** Request timeout in milliseconds. Default: 5000 */
+        timeout?: number;
+    };
+    /**
+     * OTLP adapter configuration.
+     * When configured, use `createOTLPDrain()` from `evlog/otlp` to send logs.
+     *
+     * @example
+     * ```ts
+     * otlp: {
+     *   endpoint: 'http://localhost:4318',
+     *   headers: {
+     *     'Authorization': `Basic ${process.env.GRAFANA_TOKEN}`,
+     *   },
+     * }
+     * ```
+     */
+    otlp?: {
+        /** OTLP HTTP endpoint (e.g., http://localhost:4318) */
+        endpoint: string;
+        /** Override service name (defaults to event.service) */
+        serviceName?: string;
+        /** Additional resource attributes */
+        resourceAttributes?: Record<string, string | number | boolean>;
+        /** Custom headers (e.g., for authentication) */
+        headers?: Record<string, string>;
+        /** Request timeout in milliseconds. Default: 5000 */
+        timeout?: number;
+    };
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 

package/dist/types.d.mts

@@ -185,6 +185,12 @@ interface LoggerConfig {
     pretty?: boolean;
     /** Sampling configuration for filtering logs */
     sampling?: SamplingConfig;
+    /**
+     * When pretty is disabled, emit JSON strings (default) or raw objects.
+     * Set to false for environments like Cloudflare Workers that expect objects.
+     * @default true
+     */
+    stringify?: boolean;
 }
 /**
  * Base structure for all wide events

package/dist/types.d.ts

@@ -185,6 +185,12 @@ interface LoggerConfig {
     pretty?: boolean;
     /** Sampling configuration for filtering logs */
     sampling?: SamplingConfig;
+    /**
+     * When pretty is disabled, emit JSON strings (default) or raw objects.
+     * Set to false for environments like Cloudflare Workers that expect objects.
+     * @default true
+     */
+    stringify?: boolean;
 }
 /**
  * Base structure for all wide events

package/dist/utils.d.mts

@@ -5,7 +5,7 @@ declare function isServer(): boolean;
 declare function isClient(): boolean;
 declare function isDev(): boolean;
 declare function detectEnvironment(): Partial<EnvironmentContext>;
-declare function getConsoleMethod(level: LogLevel): 'log' | 'error' | 'warn';
+declare function getConsoleMethod(level: LogLevel): LogLevel;
 declare const colors: {
     readonly reset: "\u001B[0m";
     readonly bold: "\u001B[1m";

package/dist/utils.d.ts

@@ -5,7 +5,7 @@ declare function isServer(): boolean;
 declare function isClient(): boolean;
 declare function isDev(): boolean;
 declare function detectEnvironment(): Partial<EnvironmentContext>;
-declare function getConsoleMethod(level: LogLevel): 'log' | 'error' | 'warn';
+declare function getConsoleMethod(level: LogLevel): LogLevel;
 declare const colors: {
     readonly reset: "\u001B[0m";
     readonly bold: "\u001B[1m";

package/dist/utils.mjs

@@ -11,15 +11,19 @@ function isClient() {
   return typeof window !== "undefined";
 }
 function isDev() {
-  if (typeof process !== "undefined" && process.env.NODE_ENV) {
+  if (typeof process !== "undefined") {
     return process.env.NODE_ENV !== "production";
   }
-  return true;
+  if (typeof window !== "undefined") {
+    return true;
+  }
+  return false;
 }
 function detectEnvironment() {
   const env = typeof process !== "undefined" ? process.env : {};
+  const defaultEnvironment = isDev() ? "development" : "production";
   return {
-    environment: env.NODE_ENV || "development",
+    environment: env.NODE_ENV || defaultEnvironment,
     service: env.SERVICE_NAME || "app",
     version: env.APP_VERSION,
     commitHash: env.COMMIT_SHA || env.GITHUB_SHA || env.VERCEL_GIT_COMMIT_SHA || env.CF_PAGES_COMMIT_SHA,
@@ -27,7 +31,7 @@ function detectEnvironment() {
   };
 }
 function getConsoleMethod(level) {
-  return level === "error" ? "error" : level === "warn" ? "warn" : "log";
+  return level;
 }
 const colors = {
   reset: "\x1B[0m",

package/dist/workers.d.mts

@@ -0,0 +1,45 @@
+import { RequestLogger, LoggerConfig } from './types.mjs';
+
+/**
+ * Options for createWorkersLogger
+ */
+interface WorkersLoggerOptions {
+    /** Override the request ID (default: cf-ray header) */
+    requestId?: string;
+    /** Headers to include in logs (default: none) */
+    headers?: string[];
+}
+/**
+ * Initialize evlog for Cloudflare Workers.
+ * Call once at module scope.
+ *
+ * @example
+ * ```ts
+ * initWorkersLogger({
+ *   env: { service: 'my-api' },
+ * })
+ * ```
+ */
+declare function initWorkersLogger(options?: LoggerConfig): void;
+/**
+ * Create a request-scoped logger for Cloudflare Workers.
+ * Auto-extracts cf-ray, request.cf context, method, and path.
+ *
+ * @example
+ * ```ts
+ * export default {
+ *   async fetch(request: Request) {
+ *     const log = createWorkersLogger(request)
+ *
+ *     log.set({ user: { id: '123' } })
+ *     log.emit({ status: 200 })
+ *
+ *     return new Response('ok')
+ *   }
+ * }
+ * ```
+ */
+declare function createWorkersLogger(request: Request, options?: WorkersLoggerOptions): RequestLogger;
+
+export { createWorkersLogger, initWorkersLogger };
+export type { WorkersLoggerOptions };

package/dist/workers.d.ts

@@ -0,0 +1,45 @@
+import { RequestLogger, LoggerConfig } from './types.js';
+
+/**
+ * Options for createWorkersLogger
+ */
+interface WorkersLoggerOptions {
+    /** Override the request ID (default: cf-ray header) */
+    requestId?: string;
+    /** Headers to include in logs (default: none) */
+    headers?: string[];
+}
+/**
+ * Initialize evlog for Cloudflare Workers.
+ * Call once at module scope.
+ *
+ * @example
+ * ```ts
+ * initWorkersLogger({
+ *   env: { service: 'my-api' },
+ * })
+ * ```
+ */
+declare function initWorkersLogger(options?: LoggerConfig): void;
+/**
+ * Create a request-scoped logger for Cloudflare Workers.
+ * Auto-extracts cf-ray, request.cf context, method, and path.
+ *
+ * @example
+ * ```ts
+ * export default {
+ *   async fetch(request: Request) {
+ *     const log = createWorkersLogger(request)
+ *
+ *     log.set({ user: { id: '123' } })
+ *     log.emit({ status: 200 })
+ *
+ *     return new Response('ok')
+ *   }
+ * }
+ * ```
+ */
+declare function createWorkersLogger(request: Request, options?: WorkersLoggerOptions): RequestLogger;
+
+export { createWorkersLogger, initWorkersLogger };
+export type { WorkersLoggerOptions };

package/dist/workers.mjs

@@ -0,0 +1,53 @@
+import { createRequestLogger, initLogger } from './logger.mjs';
+import 'defu';
+import './utils.mjs';
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectHeaders(headers, include) {
+  if (!include || include.length === 0) return void 0;
+  const normalized = new Set(include.map((h) => h.toLowerCase()));
+  const result = {};
+  headers.forEach((value, key) => {
+    if (normalized.has(key.toLowerCase())) {
+      result[key] = value;
+    }
+  });
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function initWorkersLogger(options = {}) {
+  initLogger({
+    ...options,
+    pretty: false,
+    stringify: false
+  });
+}
+function pickCfContext(request) {
+  const cf = Reflect.get(request, "cf");
+  if (!isRecord(cf)) return {};
+  const out = {};
+  if (typeof cf.colo === "string") out.colo = cf.colo;
+  if (typeof cf.country === "string") out.country = cf.country;
+  if (typeof cf.asn === "number") out.asn = cf.asn;
+  return out;
+}
+function createWorkersLogger(request, options = {}) {
+  const url = new URL(request.url);
+  const cfRay = request.headers.get("cf-ray") ?? void 0;
+  const traceparent = request.headers.get("traceparent") ?? void 0;
+  const log = createRequestLogger({
+    method: request.method,
+    path: url.pathname,
+    requestId: options.requestId ?? cfRay
+  });
+  log.set({
+    cfRay,
+    traceparent,
+    ...pickCfContext(request),
+    ...options.headers ? { requestHeaders: collectHeaders(request.headers, options.headers) } : {}
+  });
+  return log;
+}
+
+export { createWorkersLogger, initWorkersLogger };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evlog",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Wide event logging library with structured error handling. Inspired by LoggingSucks.",
   "author": "HugoRCD <contact@hrcd.fr>",
   "homepage": "https://evlog.dev",
@@ -34,6 +34,18 @@
     "./nitro": {
       "types": "./dist/nitro/plugin.d.mts",
       "import": "./dist/nitro/plugin.mjs"
+    },
+    "./workers": {
+      "types": "./dist/workers.d.mts",
+      "import": "./dist/workers.mjs"
+    },
+    "./axiom": {
+      "types": "./dist/adapters/axiom.d.mts",
+      "import": "./dist/adapters/axiom.mjs"
+    },
+    "./otlp": {
+      "types": "./dist/adapters/otlp.d.mts",
+      "import": "./dist/adapters/otlp.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -48,6 +60,15 @@
       ],
       "nitro": [
         "./dist/nitro/plugin.d.mts"
+      ],
+      "workers": [
+        "./dist/workers.d.mts"
+      ],
+      "axiom": [
+        "./dist/adapters/axiom.d.mts"
+      ],
+      "otlp": [
+        "./dist/adapters/otlp.d.mts"
       ]
     }
   },