evlog 2.4.0 → 2.5.0

package/dist/types.d.mts

@@ -1,496 +1,2 @@
-//#region src/types.d.ts
-declare module 'nitropack/types' {
-  interface NitroRuntimeHooks {
-    /**
-     * Tail sampling hook - called before emitting a log.
-     * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.
-     *
-     * @example
-     * ```ts
-     * nitroApp.hooks.hook('evlog:emit:keep', (ctx) => {
-     *   if (ctx.context.user?.premium) {
-     *     ctx.shouldKeep = true
-     *   }
-     * })
-     * ```
-     */
-    'evlog:emit:keep': (ctx: TailSamplingContext) => void | Promise<void>;
-    /**
-     * Enrichment hook - called after emit, before drain.
-     * Use this to enrich the event with derived context (e.g. geo, user agent).
-     *
-     * @example
-     * ```ts
-     * nitroApp.hooks.hook('evlog:enrich', (ctx) => {
-     *   ctx.event.deploymentId = process.env.DEPLOYMENT_ID
-     * })
-     * ```
-     */
-    'evlog:enrich': (ctx: EnrichContext) => void | Promise<void>;
-    /**
-     * Drain hook - called after emitting a log (fire-and-forget).
-     * Use this to send logs to external services like Axiom, Loki, or custom endpoints.
-     * Errors are logged but never block the request.
-     *
-     * @example
-     * ```ts
-     * nitroApp.hooks.hook('evlog:drain', async (ctx) => {
-     *   await fetch('https://api.axiom.co/v1/datasets/logs/ingest', {
-     *     method: 'POST',
-     *     headers: { Authorization: `Bearer ${process.env.AXIOM_TOKEN}` },
-     *     body: JSON.stringify([ctx.event])
-     *   })
-     * })
-     * ```
-     */
-    'evlog:drain': (ctx: DrainContext) => void | Promise<void>;
-  }
-}
-declare module 'nitro/types' {
-  interface NitroRuntimeHooks {
-    'evlog:emit:keep': (ctx: TailSamplingContext) => void | Promise<void>;
-    'evlog:enrich': (ctx: EnrichContext) => void | Promise<void>;
-    '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)
- */
-interface SamplingRates {
-  /** Percentage of info logs to keep (0-100). Default: 100 */
-  info?: number;
-  /** Percentage of warn logs to keep (0-100). Default: 100 */
-  warn?: number;
-  /** Percentage of debug logs to keep (0-100). Default: 100 */
-  debug?: number;
-  /** Percentage of error logs to keep (0-100). Default: 100 */
-  error?: number;
-}
-/**
- * Tail sampling condition for forcing log retention based on request outcome.
- * All conditions use >= comparison (e.g., status: 400 means status >= 400).
- */
-interface TailSamplingCondition {
-  /** Keep if HTTP status >= this value (e.g., 400 for all errors) */
-  status?: number;
-  /** Keep if request duration >= this value in milliseconds */
-  duration?: number;
-  /** Keep if path matches this glob pattern (e.g., '/api/critical/**') */
-  path?: string;
-}
-/**
- * Context passed to tail sampling evaluation and hooks.
- * Contains request outcome information for sampling decisions.
- */
-interface TailSamplingContext {
-  /** HTTP response status code */
-  status?: number;
-  /** Request duration in milliseconds (raw number) */
-  duration?: number;
-  /** Request path */
-  path?: string;
-  /** HTTP method */
-  method?: string;
-  /** Full accumulated context from the request logger */
-  context: Record<string, unknown>;
-  /**
-   * Set to true in evlog:emit:keep hook to force keep this log.
-   * Multiple hooks can set this - if any sets it to true, the log is kept.
-   */
-  shouldKeep?: boolean;
-}
-/**
- * Context passed to the evlog:enrich hook.
- * Called after emit, before drain.
- */
-interface EnrichContext {
-  /** The emitted wide event (mutable). */
-  event: WideEvent;
-  /** Request metadata (if available) */
-  request?: {
-    method?: string;
-    path: string;
-    requestId?: string;
-  };
-  /** Safe HTTP request headers (sensitive headers filtered out) */
-  headers?: Record<string, string>;
-  /** Optional response metadata */
-  response?: {
-    status?: number;
-    headers?: Record<string, string>;
-  };
-}
-/**
- * Context passed to the evlog:drain hook.
- * Contains the complete wide event and request metadata for external transport.
- */
-interface DrainContext {
-  /** The complete wide event to drain */
-  event: WideEvent;
-  /** Request metadata (if available) */
-  request?: {
-    method?: string;
-    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
- */
-interface SamplingConfig {
-  /**
-   * Sampling rates per log level (head sampling).
-   * Values are percentages from 0 to 100.
-   * Default: 100 for all levels (log everything).
-   * Error defaults to 100 even if not specified.
-   *
-   * @example
-   * ```ts
-   * sampling: {
-   *   rates: {
-   *     info: 10,    // Keep 10% of info logs
-   *     warn: 50,    // Keep 50% of warning logs
-   *     debug: 5,    // Keep 5% of debug logs
-   *     error: 100,  // Always keep errors (default)
-   *   }
-   * }
-   * ```
-   */
-  rates?: SamplingRates;
-  /**
-   * Tail sampling conditions for forcing log retention (OR logic).
-   * If ANY condition matches, the log is kept regardless of head sampling.
-   * Use the `evlog:emit:keep` Nitro hook for custom conditions.
-   *
-   * @example
-   * ```ts
-   * sampling: {
-   *   rates: { info: 10 },  // Head sampling: keep 10% of info logs
-   *   keep: [
-   *     { status: 400 },     // Always keep if status >= 400
-   *     { duration: 1000 },  // Always keep if duration >= 1000ms
-   *     { path: '/api/critical/**' },  // Always keep critical paths
-   *   ]
-   * }
-   * ```
-   */
-  keep?: TailSamplingCondition[];
-}
-/**
- * Route-based service configuration
- */
-interface RouteConfig {
-  /** Service name to use for routes matching this pattern */
-  service: string;
-}
-/**
- * Environment context automatically included in every log event
- */
-interface EnvironmentContext {
-  /** Service name (auto-detected from package.json or configurable) */
-  service: string;
-  /** Environment: 'development', 'production', 'test', etc. */
-  environment: 'development' | 'production' | 'test' | string;
-  /** Application version (auto-detected from package.json) */
-  version?: string;
-  /** Git commit hash (auto-detected from CI/CD env vars) */
-  commitHash?: string;
-  /** Deployment region (auto-detected from cloud provider env vars) */
-  region?: string;
-}
-/**
- * Logger configuration options
- */
-interface LoggerConfig {
-  /**
-   * Enable or disable all logging globally.
-   * When false, all emits, tagged logs, and request logger operations become no-ops.
-   * @default true
-   */
-  enabled?: boolean;
-  /** Environment context overrides */
-  env?: Partial<EnvironmentContext>;
-  /** Enable pretty printing (auto-detected: true in dev, false in prod) */
-  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;
-  /**
-   * Drain callback called with every emitted event (fire-and-forget).
-   * Use this to send logs to external services outside of Nitro.
-   * Compatible with drain adapters (`createAxiomDrain()`) and pipeline-wrapped drains.
-   *
-   * @example
-   * ```ts
-   * import { initLogger, log } from 'evlog'
-   * import { createAxiomDrain } from 'evlog/axiom'
-   *
-   * initLogger({
-   *   drain: createAxiomDrain({ dataset: 'logs', token: '...' }),
-   * })
-   *
-   * log.info({ action: 'user_login' }) // automatically drained
-   * ```
-   *
-   * @example
-   * ```ts
-   * // With pipeline for batching and retry
-   * import { createDrainPipeline } from 'evlog/pipeline'
-   *
-   * const pipeline = createDrainPipeline({ batch: { size: 25 } })
-   * const drain = pipeline(createAxiomDrain({ dataset: 'logs', token: '...' }))
-   *
-   * initLogger({ drain })
-   *
-   * // Flush on shutdown
-   * process.on('beforeExit', () => drain.flush())
-   * ```
-   */
-  drain?: (ctx: DrainContext) => void | Promise<void>;
-}
-/**
- * Base structure for all wide events
- */
-interface BaseWideEvent {
-  timestamp: string;
-  level: 'info' | 'error' | 'warn' | 'debug';
-  service: string;
-  environment: string;
-  version?: string;
-  commitHash?: string;
-  region?: string;
-}
-/**
- * Wide event with arbitrary additional fields
- */
-type WideEvent = BaseWideEvent & Record<string, unknown>;
-/**
- * Recursively makes all properties optional.
- * Arrays are kept as-is (not deeply partial).
- */
-type DeepPartial<T> = T extends Array<unknown> ? T : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
-/**
- * Fields set internally by the evlog plugin (status, service, etc.).
- * These are always accepted by `set()` regardless of the user-defined field type.
- */
-interface InternalFields {
-  status?: number;
-  service?: string;
-  requestLogs?: RequestLogEntry[];
-}
-/**
- * Request-scoped log entry captured during a request lifecycle.
- */
-interface RequestLogEntry {
-  level: 'info' | 'warn';
-  message: string;
-  timestamp: string;
-}
-/**
- * Resolved context type for logger methods.
- * User fields are deeply partial (matching deep merge behavior) with internal
- * field keys omitted to avoid intersection conflicts, then internal fields
- * are added back with their canonical types.
- */
-type FieldContext<T extends object = Record<string, unknown>> = DeepPartial<Omit<T, keyof InternalFields>> & InternalFields;
-/**
- * Request-scoped logger for building wide events
- *
- * @example
- * ```ts
- * const logger = useLogger(event)
- * logger.set({ user: { id: '123' } })
- * logger.set({ cart: { items: 3 } })
- * // emit() is called automatically by the plugin
- * ```
- *
- * @example
- * ```ts
- * // With typed fields for compile-time safety
- * interface MyFields {
- *   user: { id: string; plan: string }
- *   action: string
- * }
- * const logger = useLogger<MyFields>(event)
- * logger.set({ user: { id: '123', plan: 'pro' } }) // OK
- * logger.set({ user: { id: '123' } })               // OK (deep partial)
- * logger.set({ action: 'checkout' })                 // OK
- * logger.set({ status: 200 })                        // OK (internal field)
- * logger.set({ account: '...' })                     // TS error
- * ```
- */
-interface RequestLogger<T extends object = Record<string, unknown>> {
-  /**
-   * Add context to the wide event (deep merge via defu)
-   */
-  set: (context: FieldContext<T>) => void;
-  /**
-   * Log an error and capture its details
-   */
-  error: (error: Error | string, context?: FieldContext<T>) => void;
-  /**
-   * Capture an informational message inside the request wide event.
-   */
-  info: (message: string, context?: FieldContext<T>) => void;
-  /**
-   * Capture a warning message inside the request wide event.
-   */
-  warn: (message: string, context?: FieldContext<T>) => void;
-  /**
-   * Emit the final wide event with all accumulated context.
-   * Returns the emitted WideEvent, or null if the log was sampled out.
-   */
-  emit: (overrides?: FieldContext<T> & {
-    _forceKeep?: boolean;
-  }) => WideEvent | null;
-  /**
-   * Get the current accumulated context
-   */
-  getContext: () => FieldContext<T> & Record<string, unknown>;
-}
-/**
- * Log level type
- */
-type LogLevel = 'info' | 'error' | 'warn' | 'debug';
-/**
- * Simple logging API - as easy as console.log
- *
- * @example
- * ```ts
- * log.info('auth', 'User logged in')
- * log.error({ action: 'payment', error: 'failed' })
- * ```
- */
-interface Log {
-  /**
-   * Log an info message or wide event
-   * @example log.info('auth', 'User logged in')
-   * @example log.info({ action: 'login', userId: '123' })
-   */
-  info(tag: string, message: string): void;
-  info(event: Record<string, unknown>): void;
-  /**
-   * Log an error message or wide event
-   * @example log.error('payment', 'Payment failed')
-   * @example log.error({ action: 'payment', error: 'declined' })
-   */
-  error(tag: string, message: string): void;
-  error(event: Record<string, unknown>): void;
-  /**
-   * Log a warning message or wide event
-   * @example log.warn('api', 'Rate limit approaching')
-   * @example log.warn({ action: 'api', remaining: 10 })
-   */
-  warn(tag: string, message: string): void;
-  warn(event: Record<string, unknown>): void;
-  /**
-   * Log a debug message or wide event
-   * @example log.debug('cache', 'Cache miss')
-   * @example log.debug({ action: 'cache', key: 'user_123' })
-   */
-  debug(tag: string, message: string): void;
-  debug(event: Record<string, unknown>): void;
-}
-/**
- * Error options for creating structured errors
- */
-interface ErrorOptions {
-  /** What actually happened */
-  message: string;
-  /** HTTP status code (default: 500) */
-  status?: number;
-  /** Why this error occurred */
-  why?: string;
-  /** How to fix this issue */
-  fix?: string;
-  /** Link to documentation or more information */
-  link?: string;
-  /** The original error that caused this */
-  cause?: Error;
-}
-/**
- * Options for creating a request logger
- */
-interface RequestLoggerOptions {
-  method?: string;
-  path?: string;
-  requestId?: string;
-}
-/**
- * H3 event context with evlog logger attached
- */
-interface H3EventContext {
-  log?: RequestLogger;
-  requestId?: string;
-  status?: number;
-  /** Internal: start time for duration calculation in tail sampling */
-  _evlogStartTime?: number;
-  /** Internal: flag to prevent double emission on errors */
-  _evlogEmitted?: boolean;
-  [key: string]: unknown;
-}
-/**
- * Server event type for Nitro/h3 handlers
- */
-interface ServerEvent {
-  method: string;
-  path: string;
-  context: H3EventContext & {
-    /** Cloudflare Workers context (available when deployed to CF Workers) */cloudflare?: {
-      context: {
-        waitUntil: (promise: Promise<unknown>) => void;
-      };
-    }; /** Vercel Edge context (available when deployed to Vercel Edge) */
-    waitUntil?: (promise: Promise<unknown>) => void;
-  };
-  node?: {
-    res?: {
-      statusCode?: number;
-    };
-  };
-  response?: Response;
-}
-/**
- * Parsed evlog error with all fields at the top level
- */
-interface ParsedError {
-  message: string;
-  status: number;
-  why?: string;
-  fix?: string;
-  link?: string;
-  raw: unknown;
-}
-//#endregion
-export { BaseWideEvent, DeepPartial, DrainContext, EnrichContext, EnvironmentContext, ErrorOptions, FieldContext, H3EventContext, IngestPayload, InternalFields, Log, LogLevel, LoggerConfig, ParsedError, RequestLogEntry, RequestLogger, RequestLoggerOptions, RouteConfig, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent };
-//# sourceMappingURL=types.d.mts.map
+import { C as TailSamplingContext, S as TailSamplingCondition, T as WideEvent, _ as RequestLoggerOptions, a as EnvironmentContext, b as SamplingRates, c as H3EventContext, d as Log, f as LogLevel, g as RequestLogger, h as RequestLogEntry, i as EnrichContext, l as IngestPayload, m as ParsedError, n as DeepPartial, o as ErrorOptions, p as LoggerConfig, r as DrainContext, s as FieldContext, t as BaseWideEvent, u as InternalFields, v as RouteConfig, w as TransportConfig, x as ServerEvent, y as SamplingConfig } from "./types-CRj5tGVA.mjs";
+export { BaseWideEvent, DeepPartial, DrainContext, EnrichContext, EnvironmentContext, ErrorOptions, FieldContext, H3EventContext, IngestPayload, InternalFields, Log, LogLevel, LoggerConfig, ParsedError, RequestLogEntry, RequestLogger, RequestLoggerOptions, RouteConfig, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent };

package/dist/types.mjs

@@ -1 +1 @@
-export {  };
+export {};

package/dist/useLogger-w7MZjqW_.d.mts

@@ -0,0 +1,39 @@
+import { g as RequestLogger, x as ServerEvent } from "./types-CRj5tGVA.mjs";
+
+//#region src/runtime/server/useLogger.d.ts
+/**
+ * Returns the request logger attached to the given server event.
+ *
+ * @param event - The current server event containing the context with the logger.
+ * @param service - Optional service name to override the default service.
+ * @returns The request-scoped logger.
+ * @throws Error if the logger is not initialized on the event context.
+ *
+ * @example
+ * export default defineEventHandler((event) => {
+ *   const log = useLogger(event)
+ *   log.set({ foo: 'bar' })
+ *   // ...
+ * })
+ *
+ * @example
+ * // Override service name for specific routes
+ * export default defineEventHandler((event) => {
+ *   const log = useLogger(event, 'payment-service')
+ *   log.set({ foo: 'bar' })
+ *   // ...
+ * })
+ *
+ * @example
+ * // Typed fields — must use explicit import for type checking to work
+ * import { useLogger } from 'evlog'
+ *
+ * interface MyFields { user: { id: string; plan: string } }
+ * const log = useLogger<MyFields>(event)
+ * log.set({ user: { id: '123', plan: 'pro' } }) // OK
+ * log.set({ foo: 'bar' })                        // TS error
+ */
+declare function useLogger<T extends object = Record<string, unknown>>(event: ServerEvent, service?: string): RequestLogger<T>;
+//#endregion
+export { useLogger as t };
+//# sourceMappingURL=useLogger-w7MZjqW_.d.mts.map

package/dist/useLogger-w7MZjqW_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLogger-w7MZjqW_.d.mts","names":[],"sources":["../src/runtime/server/useLogger.ts"],"mappings":";;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,oBAA6B,MAAA,kBAAA,CAAyB,KAAA,EAAO,WAAA,EAAa,OAAA,YAAmB,aAAA,CAAc,CAAA"}

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { EnvironmentContext, LogLevel } from "./types.mjs";
+import { a as EnvironmentContext, f as LogLevel } from "./types-CRj5tGVA.mjs";
 
 //#region src/utils.d.ts
 declare function formatDuration(ms: number): string;

package/dist/utils.mjs

@@ -72,7 +72,7 @@ function matchesPattern(path, pattern) {
 	const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\?/g, "[^/]");
 	return new RegExp(`^${regexPattern}$`).test(path);
 }
-
 //#endregion
 export { SENSITIVE_HEADERS, colors, detectEnvironment, filterSafeHeaders, formatDuration, getConsoleMethod, getLevelColor, isClient, isDev, isServer, matchesPattern };
+
 //# sourceMappingURL=utils.mjs.map

package/dist/workers.d.mts

@@ -1,4 +1,4 @@
-import { LoggerConfig, RequestLogger } from "./types.mjs";
+import { g as RequestLogger, p as LoggerConfig } from "./types-CRj5tGVA.mjs";
 
 //#region src/workers/index.d.ts
 /**

package/dist/workers.mjs

@@ -1,5 +1,4 @@
 import { createRequestLogger, initLogger } from "./logger.mjs";
-
 //#region src/workers/index.ts
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -75,7 +74,7 @@ function createWorkersLogger(request, options = {}) {
 	});
 	return log;
 }
-
 //#endregion
 export { createWorkersLogger, initWorkersLogger };
+
 //# sourceMappingURL=workers.mjs.map

package/dist/workers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"workers.mjs","names":[],"sources":["../src/workers/index.ts"],"sourcesContent":["import { initLogger, createRequestLogger } from '../logger'\nimport type { LoggerConfig, RequestLogger } from '../types'\n\n/**\n * Options for createWorkersLogger\n */\nexport interface WorkersLoggerOptions {\n  /** Override the request ID (default: cf-ray header) */\n  requestId?: string\n  /** Headers to include in logs (default: none) */\n  headers?: string[]\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction collectHeaders(headers: Headers, include: string[] | undefined): Record<string, string> | undefined {\n  if (!include || include.length === 0) return undefined\n\n  const normalized = new Set(include.map(h => h.toLowerCase()))\n  const result: Record<string, string> = {}\n\n  headers.forEach((value, key) => {\n    if (normalized.has(key.toLowerCase())) {\n      result[key] = value\n    }\n  })\n\n  return Object.keys(result).length > 0 ? result : undefined\n}\n\n/**\n * Initialize evlog for Cloudflare Workers.\n * Call once at module scope.\n *\n * @example\n * ```ts\n * initWorkersLogger({\n *   env: { service: 'my-api' },\n * })\n * ```\n */\nexport function initWorkersLogger(options: LoggerConfig = {}): void {\n  initLogger({\n    ...options,\n    pretty: false,\n    stringify: false,\n  })\n}\n\nfunction pickCfContext(request: Request): Record<string, unknown> {\n  const cf = Reflect.get(request, 'cf')\n  if (!isRecord(cf)) return {}\n\n  const out: Record<string, unknown> = {}\n  if (typeof cf.colo === 'string') out.colo = cf.colo\n  if (typeof cf.country === 'string') out.country = cf.country\n  if (typeof cf.asn === 'number') out.asn = cf.asn\n  return out\n}\n\n/**\n * Create a request-scoped logger for Cloudflare Workers.\n * Auto-extracts cf-ray, request.cf context, method, and path.\n *\n * @example\n * ```ts\n * export default {\n *   async fetch(request: Request) {\n *     const log = createWorkersLogger(request)\n *\n *     log.set({ user: { id: '123' } })\n *     log.emit({ status: 200 })\n *\n *     return new Response('ok')\n *   }\n * }\n * ```\n */\nexport function createWorkersLogger<T extends object = Record<string, unknown>>(request: Request, options: WorkersLoggerOptions = {}): RequestLogger<T> {\n  const url = new URL(request.url)\n  const cfRay = request.headers.get('cf-ray') ?? undefined\n  const traceparent = request.headers.get('traceparent') ?? undefined\n\n  const log = createRequestLogger<T>({\n    method: request.method,\n    path: url.pathname,\n    requestId: options.requestId ?? cfRay,\n  })\n\n  // Cast needed: CF-specific enrichment fields (cfRay, traceparent, etc.) aren't in user's T\n  const untyped = log as unknown as RequestLogger\n  untyped.set({\n    cfRay,\n    traceparent,\n    ...pickCfContext(request),\n    ...(options.headers ? { requestHeaders: collectHeaders(request.headers, options.headers) } : {}),\n  })\n\n  return log\n}\n"],"mappings":";;;AAaA,SAAS,SAAS,OAAkD;AAClE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM;;AAG7E,SAAS,eAAe,SAAkB,SAAmE;AAC3G,KAAI,CAAC,WAAW,QAAQ,WAAW,EAAG,QAAO;CAE7C,MAAM,aAAa,IAAI,IAAI,QAAQ,KAAI,MAAK,EAAE,aAAa,CAAC,CAAC;CAC7D,MAAM,SAAiC,EAAE;AAEzC,SAAQ,SAAS,OAAO,QAAQ;AAC9B,MAAI,WAAW,IAAI,IAAI,aAAa,CAAC,CACnC,QAAO,OAAO;GAEhB;AAEF,QAAO,OAAO,KAAK,OAAO,CAAC,SAAS,IAAI,SAAS;;;;;;;;;;;;;AAcnD,SAAgB,kBAAkB,UAAwB,EAAE,EAAQ;AAClE,YAAW;EACT,GAAG;EACH,QAAQ;EACR,WAAW;EACZ,CAAC;;AAGJ,SAAS,cAAc,SAA2C;CAChE,MAAM,KAAK,QAAQ,IAAI,SAAS,KAAK;AACrC,KAAI,CAAC,SAAS,GAAG,CAAE,QAAO,EAAE;CAE5B,MAAM,MAA+B,EAAE;AACvC,KAAI,OAAO,GAAG,SAAS,SAAU,KAAI,OAAO,GAAG;AAC/C,KAAI,OAAO,GAAG,YAAY,SAAU,KAAI,UAAU,GAAG;AACrD,KAAI,OAAO,GAAG,QAAQ,SAAU,KAAI,MAAM,GAAG;AAC7C,QAAO;;;;;;;;;;;;;;;;;;;;AAqBT,SAAgB,oBAAgE,SAAkB,UAAgC,EAAE,EAAoB;CACtJ,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;CAChC,MAAM,QAAQ,QAAQ,QAAQ,IAAI,SAAS,IAAI;CAC/C,MAAM,cAAc,QAAQ,QAAQ,IAAI,cAAc,IAAI;CAE1D,MAAM,MAAM,oBAAuB;EACjC,QAAQ,QAAQ;EAChB,MAAM,IAAI;EACV,WAAW,QAAQ,aAAa;EACjC,CAAC;AAIF,CADgB,IACR,IAAI;EACV;EACA;EACA,GAAG,cAAc,QAAQ;EACzB,GAAI,QAAQ,UAAU,EAAE,gBAAgB,eAAe,QAAQ,SAAS,QAAQ,QAAQ,EAAE,GAAG,EAAE;EAChG,CAAC;AAEF,QAAO"}
+{"version":3,"file":"workers.mjs","names":[],"sources":["../src/workers/index.ts"],"sourcesContent":["import { initLogger, createRequestLogger } from '../logger'\nimport type { LoggerConfig, RequestLogger } from '../types'\n\n/**\n * Options for createWorkersLogger\n */\nexport interface WorkersLoggerOptions {\n  /** Override the request ID (default: cf-ray header) */\n  requestId?: string\n  /** Headers to include in logs (default: none) */\n  headers?: string[]\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n}\n\nfunction collectHeaders(headers: Headers, include: string[] | undefined): Record<string, string> | undefined {\n  if (!include || include.length === 0) return undefined\n\n  const normalized = new Set(include.map(h => h.toLowerCase()))\n  const result: Record<string, string> = {}\n\n  headers.forEach((value, key) => {\n    if (normalized.has(key.toLowerCase())) {\n      result[key] = value\n    }\n  })\n\n  return Object.keys(result).length > 0 ? result : undefined\n}\n\n/**\n * Initialize evlog for Cloudflare Workers.\n * Call once at module scope.\n *\n * @example\n * ```ts\n * initWorkersLogger({\n *   env: { service: 'my-api' },\n * })\n * ```\n */\nexport function initWorkersLogger(options: LoggerConfig = {}): void {\n  initLogger({\n    ...options,\n    pretty: false,\n    stringify: false,\n  })\n}\n\nfunction pickCfContext(request: Request): Record<string, unknown> {\n  const cf = Reflect.get(request, 'cf')\n  if (!isRecord(cf)) return {}\n\n  const out: Record<string, unknown> = {}\n  if (typeof cf.colo === 'string') out.colo = cf.colo\n  if (typeof cf.country === 'string') out.country = cf.country\n  if (typeof cf.asn === 'number') out.asn = cf.asn\n  return out\n}\n\n/**\n * Create a request-scoped logger for Cloudflare Workers.\n * Auto-extracts cf-ray, request.cf context, method, and path.\n *\n * @example\n * ```ts\n * export default {\n *   async fetch(request: Request) {\n *     const log = createWorkersLogger(request)\n *\n *     log.set({ user: { id: '123' } })\n *     log.emit({ status: 200 })\n *\n *     return new Response('ok')\n *   }\n * }\n * ```\n */\nexport function createWorkersLogger<T extends object = Record<string, unknown>>(request: Request, options: WorkersLoggerOptions = {}): RequestLogger<T> {\n  const url = new URL(request.url)\n  const cfRay = request.headers.get('cf-ray') ?? undefined\n  const traceparent = request.headers.get('traceparent') ?? undefined\n\n  const log = createRequestLogger<T>({\n    method: request.method,\n    path: url.pathname,\n    requestId: options.requestId ?? cfRay,\n  })\n\n  // Cast needed: CF-specific enrichment fields (cfRay, traceparent, etc.) aren't in user's T\n  const untyped = log as unknown as RequestLogger\n  untyped.set({\n    cfRay,\n    traceparent,\n    ...pickCfContext(request),\n    ...(options.headers ? { requestHeaders: collectHeaders(request.headers, options.headers) } : {}),\n  })\n\n  return log\n}\n"],"mappings":";;AAaA,SAAS,SAAS,OAAkD;AAClE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM;;AAG7E,SAAS,eAAe,SAAkB,SAAmE;AAC3G,KAAI,CAAC,WAAW,QAAQ,WAAW,EAAG,QAAO,KAAA;CAE7C,MAAM,aAAa,IAAI,IAAI,QAAQ,KAAI,MAAK,EAAE,aAAa,CAAC,CAAC;CAC7D,MAAM,SAAiC,EAAE;AAEzC,SAAQ,SAAS,OAAO,QAAQ;AAC9B,MAAI,WAAW,IAAI,IAAI,aAAa,CAAC,CACnC,QAAO,OAAO;GAEhB;AAEF,QAAO,OAAO,KAAK,OAAO,CAAC,SAAS,IAAI,SAAS,KAAA;;;;;;;;;;;;;AAcnD,SAAgB,kBAAkB,UAAwB,EAAE,EAAQ;AAClE,YAAW;EACT,GAAG;EACH,QAAQ;EACR,WAAW;EACZ,CAAC;;AAGJ,SAAS,cAAc,SAA2C;CAChE,MAAM,KAAK,QAAQ,IAAI,SAAS,KAAK;AACrC,KAAI,CAAC,SAAS,GAAG,CAAE,QAAO,EAAE;CAE5B,MAAM,MAA+B,EAAE;AACvC,KAAI,OAAO,GAAG,SAAS,SAAU,KAAI,OAAO,GAAG;AAC/C,KAAI,OAAO,GAAG,YAAY,SAAU,KAAI,UAAU,GAAG;AACrD,KAAI,OAAO,GAAG,QAAQ,SAAU,KAAI,MAAM,GAAG;AAC7C,QAAO;;;;;;;;;;;;;;;;;;;;AAqBT,SAAgB,oBAAgE,SAAkB,UAAgC,EAAE,EAAoB;CACtJ,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;CAChC,MAAM,QAAQ,QAAQ,QAAQ,IAAI,SAAS,IAAI,KAAA;CAC/C,MAAM,cAAc,QAAQ,QAAQ,IAAI,cAAc,IAAI,KAAA;CAE1D,MAAM,MAAM,oBAAuB;EACjC,QAAQ,QAAQ;EAChB,MAAM,IAAI;EACV,WAAW,QAAQ,aAAa;EACjC,CAAC;AAGc,KACR,IAAI;EACV;EACA;EACA,GAAG,cAAc,QAAQ;EACzB,GAAI,QAAQ,UAAU,EAAE,gBAAgB,eAAe,QAAQ,SAAS,QAAQ,QAAQ,EAAE,GAAG,EAAE;EAChG,CAAC;AAEF,QAAO"}