loggily 0.6.2 → 0.7.0

package/dist/index.mjs

@@ -1,734 +1,2 @@
-import { closeSync, openSync, writeSync } from "node:fs";
-//#region src/colors.ts
-/**
-* Vendored ANSI color functions — replaces picocolors dependency.
-* Supports NO_COLOR, FORCE_COLOR, and TTY detection.
-*/
-const _process$1 = typeof process !== "undefined" ? process : void 0;
-const enabled = _process$1?.env?.["FORCE_COLOR"] !== void 0 && _process$1?.env?.["FORCE_COLOR"] !== "0" ? true : _process$1?.env?.["NO_COLOR"] !== void 0 ? false : _process$1?.stdout?.isTTY ?? false;
-function wrap(open, close) {
-	if (!enabled) return (str) => str;
-	return (str) => open + str + close;
-}
-const colors = {
-	dim: wrap("\x1B[2m", "\x1B[22m"),
-	blue: wrap("\x1B[34m", "\x1B[39m"),
-	yellow: wrap("\x1B[33m", "\x1B[39m"),
-	red: wrap("\x1B[31m", "\x1B[39m"),
-	magenta: wrap("\x1B[35m", "\x1B[39m"),
-	cyan: wrap("\x1B[36m", "\x1B[39m")
-};
-//#endregion
-//#region src/tracing.ts
-let currentIdFormat = "simple";
-/**
-* Set the ID format for new spans and traces.
-* - "simple": sp_1, sp_2, tr_1, tr_2 (default, lightweight)
-* - "w3c": 32-char hex trace ID, 16-char hex span ID (W3C Trace Context compatible)
-*/
-function setIdFormat(format) {
-	currentIdFormat = format;
-}
-/** Get the current ID format */
-function getIdFormat() {
-	return currentIdFormat;
-}
-let simpleSpanCounter = 0;
-let simpleTraceCounter = 0;
-/** Generate a hex string of the given byte length using crypto.randomUUID */
-function randomHex(bytes) {
-	return crypto.randomUUID().replace(/-/g, "").slice(0, bytes * 2);
-}
-/** Generate a span ID according to the current format */
-function generateSpanId() {
-	if (currentIdFormat === "w3c") return randomHex(8);
-	return `sp_${(++simpleSpanCounter).toString(36)}`;
-}
-/** Generate a trace ID according to the current format */
-function generateTraceId() {
-	if (currentIdFormat === "w3c") return randomHex(16);
-	return `tr_${(++simpleTraceCounter).toString(36)}`;
-}
-/** Reset ID counters (for testing) */
-function resetIdCounters() {
-	simpleSpanCounter = 0;
-	simpleTraceCounter = 0;
-}
-/**
-* Format a W3C traceparent header from span data.
-*
-* Format: `{version}-{trace-id}-{span-id}-{trace-flags}`
-* - version: "00" (current W3C spec version)
-* - trace-id: 32 hex chars (128 bits)
-* - span-id: 16 hex chars (64 bits)
-* - trace-flags: "01" (sampled) or "00" (not sampled)
-*
-* Works with both simple and W3C ID formats. Simple IDs are zero-padded to spec length.
-*
-* @param spanData - Span data with id and traceId
-* @param options - Optional settings (sampled flag). Defaults to sampled=true.
-* @returns W3C traceparent header string
-*
-* @example
-* ```typescript
-* const span = log.span("http-request")
-* const header = traceparent(span.spanData)
-* // → "00-a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6-1a2b3c4d5e6f7a8b-01"
-* fetch(url, { headers: { traceparent: header } })
-* ```
-*/
-function traceparent(spanData, options) {
-	return `00-${padHex(spanData.traceId, 32)}-${padHex(spanData.id, 16)}-${options?.sampled ?? true ? "01" : "00"}`;
-}
-/** Pad or hash an ID to the specified hex length */
-function padHex(id, length) {
-	if (id.length === length && /^[0-9a-f]+$/.test(id)) return id;
-	let hex = "";
-	for (let i = 0; i < id.length; i++) hex += id.charCodeAt(i).toString(16).padStart(2, "0");
-	return hex.padStart(length, "0").slice(-length);
-}
-let sampleRate = 1;
-/**
-* Set the head-based sampling rate for new traces.
-* Applied at trace creation — all spans within a sampled trace are kept.
-*
-* @param rate - Sampling rate from 0.0 (sample nothing) to 1.0 (sample everything, default)
-*/
-function setSampleRate(rate) {
-	if (rate < 0 || rate > 1) throw new Error(`Sample rate must be between 0.0 and 1.0, got ${rate}`);
-	sampleRate = rate;
-}
-/** Get the current sampling rate */
-function getSampleRate() {
-	return sampleRate;
-}
-/**
-* Determine whether a new trace should be sampled.
-* Called at trace creation time (head-based sampling).
-*/
-function shouldSample() {
-	if (sampleRate >= 1) return true;
-	if (sampleRate <= 0) return false;
-	return Math.random() < sampleRate;
-}
-//#endregion
-//#region src/core.ts
-/**
-* loggily - Structured logging with spans
-*
-* Logger-first architecture: Span = Logger + Duration
-*
-* @example
-* const log = createLogger('myapp')
-*
-* // Simple logging
-* log.info('starting')
-*
-* // Lazy messages (function not called when level is disabled)
-* log.debug?.(() => `expensive: ${computeState()}`)
-*
-* // Child loggers with context fields
-* const reqLog = log.child({ requestId: 'abc' })
-* reqLog.info('handling request')  // includes requestId in every message
-*
-* // With timing (span)
-* {
-*   using task = log.span('import', { file: 'data.csv' })
-*   task.info('importing')
-*   task.spanData.count = 42  // Set span attributes
-*   // Auto-disposal on block exit → SPAN myapp:import (15ms)
-* }
-*/
-/**
-* Ambient span recorder — auto-records when TRACE is active.
-* Set by metrics.ts on import; can be replaced for testing.
-* @internal
-*/
-let _ambientRecorder = null;
-function _setAmbientRecorder(recorder) {
-	_ambientRecorder = recorder;
-}
-/** Cached process reference — undefined in browser/edge runtimes */
-const _process = typeof process !== "undefined" ? process : void 0;
-/** Read an environment variable, returning undefined in non-Node runtimes */
-function getEnv(key) {
-	return _process?.env?.[key];
-}
-/** Write to stderr with console.error fallback for non-Node runtimes */
-function writeStderr(text) {
-	if (_process?.stderr?.write) _process.stderr.write(text + "\n");
-	else console.error(text);
-}
-const writers = [];
-/** Add a writer that receives all formatted log output. Returns unsubscribe. */
-function addWriter(writer) {
-	writers.push(writer);
-	return () => {
-		const idx = writers.indexOf(writer);
-		if (idx !== -1) writers.splice(idx, 1);
-	};
-}
-let suppressConsole = false;
-/** Suppress console output from the logger (writers still receive output). */
-function setSuppressConsole(value) {
-	suppressConsole = value;
-}
-let outputMode = "console";
-/** Set output mode for log messages (not spans — spans always use stderr). */
-function setOutputMode(mode) {
-	outputMode = mode;
-}
-/** Get current output mode */
-function getOutputMode() {
-	return outputMode;
-}
-const LOG_LEVEL_PRIORITY = {
-	trace: 0,
-	debug: 1,
-	info: 2,
-	warn: 3,
-	error: 4,
-	silent: 5
-};
-const envLogLevel = getEnv("LOG_LEVEL")?.toLowerCase();
-let currentLogLevel = envLogLevel === "trace" || envLogLevel === "debug" || envLogLevel === "info" || envLogLevel === "warn" || envLogLevel === "error" || envLogLevel === "silent" ? envLogLevel : "info";
-const traceEnv = getEnv("TRACE");
-let spansEnabled = traceEnv === "1" || traceEnv === "true";
-let traceFilter = null;
-if (traceEnv && traceEnv !== "1" && traceEnv !== "true") {
-	traceFilter = new Set(traceEnv.split(",").map((s) => s.trim()));
-	spansEnabled = true;
-}
-/** Parse a comma-separated namespace filter into include/exclude sets */
-function parseNamespaceFilter(input) {
-	const includeList = [];
-	const excludeList = [];
-	for (const part of input) if (part.startsWith("-")) excludeList.push(part.slice(1));
-	else includeList.push(part);
-	return {
-		includes: includeList.length > 0 ? new Set(includeList) : null,
-		excludes: excludeList.length > 0 ? new Set(excludeList) : null
-	};
-}
-const debugEnv = getEnv("DEBUG");
-let debugIncludes = null;
-let debugExcludes = null;
-if (debugEnv) {
-	const parsed = parseNamespaceFilter(debugEnv.split(",").map((s) => s.trim()));
-	debugIncludes = parsed.includes;
-	if (debugIncludes && [...debugIncludes].some((p) => p === "*" || p === "1" || p === "true")) debugIncludes = new Set(["*"]);
-	debugExcludes = parsed.excludes;
-	if (LOG_LEVEL_PRIORITY[currentLogLevel] > LOG_LEVEL_PRIORITY.debug) currentLogLevel = "debug";
-}
-/** Set minimum log level */
-function setLogLevel(level) {
-	currentLogLevel = level;
-}
-/** Get current log level */
-function getLogLevel() {
-	return currentLogLevel;
-}
-/** Enable span output */
-function enableSpans() {
-	spansEnabled = true;
-}
-/** Disable span output */
-function disableSpans() {
-	spansEnabled = false;
-}
-/** Check if spans are enabled */
-function spansAreEnabled() {
-	return spansEnabled;
-}
-/**
-* Set trace filter for namespace-based span output control.
-* Only spans matching these namespace prefixes will be output.
-* @param namespaces - Array of namespace prefixes, or null to disable filtering
-*/
-function setTraceFilter(namespaces) {
-	if (namespaces === null || namespaces.length === 0) traceFilter = null;
-	else {
-		traceFilter = new Set(namespaces);
-		spansEnabled = true;
-	}
-}
-/** Get current trace filter (null means no filtering) */
-function getTraceFilter() {
-	return traceFilter ? [...traceFilter] : null;
-}
-/**
-* Set debug namespace filter (like the `debug` npm package).
-* When set, only loggers matching these namespace prefixes produce output.
-* Supports negative patterns with `-` prefix (e.g., ["-km:noisy"]).
-* Also ensures log level is at least `debug`.
-* @param namespaces - Array of namespace prefixes (prefix with `-` to exclude), or null to disable
-*/
-function setDebugFilter(namespaces) {
-	if (namespaces === null || namespaces.length === 0) {
-		debugIncludes = null;
-		debugExcludes = null;
-	} else {
-		const parsed = parseNamespaceFilter(namespaces);
-		debugIncludes = parsed.includes;
-		debugExcludes = parsed.excludes;
-		if (LOG_LEVEL_PRIORITY[currentLogLevel] > LOG_LEVEL_PRIORITY.debug) currentLogLevel = "debug";
-	}
-}
-/** Get current debug namespace filter (null means no filtering) */
-function getDebugFilter() {
-	if (!debugIncludes && !debugExcludes) return null;
-	const result = [];
-	if (debugIncludes) result.push(...debugIncludes);
-	if (debugExcludes) result.push(...[...debugExcludes].map((e) => `-${e}`));
-	return result;
-}
-const envLogFormat = getEnv("LOG_FORMAT")?.toLowerCase();
-let currentLogFormat = envLogFormat === "json" ? "json" : envLogFormat === "console" ? "console" : "console";
-/** Set log output format */
-function setLogFormat(format) {
-	currentLogFormat = format;
-}
-/** Get current log output format */
-function getLogFormat() {
-	return currentLogFormat;
-}
-/** Determine whether to use JSON formatting for the current call */
-function useJsonFormat() {
-	return currentLogFormat === "json" || getEnv("NODE_ENV") === "production" || getEnv("TRACE_FORMAT") === "json";
-}
-function resetIds() {
-	resetIdCounters();
-}
-/** Hook to get current span context tags (trace_id, span_id) for auto-tagging logs */
-let _getContextTags = null;
-/** Hook to get parent span info from async context */
-let _getContextParent = null;
-/** Hook to enter a span context (sets AsyncLocalStorage for the current async scope) */
-let _enterContext = null;
-/** Hook to exit a span context (restores previous context snapshot) */
-let _exitContext = null;
-/**
-* Register context propagation hooks (called by context.ts).
-* @internal
-*/
-function _setContextHooks(hooks) {
-	_getContextTags = hooks.getContextTags;
-	_getContextParent = hooks.getContextParent;
-	_enterContext = hooks.enterContext;
-	_exitContext = hooks.exitContext;
-}
-/**
-* Clear context propagation hooks (called by disableContextPropagation).
-* @internal
-*/
-function _clearContextHooks() {
-	_getContextTags = null;
-	_getContextParent = null;
-	_enterContext = null;
-	_exitContext = null;
-}
-function shouldLog(level) {
-	return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[currentLogLevel];
-}
-function shouldTraceNamespace(namespace) {
-	if (!spansEnabled) return false;
-	if (!traceFilter) return true;
-	return matchesNamespaceSet(namespace, traceFilter);
-}
-/**
-* Safe JSON.stringify that handles bigint, circular refs, symbols, and Error objects.
-* Prevents crashes from non-serializable values in log data.
-*/
-function safeStringify(value) {
-	const seen = /* @__PURE__ */ new WeakSet();
-	return JSON.stringify(value, (_key, val) => {
-		if (typeof val === "bigint") return val.toString();
-		if (typeof val === "symbol") return val.toString();
-		if (val instanceof Error) return {
-			message: val.message,
-			stack: val.stack,
-			name: val.name
-		};
-		if (typeof val === "object" && val !== null) {
-			if (seen.has(val)) return "[Circular]";
-			seen.add(val);
-		}
-		return val;
-	});
-}
-function formatConsole(namespace, level, message, data) {
-	const time = colors.dim((/* @__PURE__ */ new Date()).toISOString().split("T")[1]?.split(".")[0] || "");
-	let levelStr = "";
-	switch (level) {
-		case "trace":
-			levelStr = colors.dim("TRACE");
-			break;
-		case "debug":
-			levelStr = colors.dim("DEBUG");
-			break;
-		case "info":
-			levelStr = colors.blue("INFO");
-			break;
-		case "warn":
-			levelStr = colors.yellow("WARN");
-			break;
-		case "error":
-			levelStr = colors.red("ERROR");
-			break;
-		case "span":
-			levelStr = colors.magenta("SPAN");
-			break;
-	}
-	const ns = colors.cyan(namespace);
-	let output = `${time} ${levelStr} ${ns} ${message}`;
-	if (data && Object.keys(data).length > 0) output += ` ${colors.dim(safeStringify(data))}`;
-	return output;
-}
-function formatJSON(namespace, level, message, data) {
-	return safeStringify({
-		time: (/* @__PURE__ */ new Date()).toISOString(),
-		level,
-		name: namespace,
-		msg: message,
-		...data
-	});
-}
-function matchesNamespaceSet(namespace, set) {
-	if (set.has("*")) return true;
-	for (const filter of set) if (namespace === filter || namespace.startsWith(filter + ":")) return true;
-	return false;
-}
-function shouldDebugNamespace(namespace) {
-	if (!debugIncludes && !debugExcludes) return true;
-	if (debugExcludes && matchesNamespaceSet(namespace, debugExcludes)) return false;
-	if (debugIncludes) return matchesNamespaceSet(namespace, debugIncludes);
-	return true;
-}
-/** Resolve a lazy message: if it's a function, call it; otherwise return the string */
-function resolveMessage(msg) {
-	return typeof msg === "function" ? msg() : msg;
-}
-function writeLog(namespace, level, message, data) {
-	if (!shouldLog(level)) return;
-	if (!shouldDebugNamespace(namespace)) return;
-	const resolved = resolveMessage(message);
-	const contextTags = _getContextTags?.();
-	const mergedData = contextTags && Object.keys(contextTags).length > 0 ? {
-		...contextTags,
-		...data
-	} : data;
-	const formatted = useJsonFormat() ? formatJSON(namespace, level, resolved, mergedData) : formatConsole(namespace, level, resolved, mergedData);
-	for (const w of writers) w(formatted, level);
-	if (suppressConsole || outputMode === "writers-only") return;
-	if (outputMode === "stderr") {
-		writeStderr(formatted);
-		return;
-	}
-	switch (level) {
-		case "trace":
-		case "debug":
-			console.debug(formatted);
-			break;
-		case "info":
-			console.info(formatted);
-			break;
-		case "warn":
-			console.warn(formatted);
-			break;
-		case "error":
-			console.error(formatted);
-			break;
-	}
-}
-function writeSpan(namespace, duration, attrs) {
-	if (!shouldTraceNamespace(namespace)) return;
-	if (!shouldDebugNamespace(namespace)) return;
-	const message = `(${duration}ms)`;
-	const formatted = useJsonFormat() ? formatJSON(namespace, "span", message, {
-		duration,
-		...attrs
-	}) : formatConsole(namespace, "span", message, {
-		duration,
-		...attrs
-	});
-	for (const w of writers) w(formatted, "span");
-	if (!suppressConsole) writeStderr(formatted);
-}
-/**
-* Create a proxy that exposes span metadata as readonly and custom attributes as writable.
-* Shared between core logger spans and worker logger spans.
-*/
-function createSpanDataProxy(getFields, attrs) {
-	const READONLY_KEYS = new Set([
-		"id",
-		"traceId",
-		"parentId",
-		"startTime",
-		"endTime",
-		"duration"
-	]);
-	return new Proxy(attrs, {
-		get(_target, prop) {
-			if (READONLY_KEYS.has(prop)) return getFields()[prop];
-			return attrs[prop];
-		},
-		set(_target, prop, value) {
-			if (READONLY_KEYS.has(prop)) return false;
-			attrs[prop] = value;
-			return true;
-		}
-	});
-}
-function createLoggerImpl(name, props, spanMeta, parentSpanId, traceId, traceSampled = true) {
-	const log = (level, msgOrError, data) => {
-		if (msgOrError instanceof Error) {
-			const err = msgOrError;
-			writeLog(name, level, err.message, {
-				...props,
-				...data,
-				error_type: err.name,
-				error_stack: err.stack,
-				error_code: err.code
-			});
-		} else writeLog(name, level, msgOrError, {
-			...props,
-			...data
-		});
-	};
-	return {
-		name,
-		props: Object.freeze({ ...props }),
-		get spanData() {
-			if (!spanMeta) return null;
-			return createSpanDataProxy(() => ({
-				id: spanMeta.id,
-				traceId: spanMeta.traceId,
-				parentId: spanMeta.parentId,
-				startTime: spanMeta.startTime,
-				endTime: spanMeta.endTime,
-				duration: spanMeta.endTime !== null ? spanMeta.endTime - spanMeta.startTime : Date.now() - spanMeta.startTime
-			}), spanMeta.attrs);
-		},
-		trace: (msg, data) => log("trace", msg, data),
-		debug: (msg, data) => log("debug", msg, data),
-		info: (msg, data) => log("info", msg, data),
-		warn: (msg, data) => log("warn", msg, data),
-		error: (msgOrError, data) => log("error", msgOrError, data),
-		logger(namespace, childProps) {
-			return createLoggerImpl(namespace ? `${name}:${namespace}` : name, {
-				...props,
-				...childProps
-			}, null, parentSpanId, traceId, traceSampled);
-		},
-		span(namespace, childProps) {
-			const childName = namespace ? `${name}:${namespace}` : name;
-			const resolvedChildProps = typeof childProps === "function" ? childProps() : childProps;
-			const mergedProps = {
-				...props,
-				...resolvedChildProps
-			};
-			const newSpanId = generateSpanId();
-			let resolvedParentId = parentSpanId;
-			let resolvedTraceId = traceId;
-			if (!resolvedParentId && _getContextParent) {
-				const ctxParent = _getContextParent();
-				if (ctxParent) {
-					resolvedParentId = ctxParent.spanId;
-					resolvedTraceId = resolvedTraceId || ctxParent.traceId;
-				}
-			}
-			const isNewTrace = !resolvedTraceId;
-			const finalTraceId = resolvedTraceId || generateTraceId();
-			const sampled = isNewTrace ? shouldSample() : traceSampled;
-			const newSpanData = {
-				id: newSpanId,
-				traceId: finalTraceId,
-				parentId: resolvedParentId,
-				startTime: Date.now(),
-				endTime: null,
-				duration: null,
-				attrs: {}
-			};
-			const spanLogger = createLoggerImpl(childName, mergedProps, newSpanData, newSpanId, finalTraceId, sampled);
-			_enterContext?.(newSpanId, finalTraceId, resolvedParentId);
-			spanLogger[Symbol.dispose] = () => {
-				if (newSpanData.endTime !== null) return;
-				newSpanData.endTime = Date.now();
-				newSpanData.duration = newSpanData.endTime - newSpanData.startTime;
-				if (collectSpans) collectedSpans.push(createSpanDataProxy(() => ({
-					id: newSpanData.id,
-					traceId: newSpanData.traceId,
-					parentId: newSpanData.parentId,
-					startTime: newSpanData.startTime,
-					endTime: newSpanData.endTime,
-					duration: newSpanData.duration
-				}), { ...newSpanData.attrs }));
-				_exitContext?.(newSpanId);
-				_ambientRecorder?.recordSpan({
-					name: childName,
-					durationMs: newSpanData.duration
-				});
-				if (sampled) writeSpan(childName, newSpanData.duration, {
-					span_id: newSpanData.id,
-					trace_id: newSpanData.traceId,
-					parent_id: newSpanData.parentId,
-					...mergedProps,
-					...newSpanData.attrs
-				});
-			};
-			return spanLogger;
-		},
-		child(context) {
-			if (typeof context === "string") return this.logger(context);
-			return createLoggerImpl(name, {
-				...props,
-				...context
-			}, null, parentSpanId, traceId, traceSampled);
-		},
-		end() {
-			if (spanMeta?.endTime === null) this[Symbol.dispose]?.();
-		}
-	};
-}
-/**
-* Create a plain logger for a component (internal use).
-* For application code, use createLogger() instead which returns undefined for disabled levels.
-*/
-function createPlainLogger(name, props) {
-	return createLoggerImpl(name, props || {}, null, null, null);
-}
-const collectedSpans = [];
-let collectSpans = false;
-/** Enable span collection for analysis */
-function startCollecting() {
-	collectSpans = true;
-	collectedSpans.length = 0;
-}
-/** Stop collecting and return collected spans */
-function stopCollecting() {
-	collectSpans = false;
-	return [...collectedSpans];
-}
-/** Get collected spans */
-function getCollectedSpans() {
-	return [...collectedSpans];
-}
-/** Clear collected spans */
-function clearCollectedSpans() {
-	collectedSpans.length = 0;
-}
-/**
-* Create a logger for a component.
-* Returns undefined for disabled levels - use with optional chaining for zero overhead.
-*
-* Log levels (most → least verbose): trace < debug < info < warn < error < silent
-* Default level: info (trace and debug disabled)
-*
-* @example
-* const log = createLogger('myapp')
-*
-* // All methods support ?. for zero-overhead when disabled
-* log.trace?.(`very verbose: ${expensiveDebug()}`)  // Skipped at info level
-* log.debug?.(`debug: ${getState()}`)               // Skipped at info level
-* log.info?.('starting')                            // Enabled at info level
-* log.warn?.('deprecated')                          // Enabled at info level
-* log.error?.('failed')                             // Enabled at info level
-*
-* // With -q flag or LOG_LEVEL=warn:
-* log.info?.('starting')  // Now skipped - info < warn
-*
-* // With initial props
-* const log = createLogger('myapp', { version: '1.0' })
-*
-* // Create spans
-* {
-*   using task = log.span('import', { file: 'data.csv' })
-*   task.info?.('importing')
-*   task.spanData.count = 42
-* }
-*/
-function createLogger(name, props) {
-	const baseLog = createPlainLogger(name, props);
-	return new Proxy(baseLog, { get(target, prop) {
-		if (prop in LOG_LEVEL_PRIORITY && prop !== "silent") {
-			const current = LOG_LEVEL_PRIORITY[currentLogLevel];
-			if (LOG_LEVEL_PRIORITY[prop] < current) return;
-		}
-		return target[prop];
-	} });
-}
-//#endregion
-//#region src/file-writer.ts
-/**
-* File writer for loggily — Node.js/Bun only.
-*
-* Separated from core logger to allow tree-shaking in browser bundles.
-* Uses dynamic import("node:fs") to avoid static dependency on Node APIs.
-*/
-/**
-* Create an async buffered file writer for log output.
-* Buffers writes and flushes on size threshold or interval.
-* Registers a process.on('exit') handler to flush remaining buffer.
-*
-* **Node.js/Bun only** — not available in browser environments.
-*
-* @param filePath - Path to the log file (opened in append mode)
-* @param options - Buffer size and flush interval configuration
-* @returns FileWriter with write, flush, and close methods
-*
-* @example
-* const writer = createFileWriter('/tmp/app.log')
-* const unsubscribe = addWriter((formatted) => writer.write(formatted))
-*
-* // On shutdown:
-* unsubscribe()
-* writer.close()
-*/
-function createFileWriter(filePath, options = {}) {
-	const bufferSize = options.bufferSize ?? 4096;
-	const flushInterval = options.flushInterval ?? 100;
-	let buffer = "";
-	let fd = null;
-	let timer = null;
-	let closed = false;
-	fd = openSync(filePath, "a");
-	/** Flush buffer contents to disk synchronously */
-	function flush() {
-		if (buffer.length === 0 || fd === null) return;
-		writeSync(fd, buffer);
-		buffer = "";
-	}
-	timer = setInterval(flush, flushInterval);
-	if (timer && typeof timer === "object" && "unref" in timer) timer.unref();
-	const exitHandler = () => flush();
-	process.on("exit", exitHandler);
-	return {
-		write(line) {
-			if (closed) return;
-			buffer += line + "\n";
-			if (buffer.length >= bufferSize) flush();
-		},
-		flush,
-		close() {
-			if (closed) return;
-			closed = true;
-			if (timer !== null) {
-				clearInterval(timer);
-				timer = null;
-			}
-			try {
-				flush();
-			} catch {} finally {
-				if (fd !== null) {
-					closeSync(fd);
-					fd = null;
-				}
-				process.removeListener("exit", exitHandler);
-			}
-		}
-	};
-}
-//#endregion
-export { _ambientRecorder, _clearContextHooks, _setAmbientRecorder, _setContextHooks, addWriter, clearCollectedSpans, createFileWriter, createLogger, createSpanDataProxy, disableSpans, enableSpans, getCollectedSpans, getDebugFilter, getIdFormat, getLogFormat, getLogLevel, getOutputMode, getSampleRate, getTraceFilter, resetIds, setDebugFilter, setIdFormat, setLogFormat, setLogLevel, setOutputMode, setSampleRate, setSuppressConsole, setTraceFilter, spansAreEnabled, startCollecting, stopCollecting, traceparent, writeSpan };
-
-//# sourceMappingURL=index.mjs.map
+import { A as getSampleRate, C as setSuppressConsole, D as stopCollecting, E as startCollecting, F as buildPipeline, I as defaultPipeline, L as safeStringify, M as setSampleRate, N as traceparent, O as writeSpan, P as LOG_LEVEL_PRIORITY, R as createFileWriter, S as setOutputMode, T as spansAreEnabled, _ as getTraceFilter, a as addWriter, b as setLogFormat, c as createLogger, d as enableSpans, f as getCollectedSpans, g as getOutputMode, h as getLogLevel, i as _setContextHooks, j as setIdFormat, k as getIdFormat, l as createSpanDataProxy, m as getLogFormat, n as _clearContextHooks, o as clearCollectedSpans, p as getDebugFilter, r as _setAmbientRecorder, s as compose, t as _ambientRecorder, u as disableSpans, v as resetIds, w as setTraceFilter, x as setLogLevel, y as setDebugFilter } from "./core-Du3sIje6.mjs";
+export { LOG_LEVEL_PRIORITY, _ambientRecorder, _clearContextHooks, _setAmbientRecorder, _setContextHooks, addWriter, buildPipeline, clearCollectedSpans, compose, createFileWriter, createLogger, createSpanDataProxy, defaultPipeline, disableSpans, enableSpans, getCollectedSpans, getDebugFilter, getIdFormat, getLogFormat, getLogLevel, getOutputMode, getSampleRate, getTraceFilter, resetIds, safeStringify, setDebugFilter, setIdFormat, setLogFormat, setLogLevel, setOutputMode, setSampleRate, setSuppressConsole, setTraceFilter, spansAreEnabled, startCollecting, stopCollecting, traceparent, writeSpan };