evlog 2.11.0 → 2.12.0

package/dist/logger-DY0X5oQd.mjs

@@ -0,0 +1,704 @@
+import { colors, cssColors, detectEnvironment, escapeFormatString, formatDuration, getConsoleMethod, getCssLevelColor, getLevelColor, isClient, isDev, isLevelEnabled, matchesPattern } from "./utils.mjs";
+//#region src/redact.ts
+const DEFAULT_REPLACEMENT = "[REDACTED]";
+/**
+* Built-in PII detection patterns with smart masking.
+* Each builtin preserves just enough signal for debugging while scrubbing PII.
+*/
+const builtinPatterns = {
+	creditCard: {
+		pattern: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,
+		mask: (m) => `****${m.replace(/[\s-]/g, "").slice(-4)}`
+	},
+	email: {
+		pattern: /[\w.+-]+@[\w-]+\.[\w.]+/g,
+		mask: (m) => {
+			if (m.indexOf("@") < 1) return "***@***";
+			const tld = m.slice(m.lastIndexOf("."));
+			return `${m[0]}***@***${tld}`;
+		}
+	},
+	ipv4: {
+		pattern: /\b(?!0\.0\.0\.0\b)(?!127\.0\.0\.1\b)\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g,
+		mask: (m) => `***.***.***.${m.split(".").pop()}`
+	},
+	phone: {
+		pattern: /(?:\+\d{1,3}[\s.-]?)?\(?\d{1,4}\)?[\s.-]?\d{2,4}[\s.-]?\d{2,4}[\s.-]?\d{2,4}\b/g,
+		mask: (m) => {
+			const digits = m.replace(/[^\d]/g, "");
+			if (m.startsWith("+") && digits.length > 4) {
+				const ccMatch = m.match(/^\+\d{1,3}/);
+				return `${ccMatch ? ccMatch[0] : "+"}******${digits.slice(-2)}`;
+			}
+			if (digits.length > 2) return `${"*".repeat(digits.length - 2)}${digits.slice(-2)}`;
+			return "***";
+		}
+	},
+	jwt: {
+		pattern: /\beyJ[\w-]*\.[\w-]*\.[\w-]*\b/g,
+		mask: () => "eyJ***.***"
+	},
+	bearer: {
+		pattern: /\bBearer\s+[\w\-.~+/]{8,}=*/gi,
+		mask: () => "Bearer ***"
+	},
+	iban: {
+		pattern: /\b[A-Z]{2}\d{2}[\s-]?[\dA-Z]{4}[\s-]?[\dA-Z]{4}[\s-]?[\dA-Z]{4}[\s-]?[\dA-Z]{0,4}[\s-]?[\dA-Z]{0,4}[\s-]?[\dA-Z]{0,4}\b/g,
+		mask: (m) => {
+			const clean = m.replace(/[\s-]/g, "");
+			return `${clean.slice(0, 4)}****${clean.slice(-3)}`;
+		}
+	}
+};
+/**
+* Resolve a `redact` option (boolean or object) into a concrete `RedactConfig`.
+*
+* - `true` → all built-in patterns with smart masking, no custom paths
+* - `{ ... }` → built-in maskers merged with user config (opt-out: `builtins: false`)
+* - `false` / `undefined` → `undefined` (no redaction)
+*/
+function resolveRedactConfig(input) {
+	if (input === void 0 || input === false) return void 0;
+	if (input === true) return { _maskers: allBuiltinMaskers() };
+	if (input.builtins === false) return input;
+	const maskers = Array.isArray(input.builtins) ? input.builtins.map((name) => builtinPatterns[name]).filter(Boolean).map((b) => [cloneRegex(b.pattern), b.mask]) : allBuiltinMaskers();
+	return {
+		...input,
+		_maskers: maskers
+	};
+}
+function allBuiltinMaskers() {
+	return Object.values(builtinPatterns).map((b) => [cloneRegex(b.pattern), b.mask]);
+}
+function cloneRegex(re) {
+	return new RegExp(re.source, re.flags);
+}
+/**
+* Redact sensitive data from a wide event in-place.
+*
+* Three strategies applied in order:
+* 1. **Path-based**: dot-notation paths — the leaf value is replaced with `replacement`.
+* 2. **Masker-based**: built-in patterns with smart partial masking (e.g. `****1111`).
+* 3. **Pattern-based**: custom RegExp patterns replaced with `replacement`.
+*
+* @param event - The wide event object (mutated in-place).
+* @param config - Redaction configuration.
+*/
+function redactEvent(event, config) {
+	const replacement = config.replacement ?? DEFAULT_REPLACEMENT;
+	if (config.paths?.length) for (const path of config.paths) redactPath(event, path.split("."), replacement);
+	if (config._maskers?.length) applyMaskersToTree(event, config._maskers);
+	if (config.patterns?.length) redactPatterns(event, config.patterns, replacement);
+}
+function redactPath(obj, segments, replacement) {
+	let current = obj;
+	for (let i = 0; i < segments.length - 1; i++) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[segments[i]];
+	}
+	if (current === null || current === void 0 || typeof current !== "object") return;
+	const leaf = segments[segments.length - 1];
+	if (leaf in current) current[leaf] = replacement;
+}
+function redactPatterns(obj, patterns, replacement) {
+	if (obj === null || obj === void 0) return;
+	if (Array.isArray(obj)) {
+		for (let i = 0; i < obj.length; i++) if (typeof obj[i] === "string") obj[i] = applyPatterns(obj[i], patterns, replacement);
+		else if (typeof obj[i] === "object") redactPatterns(obj[i], patterns, replacement);
+		return;
+	}
+	if (typeof obj === "object") {
+		const record = obj;
+		for (const key in record) {
+			const val = record[key];
+			if (typeof val === "string") record[key] = applyPatterns(val, patterns, replacement);
+			else if (typeof val === "object") redactPatterns(val, patterns, replacement);
+		}
+	}
+}
+function applyPatterns(value, patterns, replacement) {
+	let result = value;
+	for (const pattern of patterns) {
+		pattern.lastIndex = 0;
+		result = result.replace(pattern, replacement);
+	}
+	return result;
+}
+function applyMaskersToTree(obj, maskers) {
+	if (obj === null || obj === void 0) return;
+	if (Array.isArray(obj)) {
+		for (let i = 0; i < obj.length; i++) if (typeof obj[i] === "string") obj[i] = applyMaskers(obj[i], maskers);
+		else if (typeof obj[i] === "object") applyMaskersToTree(obj[i], maskers);
+		return;
+	}
+	if (typeof obj === "object") {
+		const record = obj;
+		for (const key in record) {
+			const val = record[key];
+			if (typeof val === "string") record[key] = applyMaskers(val, maskers);
+			else if (typeof val === "object") applyMaskersToTree(val, maskers);
+		}
+	}
+}
+function applyMaskers(value, maskers) {
+	let result = value;
+	for (const [pattern, mask] of maskers) {
+		pattern.lastIndex = 0;
+		result = result.replace(pattern, mask);
+	}
+	return result;
+}
+/**
+* Normalize a redact config that may have been deserialized from JSON
+* (e.g. via `process.env.__EVLOG_CONFIG`). Converts pattern strings
+* back to RegExp instances, then resolves built-in patterns.
+*/
+function normalizeRedactConfig(raw) {
+	if (raw === void 0 || raw === false) return void 0;
+	if (raw === true) return resolveRedactConfig(true);
+	const config = {};
+	if (Array.isArray(raw.paths)) config.paths = raw.paths;
+	if (typeof raw.replacement === "string") config.replacement = raw.replacement;
+	if (raw.builtins === false) config.builtins = false;
+	else if (Array.isArray(raw.builtins)) config.builtins = raw.builtins;
+	if (Array.isArray(raw.patterns)) config.patterns = raw.patterns.map((p) => {
+		if (p instanceof RegExp) return p;
+		if (typeof p === "string") return new RegExp(p, "g");
+		if (typeof p === "object" && p !== null) {
+			const obj = p;
+			return new RegExp(obj.source, obj.flags ?? "g");
+		}
+		return null;
+	}).filter((p) => p !== null);
+	return resolveRedactConfig(config);
+}
+//#endregion
+//#region src/logger.ts
+function isPlainObject(val) {
+	return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+const _tsDate = /* @__PURE__ */ new Date();
+function isoNow() {
+	_tsDate.setTime(Date.now());
+	return _tsDate.toISOString();
+}
+function mergeInto(target, source) {
+	for (const key in source) {
+		const sourceVal = source[key];
+		if (sourceVal === void 0 || sourceVal === null) continue;
+		const targetVal = target[key];
+		if (isPlainObject(sourceVal) && isPlainObject(targetVal)) mergeInto(targetVal, sourceVal);
+		else target[key] = sourceVal;
+	}
+}
+let globalEnv = {
+	service: "app",
+	environment: "development"
+};
+let globalPretty = isDev();
+let globalSampling = {};
+let globalStringify = true;
+let globalDrain;
+let globalRedact;
+let globalEnabled = true;
+let globalSilent = false;
+/** Minimum level for the global `log` API only (`ownsEvent === false`). Default: all levels. */
+let globalMinLevel = "debug";
+let _locked = false;
+/**
+* Initialize the logger with configuration.
+* Call this once at application startup.
+*/
+function initLogger(config = {}) {
+	globalEnabled = config.enabled ?? true;
+	const detected = detectEnvironment();
+	globalEnv = {
+		service: config.env?.service ?? detected.service ?? "app",
+		environment: config.env?.environment ?? detected.environment ?? "development",
+		version: config.env?.version ?? detected.version,
+		commitHash: config.env?.commitHash ?? detected.commitHash,
+		region: config.env?.region ?? detected.region
+	};
+	globalPretty = config.pretty ?? isDev();
+	globalSampling = config.sampling ?? {};
+	globalStringify = config.stringify ?? true;
+	globalDrain = config.drain;
+	globalRedact = resolveRedactConfig(config.redact ?? !isDev());
+	globalSilent = config.silent ?? false;
+	globalMinLevel = config.minLevel ?? "debug";
+	if (globalSilent && !globalDrain && !config._suppressDrainWarning) console.warn("[evlog] silent mode is enabled but no drain is configured. Events will be built and sampled but not output anywhere. Set a drain via initLogger({ drain }) or a framework hook (evlog:drain).");
+}
+/**
+* Check if logging is globally enabled.
+*/
+function isEnabled() {
+	return globalEnabled;
+}
+/**
+* @internal Lock the logger to prevent re-initialization.
+* Called by instrumentation register() after setting up the logger with drain.
+* Prevents configureHandler() from overwriting the drain config.
+*/
+function lockLogger() {
+	_locked = true;
+}
+/**
+* @internal Check if the logger has been locked by instrumentation.
+*/
+function isLoggerLocked() {
+	return _locked;
+}
+/**
+* @internal Get the globally configured drain callback.
+* Used by framework middleware to fall back to the global drain
+* when no middleware-level drain is provided.
+*/
+function getGlobalDrain() {
+	return globalDrain;
+}
+/**
+* Determine if a log at the given level should be emitted based on sampling config.
+* Error level defaults to 100% (always logged) unless explicitly configured otherwise.
+*/
+function shouldSample(level) {
+	const { rates } = globalSampling;
+	if (!rates) return true;
+	const percentage = level === "error" && rates.error === void 0 ? 100 : rates[level] ?? 100;
+	if (percentage <= 0) return false;
+	if (percentage >= 100) return true;
+	return Math.random() * 100 < percentage;
+}
+/**
+* Evaluate tail sampling conditions to determine if a log should be force-kept.
+* Returns true if ANY condition matches (OR logic).
+*/
+function shouldKeep(ctx) {
+	const { keep } = globalSampling;
+	if (!keep?.length) return false;
+	return keep.some((condition) => {
+		if (condition.status !== void 0 && ctx.status !== void 0 && ctx.status >= condition.status) return true;
+		if (condition.duration !== void 0 && ctx.duration !== void 0 && ctx.duration >= condition.duration) return true;
+		if (condition.path && ctx.path && matchesPattern(ctx.path, condition.path)) return true;
+		return false;
+	});
+}
+function emitWideEvent(level, event, deferDrain = false, ownsEvent = false) {
+	if (!globalEnabled) return null;
+	if (!ownsEvent) {
+		if (!isLevelEnabled(level, globalMinLevel)) return null;
+		if (!shouldSample(level)) return null;
+	}
+	let formatted;
+	if (ownsEvent) {
+		event.timestamp = isoNow();
+		event.level = level;
+		if (event.service === void 0) event.service = globalEnv.service;
+		if (event.environment === void 0) event.environment = globalEnv.environment;
+		if (globalEnv.version !== void 0 && event.version === void 0) event.version = globalEnv.version;
+		if (globalEnv.commitHash !== void 0 && event.commitHash === void 0) event.commitHash = globalEnv.commitHash;
+		if (globalEnv.region !== void 0 && event.region === void 0) event.region = globalEnv.region;
+		formatted = event;
+	} else formatted = {
+		timestamp: isoNow(),
+		level,
+		...globalEnv,
+		...event
+	};
+	if (globalRedact) redactEvent(formatted, globalRedact);
+	if (!globalSilent) if (globalPretty) prettyPrintWideEvent(formatted);
+	else if (globalStringify) console[getConsoleMethod(level)](JSON.stringify(formatted));
+	else console[getConsoleMethod(level)](formatted);
+	if (globalDrain && !deferDrain) Promise.resolve(globalDrain({ event: formatted })).catch((err) => {
+		console.error("[evlog] drain failed:", err);
+	});
+	return formatted;
+}
+function emitTaggedLog(level, tag, message) {
+	if (!globalEnabled) return;
+	if (globalPretty && !globalSilent) {
+		if (!isLevelEnabled(level, globalMinLevel)) return;
+		if (!shouldSample(level)) return;
+		if (isClient()) {
+			const levelColor = getCssLevelColor(level);
+			const timestamp = isoNow().slice(11, 23);
+			console.log(`%c${timestamp}%c %c[${escapeFormatString(tag)}]%c ${escapeFormatString(message)}`, cssColors.dim, cssColors.reset, levelColor, cssColors.reset);
+		} else {
+			const color = getLevelColor(level);
+			const timestamp = isoNow().slice(11, 23);
+			console.log(`${colors.dim}${timestamp}${colors.reset} ${color}[${tag}]${colors.reset} ${message}`);
+		}
+		return;
+	}
+	emitWideEvent(level, {
+		tag,
+		message
+	});
+}
+function formatValue(value) {
+	if (value === null || value === void 0) return String(value);
+	if (typeof value === "object") {
+		const pairs = [];
+		for (const [k, v] of Object.entries(value)) if (v !== void 0 && v !== null) if (typeof v === "object") pairs.push(`${k}=${JSON.stringify(v)}`);
+		else pairs.push(`${k}=${v}`);
+		return pairs.join(" ");
+	}
+	return String(value);
+}
+function formatCost(cost) {
+	if (cost < .01) return `$${cost.toFixed(6)}`;
+	if (cost < 1) return `$${cost.toFixed(4)}`;
+	return `$${cost.toFixed(2)}`;
+}
+function buildAIEntries(ai) {
+	const entries = [];
+	const headerParts = [];
+	if (ai.model) {
+		let m = String(ai.model);
+		if (ai.provider) m += ` (${ai.provider})`;
+		headerParts.push(m);
+	}
+	if (ai.calls) headerParts.push(`${ai.calls} call${ai.calls > 1 ? "s" : ""}`);
+	if (ai.steps && ai.steps > 1) headerParts.push(`${ai.steps} steps`);
+	entries.push({
+		key: "ai",
+		value: headerParts.join(" · ")
+	});
+	const inputTokens = ai.inputTokens;
+	const outputTokens = ai.outputTokens;
+	const totalTokens = ai.totalTokens;
+	if (inputTokens !== void 0 && outputTokens !== void 0) {
+		let tokLine = `${inputTokens} in → ${outputTokens} out`;
+		if (totalTokens) tokLine += ` (${totalTokens} total)`;
+		const extras = [];
+		if (ai.cacheReadTokens) extras.push(`${ai.cacheReadTokens} cache read`);
+		if (ai.cacheWriteTokens) extras.push(`${ai.cacheWriteTokens} cache write`);
+		if (ai.reasoningTokens) extras.push(`${ai.reasoningTokens} reasoning`);
+		if (extras.length) tokLine += ` · ${extras.join(" · ")}`;
+		entries.push({
+			key: "ai.tokens",
+			value: tokLine
+		});
+	}
+	const msFirst = ai.msToFirstChunk;
+	const msFinish = ai.msToFinish;
+	const tps = ai.tokensPerSecond;
+	if (msFirst !== void 0 || msFinish !== void 0) {
+		const parts = [];
+		if (msFirst !== void 0) parts.push(`${formatDuration(msFirst)} to first chunk`);
+		if (msFinish !== void 0) parts.push(`${formatDuration(msFinish)} total`);
+		let streamLine = parts.join(" → ");
+		if (tps) streamLine += ` · ${tps} tok/s`;
+		entries.push({
+			key: "ai.streaming",
+			value: streamLine
+		});
+	}
+	if (ai.estimatedCost !== void 0) entries.push({
+		key: "ai.cost",
+		value: formatCost(ai.estimatedCost)
+	});
+	if (ai.totalDurationMs !== void 0) entries.push({
+		key: "ai.totalDuration",
+		value: formatDuration(ai.totalDurationMs)
+	});
+	const toolCalls = ai.toolCalls;
+	const tools = ai.tools;
+	const hasInputs = toolCalls?.length ? typeof toolCalls[0] === "object" : false;
+	if (tools?.length) {
+		const children = tools.map((t, idx) => {
+			const mark = t.success ? "✓" : "✗";
+			let line = `${t.name} ${formatDuration(t.durationMs)} ${mark}`;
+			if (t.error) line += ` ${t.error}`;
+			if (hasInputs && toolCalls && idx < toolCalls.length) {
+				const tc = toolCalls[idx];
+				const inputStr = typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input);
+				const truncated = inputStr.length > 100 ? `${inputStr.slice(0, 100)}…` : inputStr;
+				line += ` ${truncated}`;
+			}
+			return line;
+		});
+		entries.push({
+			key: "ai.tools",
+			value: "",
+			children
+		});
+	} else if (toolCalls?.length) if (hasInputs) {
+		const children = toolCalls.map((tc) => {
+			const inputStr = typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input);
+			const truncated = inputStr.length > 100 ? `${inputStr.slice(0, 100)}…` : inputStr;
+			return `${tc.name}(${truncated})`;
+		});
+		entries.push({
+			key: "ai.tools",
+			value: "",
+			children
+		});
+	} else entries.push({
+		key: "ai.tools",
+		value: toolCalls.join(", ")
+	});
+	const stepsUsage = ai.stepsUsage;
+	if (stepsUsage?.length) {
+		const allSameModel = stepsUsage.every((s) => s.model === stepsUsage[0].model);
+		const children = stepsUsage.map((s) => {
+			let line = `${allSameModel ? "" : `${s.model} `}${s.inputTokens} in → ${s.outputTokens} out`;
+			const stepTools = s.toolCalls;
+			if (stepTools?.length) line += ` [${stepTools.join(", ")}]`;
+			return line;
+		});
+		entries.push({
+			key: "ai.steps",
+			value: "",
+			children
+		});
+	} else if (ai.steps && ai.steps > 1) entries.push({
+		key: "ai.steps",
+		value: String(ai.steps)
+	});
+	const embedding = ai.embedding;
+	if (embedding) {
+		const parts = [];
+		if (embedding.model) parts.push(String(embedding.model));
+		parts.push(`${embedding.tokens} tokens`);
+		if (embedding.dimensions) parts.push(`${embedding.dimensions}d`);
+		if (embedding.count) parts.push(`${embedding.count} items`);
+		entries.push({
+			key: "ai.embedding",
+			value: parts.join(" · ")
+		});
+	}
+	if (ai.finishReason) entries.push({
+		key: "ai.finishReason",
+		value: String(ai.finishReason)
+	});
+	if (ai.error) entries.push({
+		key: "ai.error",
+		value: String(ai.error)
+	});
+	if (ai.responseId) entries.push({
+		key: "ai.responseId",
+		value: String(ai.responseId)
+	});
+	return entries;
+}
+function prettyPrintWideEvent(event) {
+	const { timestamp, level, service, environment, version, ...rest } = event;
+	const ts = timestamp.slice(11, 23);
+	const browser = isClient();
+	const parts = [];
+	const styles = [];
+	if (browser) {
+		const lc = getCssLevelColor(level);
+		parts.push(`%c${ts}%c %c${level.toUpperCase()}%c %c[${escapeFormatString(String(service))}]%c`);
+		styles.push(cssColors.dim, cssColors.reset, lc, cssColors.reset, cssColors.cyan, cssColors.reset);
+	} else {
+		const lc = getLevelColor(level);
+		parts.push(`${colors.dim}${ts}${colors.reset} ${lc}${level.toUpperCase()}${colors.reset} ${colors.cyan}[${service}]${colors.reset}`);
+	}
+	if (rest.method && rest.path) {
+		parts.push(browser ? ` ${escapeFormatString(String(rest.method))} ${escapeFormatString(String(rest.path))}` : ` ${rest.method} ${rest.path}`);
+		delete rest.method;
+		delete rest.path;
+	}
+	if (rest.status) {
+		const sc = browser ? rest.status >= 400 ? cssColors.red : cssColors.green : rest.status >= 400 ? colors.red : colors.green;
+		if (browser) {
+			parts.push(` %c${rest.status}%c`);
+			styles.push(sc, cssColors.reset);
+		} else parts.push(` ${sc}${rest.status}${colors.reset}`);
+		delete rest.status;
+	}
+	if (rest.duration) {
+		if (browser) {
+			parts.push(` %c${escapeFormatString(`in ${rest.duration}`)}%c`);
+			styles.push(cssColors.dim, cssColors.reset);
+		} else parts.push(` ${colors.dim}in ${rest.duration}${colors.reset}`);
+		delete rest.duration;
+	}
+	console.log(parts.join(""), ...styles);
+	const aiData = rest.ai;
+	if (aiData && typeof aiData === "object") delete rest.ai;
+	const restEntries = Object.entries(rest).filter(([_, v]) => v !== void 0);
+	const aiEntries = aiData ? buildAIEntries(aiData) : [];
+	const allEntries = [...restEntries.map(([key, value]) => ({
+		key,
+		value: formatValue(value)
+	})), ...aiEntries];
+	for (let i = 0; i < allEntries.length; i++) {
+		const entry = allEntries[i];
+		const hasChildren = entry.children && entry.children.length > 0;
+		const prefix = i === allEntries.length - 1 && !hasChildren ? "└─" : "├─";
+		if (browser) {
+			const val = entry.value ? ` ${escapeFormatString(entry.value)}` : "";
+			console.log(`  %c${prefix}%c %c${escapeFormatString(entry.key)}:%c${val}`, cssColors.dim, cssColors.reset, cssColors.cyan, cssColors.reset);
+		} else {
+			const val = entry.value ? ` ${entry.value}` : "";
+			console.log(`  ${colors.dim}${prefix}${colors.reset} ${colors.cyan}${entry.key}:${colors.reset}${val}`);
+		}
+		if (hasChildren) {
+			const connector = i === allEntries.length - 1 ? " " : "│";
+			for (let j = 0; j < entry.children.length; j++) {
+				const child = entry.children[j];
+				const childPrefix = j === entry.children.length - 1 ? "└─" : "├─";
+				if (browser) console.log(`  %c${connector}  ${childPrefix}%c ${escapeFormatString(child)}`, cssColors.dim, cssColors.reset);
+				else console.log(`  ${colors.dim}${connector}  ${childPrefix}${colors.reset} ${child}`);
+			}
+		}
+	}
+}
+function createLogMethod(level) {
+	return function logMethod(tagOrEvent, message) {
+		if (typeof tagOrEvent === "string" && message !== void 0) emitTaggedLog(level, tagOrEvent, message);
+		else if (typeof tagOrEvent === "object") emitWideEvent(level, tagOrEvent);
+		else emitTaggedLog(level, "log", String(tagOrEvent));
+	};
+}
+/**
+* Simple logging API - as easy as console.log
+*
+* @example
+* ```ts
+* log.info('auth', 'User logged in')
+* log.error({ action: 'payment', error: 'failed' })
+* ```
+*/
+const _log = {
+	info: createLogMethod("info"),
+	error: createLogMethod("error"),
+	warn: createLogMethod("warn"),
+	debug: createLogMethod("debug")
+};
+const noopLogger = {
+	set() {},
+	error() {},
+	info() {},
+	warn() {},
+	emit() {
+		return null;
+	},
+	getContext() {
+		return {};
+	}
+};
+/**
+* Create a scoped logger for building wide events.
+* Use this for any context: workflows, jobs, scripts, queues, etc.
+*
+* @example
+* ```ts
+* const log = createLogger({ jobId: job.id, queue: 'emails' })
+* log.set({ batch: { size: 50, processed: 12 } })
+* log.emit()
+* ```
+*/
+function createLogger(initialContext = {}, internalOptions) {
+	if (!globalEnabled) return noopLogger;
+	const deferDrain = internalOptions?._deferDrain ?? false;
+	const startTime = Date.now();
+	const context = { ...initialContext };
+	let hasError = false;
+	let hasWarn = false;
+	function addLog(level, message) {
+		if (!Array.isArray(context.requestLogs)) context.requestLogs = [];
+		context.requestLogs.push({
+			level,
+			message,
+			timestamp: isoNow()
+		});
+	}
+	return {
+		set(data) {
+			mergeInto(context, data);
+		},
+		error(error, errorContext) {
+			hasError = true;
+			const err = typeof error === "string" ? new Error(error) : error;
+			if (errorContext) mergeInto(context, errorContext);
+			const errorObj = {
+				name: err.name,
+				message: err.message,
+				stack: err.stack
+			};
+			const errRecord = err;
+			for (const k of [
+				"status",
+				"statusText",
+				"statusCode",
+				"statusMessage",
+				"data",
+				"cause",
+				"internal"
+			]) if (k in err) errorObj[k] = errRecord[k];
+			if (isPlainObject(context.error)) mergeInto(context.error, errorObj);
+			else context.error = errorObj;
+		},
+		info(message, infoContext) {
+			addLog("info", message);
+			if (infoContext) {
+				const { requestLogs: _, ...rest } = infoContext;
+				mergeInto(context, rest);
+			}
+		},
+		warn(message, warnContext) {
+			hasWarn = true;
+			addLog("warn", message);
+			if (warnContext) {
+				const { requestLogs: _, ...rest } = warnContext;
+				mergeInto(context, rest);
+			}
+		},
+		emit(overrides) {
+			const durationMs = Date.now() - startTime;
+			const level = hasError ? "error" : hasWarn ? "warn" : "info";
+			let forceKeep = false;
+			if (overrides?._forceKeep) forceKeep = true;
+			else if (globalSampling.keep?.length) forceKeep = shouldKeep({
+				status: overrides?.status ?? context.status,
+				duration: durationMs,
+				path: context.path,
+				method: context.method,
+				context
+			});
+			if (!forceKeep && !shouldSample(level)) return null;
+			if (overrides) {
+				const obj = overrides;
+				for (const key in obj) if (key !== "_forceKeep") context[key] = obj[key];
+			}
+			context.duration = formatDuration(durationMs);
+			return emitWideEvent(level, context, deferDrain, true);
+		},
+		getContext() {
+			return { ...context };
+		}
+	};
+}
+/**
+* Create a request-scoped logger for building wide events.
+* Convenience wrapper around `createLogger` that pre-populates HTTP request fields.
+*
+* @example
+* ```ts
+* const log = createRequestLogger({ method: 'POST', path: '/checkout' })
+* log.set({ user: { id: '123' } })
+* log.set({ cart: { items: 3 } })
+* log.emit()
+* ```
+*/
+function createRequestLogger(options = {}, internalOptions) {
+	const initial = {};
+	if (options.method !== void 0) initial.method = options.method;
+	if (options.path !== void 0) initial.path = options.path;
+	if (options.requestId !== void 0) initial.requestId = options.requestId;
+	return createLogger(initial, internalOptions);
+}
+/**
+* Get the current environment context.
+*/
+function getEnvironment() {
+	return { ...globalEnv };
+}
+if (typeof __EVLOG_CONFIG__ !== "undefined") initLogger(__EVLOG_CONFIG__);
+//#endregion
+export { getGlobalDrain as a, isLoggerLocked as c, normalizeRedactConfig as d, redactEvent as f, getEnvironment as i, lockLogger as l, createLogger as n, initLogger as o, resolveRedactConfig as p, createRequestLogger as r, isEnabled as s, _log as t, shouldKeep as u };
+
+//# sourceMappingURL=logger-DY0X5oQd.mjs.map