evlog 2.11.0 → 2.12.0

package/dist/{headers-BSi3UHKL.mjs → headers-ht4yS2mx.mjs}

@@ -1,7 +1,7 @@
 import { filterSafeHeaders } from "./utils.mjs";
-import { createRequestLogger, getGlobalDrain, isEnabled, shouldKeep } from "./logger.mjs";
-import { t as extractErrorStatus } from "./errors-gH4C9KSC.mjs";
-import { n as shouldLog, t as getServiceForPath } from "./routes-CE3_c-iZ.mjs";
+import { a as getGlobalDrain, f as redactEvent, p as resolveRedactConfig, r as createRequestLogger, s as isEnabled, u as shouldKeep } from "./logger-DY0X5oQd.mjs";
+import { t as extractErrorStatus } from "./errors-BJRXUfMg.mjs";
+import { n as shouldLog, t as getServiceForPath } from "./routes-CGPmbzCZ.mjs";
 //#region src/shared/middleware.ts
 const noopResult = {
 	logger: {
@@ -20,6 +20,8 @@ const noopResult = {
 	skipped: true
 };
 async function runEnrichAndDrain(emittedEvent, options, requestInfo, responseStatus) {
+	const resolvedRedact = resolveRedactConfig(options.redact);
+	if (resolvedRedact) redactEvent(emittedEvent, resolvedRedact);
 	if (options.enrich) {
 		const enrichCtx = {
 			event: emittedEvent,
@@ -139,4 +141,4 @@ function extractSafeNodeHeaders(headers) {
 //#endregion
 export { extractSafeNodeHeaders as n, createMiddlewareLogger as r, extractSafeHeaders as t };
 
-//# sourceMappingURL=headers-BSi3UHKL.mjs.map
+//# sourceMappingURL=headers-ht4yS2mx.mjs.map

package/dist/headers-ht4yS2mx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers-ht4yS2mx.mjs","names":[],"sources":["../src/shared/middleware.ts","../src/shared/headers.ts"],"sourcesContent":["import type { DrainContext, EnrichContext, RedactConfig, RequestLogger, RouteConfig, TailSamplingContext, WideEvent } from '../types'\nimport { createRequestLogger, getGlobalDrain, isEnabled, shouldKeep } from '../logger'\nimport { redactEvent, resolveRedactConfig } from '../redact'\nimport { extractErrorStatus } from './errors'\nimport { shouldLog, getServiceForPath } from './routes'\n\n/**\n * Base options shared by all framework integrations.\n *\n * Every framework-specific options interface (e.g. `EvlogExpressOptions`)\n * extends this type. If a framework needs extra fields it can add them\n * on top; otherwise the base is used as-is.\n *\n * @beta Part of `evlog/toolkit` — the public API for building custom integrations.\n */\nexport interface BaseEvlogOptions {\n  /** Route patterns to include in logging (glob). If not set, all routes are logged */\n  include?: string[]\n  /** Route patterns to exclude from logging. Exclusions take precedence over inclusions */\n  exclude?: string[]\n  /** Route-specific service configuration */\n  routes?: Record<string, RouteConfig>\n  /**\n   * Drain callback called with every emitted event.\n   * Use with drain adapters (Axiom, OTLP, Sentry, etc.) or custom endpoints.\n   */\n  drain?: (ctx: DrainContext) => void | Promise<void>\n  /**\n   * Enrich callback called after emit, before drain.\n   * Use to add derived context (geo, deployment info, user agent, etc.).\n   */\n  enrich?: (ctx: EnrichContext) => void | Promise<void>\n  /**\n   * Custom tail sampling callback.\n   * Set `ctx.shouldKeep = true` to force-keep the log regardless of head sampling.\n   */\n  keep?: (ctx: TailSamplingContext) => void | Promise<void>\n  /**\n   * Auto-redaction configuration for PII protection.\n   * `true` enables all built-in PII patterns. Pass an object for fine-grained control.\n   * Applied before enrich/drain. Also applied at the core `emitWideEvent` level\n   * when configured via `initLogger()`.\n   */\n  redact?: boolean | RedactConfig\n}\n\n/**\n * Internal options consumed by `createMiddlewareLogger`.\n * Extends `BaseEvlogOptions` with the request-specific fields\n * that framework adapters must provide.\n */\nexport interface MiddlewareLoggerOptions extends BaseEvlogOptions {\n  method: string\n  path: string\n  requestId?: string\n  /** Pre-filtered safe request headers (used for enrich/drain context) */\n  headers?: Record<string, string>\n}\n\nexport interface MiddlewareLoggerResult {\n  logger: RequestLogger\n  finish: (opts?: { status?: number; error?: Error }) => Promise<WideEvent | null>\n  skipped: boolean\n}\n\nconst noopResult: MiddlewareLoggerResult = {\n  logger: {\n    set() {},\n    error() {},\n    info() {},\n    warn() {},\n    emit() {\n      return null \n    },\n    getContext() {\n      return {} \n    },\n  },\n  finish: () => Promise.resolve(null),\n  skipped: true,\n}\n\nasync function runEnrichAndDrain(\n  emittedEvent: WideEvent,\n  options: MiddlewareLoggerOptions,\n  requestInfo: { method: string; path: string; requestId?: string },\n  responseStatus?: number,\n): Promise<void> {\n  const resolvedRedact = resolveRedactConfig(options.redact)\n  if (resolvedRedact) {\n    redactEvent(emittedEvent, resolvedRedact)\n  }\n\n  if (options.enrich) {\n    const enrichCtx: EnrichContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n      response: { status: responseStatus },\n    }\n    try {\n      await options.enrich(enrichCtx)\n    } catch (err) {\n      console.error('[evlog] enrich failed:', err)\n    }\n  }\n\n  const drain = options.drain ?? getGlobalDrain()\n  if (drain) {\n    const drainCtx: DrainContext = {\n      event: emittedEvent,\n      request: requestInfo,\n      headers: options.headers,\n    }\n    try {\n      await drain(drainCtx)\n    } catch (err) {\n      console.error('[evlog] drain failed:', err)\n    }\n  }\n}\n\n/**\n * Create a middleware-aware request logger with full lifecycle management.\n *\n * Handles the complete pipeline shared across all framework integrations:\n * route filtering, logger creation, service overrides, duration tracking,\n * tail sampling evaluation, event emission, enrichment, and draining.\n *\n * Framework adapters only need to:\n * 1. Extract method/path/requestId/headers from the framework request\n * 2. Call `createMiddlewareLogger()` with those + user options\n * 3. Check `skipped` — if true, skip to next middleware\n * 4. Store `logger` in framework-specific context (e.g., `c.set('log', logger)`)\n * 5. Call `finish({ status })` or `finish({ error })` at response end\n *\n * @beta Part of `evlog/toolkit` — the public API for building custom integrations.\n */\nexport function createMiddlewareLogger(options: MiddlewareLoggerOptions): MiddlewareLoggerResult {\n  if (!isEnabled()) return noopResult\n\n  const { method, path, requestId, include, exclude, routes, keep } = options\n\n  if (!shouldLog(path, include, exclude)) {\n    return noopResult\n  }\n\n  const resolvedRequestId = requestId || crypto.randomUUID()\n\n  const logger = createRequestLogger({\n    method,\n    path,\n    requestId: resolvedRequestId,\n  }, { _deferDrain: true })\n\n  const routeService = getServiceForPath(path, routes)\n  if (routeService) {\n    logger.set({ service: routeService })\n  }\n\n  const startTime = Date.now()\n  const requestInfo = { method, path, requestId: resolvedRequestId }\n\n  const finish = async (opts?: { status?: number; error?: Error }): Promise<WideEvent | null> => {\n    const { status, error } = opts ?? {}\n\n    if (error) {\n      logger.error(error)\n      const errorStatus = extractErrorStatus(error)\n      logger.set({ status: errorStatus })\n    } else if (status !== undefined) {\n      logger.set({ status })\n    }\n\n    const durationMs = Date.now() - startTime\n\n    const resolvedStatus = error\n      ? extractErrorStatus(error)\n      : status ?? (logger.getContext().status as number | undefined)\n\n    const tailCtx: TailSamplingContext = {\n      status: resolvedStatus,\n      duration: durationMs,\n      path,\n      method,\n      context: logger.getContext(),\n      shouldKeep: false,\n    }\n\n    if (keep) {\n      await keep(tailCtx)\n    }\n\n    const forceKeep = tailCtx.shouldKeep || shouldKeep(tailCtx)\n    const emittedEvent = logger.emit({ _forceKeep: forceKeep })\n\n    if (emittedEvent && (options.enrich || options.drain || getGlobalDrain())) {\n      await runEnrichAndDrain(emittedEvent, options, requestInfo, resolvedStatus)\n    }\n\n    return emittedEvent\n  }\n\n  return { logger, finish, skipped: false }\n}\n","import { filterSafeHeaders } from '../utils'\n\n/**\n * Extract headers from a Web API `Headers` object and filter out sensitive ones.\n * Works with any runtime that supports the standard `Headers` API (Hono, Elysia,\n * Nitro v3, Cloudflare Workers, Bun, Deno, etc.).\n */\nexport function extractSafeHeaders(headers: Headers): Record<string, string> {\n  const raw: Record<string, string> = {}\n  headers.forEach((value, key) => {\n    raw[key] = value\n  })\n  return filterSafeHeaders(raw)\n}\n\n/**\n * Extract headers from Node.js `IncomingHttpHeaders` and filter out sensitive ones.\n * Works with Express, Fastify, and any Node.js HTTP server using `req.headers`.\n */\nexport function extractSafeNodeHeaders(headers: Record<string, string | string[] | undefined>): Record<string, string> {\n  const raw: Record<string, string> = {}\n  for (const [key, value] of Object.entries(headers)) {\n    if (value === undefined) continue\n    raw[key] = Array.isArray(value) ? value.join(', ') : value\n  }\n  return filterSafeHeaders(raw)\n}\n"],"mappings":"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"}

package/dist/hono/index.d.mts

@@ -1,5 +1,5 @@
-import { g as RequestLogger } from "../types-v_JkG_D7.mjs";
-import { t as BaseEvlogOptions } from "../middleware-DojmTj9Y.mjs";
+import { _ as RequestLogger } from "../types-D5OwxZCw.mjs";
+import { t as BaseEvlogOptions } from "../middleware-D_igVy93.mjs";
 import { MiddlewareHandler } from "hono";
 
 //#region src/hono/index.d.ts

package/dist/hono/index.mjs

@@ -1,4 +1,4 @@
-import { r as createMiddlewareLogger, t as extractSafeHeaders } from "../headers-BSi3UHKL.mjs";
+import { r as createMiddlewareLogger, t as extractSafeHeaders } from "../headers-ht4yS2mx.mjs";
 //#region src/hono/index.ts
 /**
 * Create an evlog middleware for Hono.

package/dist/http.d.mts

@@ -0,0 +1,65 @@
+import { r as DrainContext } from "./types-D5OwxZCw.mjs";
+import { DrainPipelineOptions, PipelineDrainFn } from "./pipeline.mjs";
+
+//#region src/http.d.ts
+interface HttpDrainConfig {
+  /** URL of the server ingest endpoint */
+  endpoint: string;
+  /** Custom headers sent with each fetch request (e.g. Authorization, X-API-Key). Not applied to sendBeacon — see `useBeacon`. */
+  headers?: Record<string, string>;
+  /** Request timeout in milliseconds. @default 5000 */
+  timeout?: number;
+  /** Use sendBeacon when the page is hidden. @default true */
+  useBeacon?: boolean;
+  /** Fetch credentials mode. @default 'same-origin' */
+  credentials?: RequestCredentials;
+}
+interface HttpLogDrainOptions {
+  /** HTTP drain configuration (endpoint is required) */
+  drain: HttpDrainConfig;
+  /** Pipeline configuration overrides */
+  pipeline?: DrainPipelineOptions<DrainContext>;
+  /** Auto-register visibilitychange flush listener. @default true */
+  autoFlush?: boolean;
+}
+/**
+ * Create a low-level HTTP drain transport function (fetch / sendBeacon).
+ *
+ * Returns a function compatible with `createDrainPipeline` that sends batches
+ * to the configured endpoint via `fetch` (with `keepalive: true`) or
+ * `navigator.sendBeacon` when the page is hidden.
+ *
+ * @example
+ * ```ts
+ * import { createHttpDrain } from 'evlog/http'
+ * import { createDrainPipeline } from 'evlog/pipeline'
+ *
+ * const pipeline = createDrainPipeline({ batch: { size: 50 } })
+ * const drain = pipeline(createHttpDrain({ endpoint: '/api/logs' }))
+ * ```
+ */
+declare function createHttpDrain(config: HttpDrainConfig): (batch: DrainContext[]) => Promise<void>;
+/**
+ * Create a pre-composed HTTP log drain with pipeline, batching, and auto-flush.
+ *
+ * Returns a `PipelineDrainFn<DrainContext>` directly usable with `initLogger({ drain })`.
+ *
+ * @example
+ * ```ts
+ * import { initLogger, log } from 'evlog'
+ * import { createHttpLogDrain } from 'evlog/http'
+ *
+ * const drain = createHttpLogDrain({
+ *   drain: { endpoint: '/api/logs' },
+ * })
+ * initLogger({ drain })
+ *
+ * log.info({ action: 'page_view', path: location.pathname })
+ * ```
+ */
+declare function createHttpLogDrain(options: HttpLogDrainOptions): PipelineDrainFn<DrainContext> & {
+  dispose: () => void;
+};
+//#endregion
+export { HttpDrainConfig, HttpLogDrainOptions, createHttpDrain, createHttpLogDrain };
+//# sourceMappingURL=http.d.mts.map

package/dist/http.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.mts","names":[],"sources":["../src/http.ts"],"mappings":";;;;UAIiB,eAAA;;EAEf,QAAA;EAF8B;EAI9B,OAAA,GAAU,MAAA;EAMsB;EAJhC,OAAA;EAFA;EAIA,SAAA;EAFA;EAIA,WAAA,GAAc,kBAAA;AAAA;AAAA,UAGC,mBAAA;EAHiB;EAKhC,KAAA,EAAO,eAAA;EAFQ;EAIf,QAAA,GAAW,oBAAA,CAAqB,YAAA;;EAEhC,SAAA;AAAA;;;;;;;;;;;;AAmBF;;;;;iBAAgB,eAAA,CAAgB,MAAA,EAAQ,eAAA,IAAmB,KAAA,EAAO,YAAA,OAAmB,OAAA;;;;;;;;;;AA8DrF;;;;;;;;;iBAAgB,kBAAA,CAAmB,OAAA,EAAS,mBAAA,GAAsB,eAAA,CAAgB,YAAA;EAAkB,OAAA;AAAA"}

package/dist/http.mjs

@@ -0,0 +1,94 @@
+import { createDrainPipeline } from "./pipeline.mjs";
+//#region src/http.ts
+/**
+* Create a low-level HTTP drain transport function (fetch / sendBeacon).
+*
+* Returns a function compatible with `createDrainPipeline` that sends batches
+* to the configured endpoint via `fetch` (with `keepalive: true`) or
+* `navigator.sendBeacon` when the page is hidden.
+*
+* @example
+* ```ts
+* import { createHttpDrain } from 'evlog/http'
+* import { createDrainPipeline } from 'evlog/pipeline'
+*
+* const pipeline = createDrainPipeline({ batch: { size: 50 } })
+* const drain = pipeline(createHttpDrain({ endpoint: '/api/logs' }))
+* ```
+*/
+function createHttpDrain(config) {
+	const { endpoint, headers: customHeaders, timeout = 5e3, useBeacon = true, credentials = "same-origin" } = config;
+	return async (batch) => {
+		if (batch.length === 0) return;
+		const body = JSON.stringify(batch);
+		if (useBeacon && typeof document !== "undefined" && document.visibilityState === "hidden" && typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+			if (!navigator.sendBeacon(endpoint, new Blob([body], { type: "application/json" }))) throw new Error("[evlog/http] sendBeacon failed — payload may exceed browser limit");
+			return;
+		}
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeout);
+		try {
+			const response = await fetch(endpoint, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...customHeaders
+				},
+				body,
+				signal: controller.signal,
+				keepalive: true,
+				credentials
+			});
+			if (!response.ok) throw new Error(`[evlog/http] Server responded with ${response.status}`);
+		} finally {
+			clearTimeout(timeoutId);
+		}
+	};
+}
+/**
+* Create a pre-composed HTTP log drain with pipeline, batching, and auto-flush.
+*
+* Returns a `PipelineDrainFn<DrainContext>` directly usable with `initLogger({ drain })`.
+*
+* @example
+* ```ts
+* import { initLogger, log } from 'evlog'
+* import { createHttpLogDrain } from 'evlog/http'
+*
+* const drain = createHttpLogDrain({
+*   drain: { endpoint: '/api/logs' },
+* })
+* initLogger({ drain })
+*
+* log.info({ action: 'page_view', path: location.pathname })
+* ```
+*/
+function createHttpLogDrain(options) {
+	const { autoFlush = true } = options;
+	const drain = createDrainPipeline({
+		batch: {
+			size: 25,
+			intervalMs: 2e3
+		},
+		retry: { maxAttempts: 2 },
+		...options.pipeline
+	})(createHttpDrain(options.drain));
+	let onVisibilityChange;
+	if (autoFlush && typeof document !== "undefined") {
+		onVisibilityChange = () => {
+			if (document.visibilityState === "hidden") drain.flush();
+		};
+		document.addEventListener("visibilitychange", onVisibilityChange);
+	}
+	drain.dispose = () => {
+		if (onVisibilityChange) {
+			document.removeEventListener("visibilitychange", onVisibilityChange);
+			onVisibilityChange = void 0;
+		}
+	};
+	return drain;
+}
+//#endregion
+export { createHttpDrain, createHttpLogDrain };
+
+//# sourceMappingURL=http.mjs.map

package/dist/http.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.mjs","names":[],"sources":["../src/http.ts"],"sourcesContent":["import type { DrainContext } from './types'\nimport type { DrainPipelineOptions, PipelineDrainFn } from './pipeline'\nimport { createDrainPipeline } from './pipeline'\n\nexport interface HttpDrainConfig {\n  /** URL of the server ingest endpoint */\n  endpoint: string\n  /** Custom headers sent with each fetch request (e.g. Authorization, X-API-Key). Not applied to sendBeacon — see `useBeacon`. */\n  headers?: Record<string, string>\n  /** Request timeout in milliseconds. @default 5000 */\n  timeout?: number\n  /** Use sendBeacon when the page is hidden. @default true */\n  useBeacon?: boolean\n  /** Fetch credentials mode. @default 'same-origin' */\n  credentials?: RequestCredentials\n}\n\nexport interface HttpLogDrainOptions {\n  /** HTTP drain configuration (endpoint is required) */\n  drain: HttpDrainConfig\n  /** Pipeline configuration overrides */\n  pipeline?: DrainPipelineOptions<DrainContext>\n  /** Auto-register visibilitychange flush listener. @default true */\n  autoFlush?: boolean\n}\n\n/**\n * Create a low-level HTTP drain transport function (fetch / sendBeacon).\n *\n * Returns a function compatible with `createDrainPipeline` that sends batches\n * to the configured endpoint via `fetch` (with `keepalive: true`) or\n * `navigator.sendBeacon` when the page is hidden.\n *\n * @example\n * ```ts\n * import { createHttpDrain } from 'evlog/http'\n * import { createDrainPipeline } from 'evlog/pipeline'\n *\n * const pipeline = createDrainPipeline({ batch: { size: 50 } })\n * const drain = pipeline(createHttpDrain({ endpoint: '/api/logs' }))\n * ```\n */\nexport function createHttpDrain(config: HttpDrainConfig): (batch: DrainContext[]) => Promise<void> {\n  const { endpoint, headers: customHeaders, timeout = 5000, useBeacon = true, credentials = 'same-origin' } = config\n\n  return async (batch: DrainContext[]): Promise<void> => {\n    if (batch.length === 0) return\n\n    const body = JSON.stringify(batch)\n\n    if (\n      useBeacon\n      && typeof document !== 'undefined'\n      && document.visibilityState === 'hidden'\n      && typeof navigator !== 'undefined'\n      && typeof navigator.sendBeacon === 'function'\n    ) {\n      const queued = navigator.sendBeacon(endpoint, new Blob([body], { type: 'application/json' }))\n      if (!queued) {\n        throw new Error('[evlog/http] sendBeacon failed — payload may exceed browser limit')\n      }\n      return\n    }\n\n    const controller = new AbortController()\n    const timeoutId = setTimeout(() => controller.abort(), timeout)\n\n    try {\n      const response = await fetch(endpoint, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json', ...customHeaders },\n        body,\n        signal: controller.signal,\n        keepalive: true,\n        credentials,\n      })\n\n      if (!response.ok) {\n        throw new Error(`[evlog/http] Server responded with ${response.status}`)\n      }\n    } finally {\n      clearTimeout(timeoutId)\n    }\n  }\n}\n\n/**\n * Create a pre-composed HTTP log drain with pipeline, batching, and auto-flush.\n *\n * Returns a `PipelineDrainFn<DrainContext>` directly usable with `initLogger({ drain })`.\n *\n * @example\n * ```ts\n * import { initLogger, log } from 'evlog'\n * import { createHttpLogDrain } from 'evlog/http'\n *\n * const drain = createHttpLogDrain({\n *   drain: { endpoint: '/api/logs' },\n * })\n * initLogger({ drain })\n *\n * log.info({ action: 'page_view', path: location.pathname })\n * ```\n */\nexport function createHttpLogDrain(options: HttpLogDrainOptions): PipelineDrainFn<DrainContext> & { dispose: () => void } {\n  const { autoFlush = true } = options\n\n  const pipeline = createDrainPipeline<DrainContext>({\n    batch: { size: 25, intervalMs: 2000 },\n    retry: { maxAttempts: 2 },\n    ...options.pipeline,\n  })\n\n  const drain = pipeline(createHttpDrain(options.drain)) as PipelineDrainFn<DrainContext> & { dispose: () => void }\n\n  let onVisibilityChange: (() => void) | undefined\n\n  if (autoFlush && typeof document !== 'undefined') {\n    onVisibilityChange = () => {\n      if (document.visibilityState === 'hidden') {\n        drain.flush()\n      }\n    }\n    document.addEventListener('visibilitychange', onVisibilityChange)\n  }\n\n  drain.dispose = () => {\n    if (onVisibilityChange) {\n      document.removeEventListener('visibilitychange', onVisibilityChange)\n      onVisibilityChange = undefined\n    }\n  }\n\n  return drain\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA0CA,SAAgB,gBAAgB,QAAmE;CACjG,MAAM,EAAE,UAAU,SAAS,eAAe,UAAU,KAAM,YAAY,MAAM,cAAc,kBAAkB;AAE5G,QAAO,OAAO,UAAyC;AACrD,MAAI,MAAM,WAAW,EAAG;EAExB,MAAM,OAAO,KAAK,UAAU,MAAM;AAElC,MACE,aACG,OAAO,aAAa,eACpB,SAAS,oBAAoB,YAC7B,OAAO,cAAc,eACrB,OAAO,UAAU,eAAe,YACnC;AAEA,OAAI,CADW,UAAU,WAAW,UAAU,IAAI,KAAK,CAAC,KAAK,EAAE,EAAE,MAAM,oBAAoB,CAAC,CAAC,CAE3F,OAAM,IAAI,MAAM,oEAAoE;AAEtF;;EAGF,MAAM,aAAa,IAAI,iBAAiB;EACxC,MAAM,YAAY,iBAAiB,WAAW,OAAO,EAAE,QAAQ;AAE/D,MAAI;GACF,MAAM,WAAW,MAAM,MAAM,UAAU;IACrC,QAAQ;IACR,SAAS;KAAE,gBAAgB;KAAoB,GAAG;KAAe;IACjE;IACA,QAAQ,WAAW;IACnB,WAAW;IACX;IACD,CAAC;AAEF,OAAI,CAAC,SAAS,GACZ,OAAM,IAAI,MAAM,sCAAsC,SAAS,SAAS;YAElE;AACR,gBAAa,UAAU;;;;;;;;;;;;;;;;;;;;;;AAuB7B,SAAgB,mBAAmB,SAAuF;CACxH,MAAM,EAAE,YAAY,SAAS;CAQ7B,MAAM,QANW,oBAAkC;EACjD,OAAO;GAAE,MAAM;GAAI,YAAY;GAAM;EACrC,OAAO,EAAE,aAAa,GAAG;EACzB,GAAG,QAAQ;EACZ,CAAC,CAEqB,gBAAgB,QAAQ,MAAM,CAAC;CAEtD,IAAI;AAEJ,KAAI,aAAa,OAAO,aAAa,aAAa;AAChD,6BAA2B;AACzB,OAAI,SAAS,oBAAoB,SAC/B,OAAM,OAAO;;AAGjB,WAAS,iBAAiB,oBAAoB,mBAAmB;;AAGnE,OAAM,gBAAgB;AACpB,MAAI,oBAAoB;AACtB,YAAS,oBAAoB,oBAAoB,mBAAmB;AACpE,wBAAqB,KAAA;;;AAIzB,QAAO"}

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-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, 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, w as TransportConfig, x as ServerEvent, y as SamplingConfig } from "./types-v_JkG_D7.mjs";
-import { n as createError, t as EvlogError } from "./error-plrBYLQk.mjs";
-import { i as getEnvironment, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-CG1eop2_.mjs";
-import { t as useLogger } from "./useLogger-TjKH37BO.mjs";
-import { t as parseError } from "./parseError-B_qXj8x4.mjs";
-export { type BaseWideEvent, type DeepPartial, type DrainContext, type EnrichContext, type EnvironmentContext, type ErrorOptions, EvlogError, type FieldContext, type H3EventContext, type IngestPayload, type InternalFields, type Log, type LogLevel, type LoggerConfig, type ParsedError, type RequestLogger, type RequestLoggerOptions, type SamplingConfig, type SamplingRates, type ServerEvent, type TailSamplingCondition, type TailSamplingContext, type TransportConfig, type WideEvent, createError, createError as createEvlogError, createLogger, createRequestLogger, getEnvironment, initLogger, isEnabled, _log as log, parseError, shouldKeep, useLogger };
+import { C as TailSamplingCondition, E as WideEvent, S as ServerEvent, T as TransportConfig, _ as RequestLogger, a as EnvironmentContext, b as SamplingConfig, c as H3EventContext, d as Log, f as LogLevel, h as RedactConfig, 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 RequestLoggerOptions, w as TailSamplingContext, x as SamplingRates } from "./types-D5OwxZCw.mjs";
+import { n as createError, t as EvlogError } from "./error-WRz4_F3W.mjs";
+import { i as getEnvironment, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-Bm0k3Hf3.mjs";
+import { p as isLevelEnabled } from "./utils-Bnc95-VC.mjs";
+import { t as useLogger } from "./useLogger-Dcj1Nrsa.mjs";
+import { t as parseError } from "./parseError-DhXS_vzM.mjs";
+export { type BaseWideEvent, type DeepPartial, type DrainContext, type EnrichContext, type EnvironmentContext, type ErrorOptions, EvlogError, type FieldContext, type H3EventContext, type IngestPayload, type InternalFields, type Log, type LogLevel, type LoggerConfig, type ParsedError, type RedactConfig, type RequestLogger, type RequestLoggerOptions, type SamplingConfig, type SamplingRates, type ServerEvent, type TailSamplingCondition, type TailSamplingContext, type TransportConfig, type WideEvent, createError, createError as createEvlogError, createLogger, createRequestLogger, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, parseError, shouldKeep, useLogger };

package/dist/index.mjs

@@ -1,5 +1,6 @@
+import { isLevelEnabled } from "./utils.mjs";
 import { EvlogError, createError } from "./error.mjs";
-import { createLogger, createRequestLogger, getEnvironment, initLogger, isEnabled, log as _log, shouldKeep } from "./logger.mjs";
+import { i as getEnvironment, n as createLogger, o as initLogger, r as createRequestLogger, s as isEnabled, t as _log, u as shouldKeep } from "./logger-DY0X5oQd.mjs";
 import { useLogger } from "./runtime/server/useLogger.mjs";
 import { parseError } from "./runtime/utils/parseError.mjs";
-export { EvlogError, createError, createError as createEvlogError, createLogger, createRequestLogger, getEnvironment, initLogger, isEnabled, _log as log, parseError, shouldKeep, useLogger };
+export { EvlogError, createError, createError as createEvlogError, createLogger, createRequestLogger, getEnvironment, initLogger, isEnabled, isLevelEnabled, _log as log, parseError, shouldKeep, useLogger };

package/dist/{logger-CG1eop2_.d.mts → logger-Bm0k3Hf3.d.mts}

@@ -1,4 +1,4 @@
-import { C as TailSamplingContext, _ as RequestLoggerOptions, a as EnvironmentContext, d as Log, g as RequestLogger, p as LoggerConfig, r as DrainContext } from "./types-v_JkG_D7.mjs";
+import { _ as RequestLogger, a as EnvironmentContext, d as Log, p as LoggerConfig, r as DrainContext, v as RequestLoggerOptions, w as TailSamplingContext } from "./types-D5OwxZCw.mjs";
 
 //#region src/logger.d.ts
 /**
@@ -82,4 +82,4 @@ declare function createRequestLogger<T extends object = Record<string, unknown>>
 declare function getEnvironment(): EnvironmentContext;
 //#endregion
 export { getGlobalDrain as a, isLoggerLocked as c, getEnvironment as i, lockLogger as l, createLogger as n, initLogger as o, createRequestLogger as r, isEnabled as s, _log as t, shouldKeep as u };
-//# sourceMappingURL=logger-CG1eop2_.d.mts.map
+//# sourceMappingURL=logger-Bm0k3Hf3.d.mts.map

package/dist/{logger-CG1eop2_.d.mts.map → logger-Bm0k3Hf3.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"logger-CG1eop2_.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;;;AA2CA;;iBAAgB,UAAA,CAAW,MAAA,GAAQ,YAAA;;;AA0BnC;iBAAgB,SAAA,CAAA;;;;AAShB;;iBAAgB,UAAA,CAAA;;;AAOhB;iBAAgB,cAAA,CAAA;;;;AAShB;;iBAAgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;;iBA8BjD,UAAA,CAAW,GAAA,EAAK,mBAAA;;AAAhC;;;;;AAgBC;;;cAqLK,IAAA,EAAM,GAAA;AAOU;;;AAAA,UAkBZ,2BAAA;EAKG;AAcb;;;EAdE,WAAA;AAAA;;;;;;;;;;;;iBAcc,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,aAAA,CAAc,CAAA;;;;AAsHrL;;;;;;;;;iBAAgB,mBAAA,oBAAuC,MAAA,kBAAA,CAAyB,OAAA,GAAS,oBAAA,EAA2B,eAAA,GAAkB,2BAAA,GAA8B,aAAA,CAAc,CAAA;;;;iBAWlK,cAAA,CAAA,GAAkB,kBAAA"}
+{"version":3,"file":"logger-Bm0k3Hf3.d.mts","names":[],"sources":["../src/logger.ts"],"mappings":";;;;;AA+CA;;iBAAgB,UAAA,CAAW,MAAA,GAAQ,YAAA;;;AA4BnC;iBAAgB,SAAA,CAAA;;;;AAShB;;iBAAgB,UAAA,CAAA;;;AAOhB;iBAAgB,cAAA,CAAA;;;;AAShB;;iBAAgB,cAAA,CAAA,KAAoB,GAAA,EAAK,YAAA,YAAwB,OAAA;;;;;iBA8BjD,UAAA,CAAW,GAAA,EAAK,mBAAA;;AAAhC;;;;;AAgBC;;;cA8VK,IAAA,EAAM,GAAA;AAOU;;;AAAA,UAkBZ,2BAAA;EAKG;AAcb;;;EAdE,WAAA;AAAA;;;;;;;;;;;;iBAcc,YAAA,oBAAgC,MAAA,kBAAA,CAAyB,cAAA,GAAgB,MAAA,mBAA8B,eAAA,GAAkB,2BAAA,GAA8B,aAAA,CAAc,CAAA;;;;AAsHrL;;;;;;;;;iBAAgB,mBAAA,oBAAuC,MAAA,kBAAA,CAAyB,OAAA,GAAS,oBAAA,EAA2B,eAAA,GAAkB,2BAAA,GAA8B,aAAA,CAAc,CAAA;;;;iBAWlK,cAAA,CAAA,GAAkB,kBAAA"}