autotel 4.2.5 → 5.0.0

package/dist/functional-Bit6noRu.js

@@ -0,0 +1,840 @@
+import { getForceFlushableProvider } from "./tracer-provider.js";
+import { getConfig } from "./config.js";
+import { AUTOTEL_SAMPLING_RATE, AUTOTEL_SAMPLING_TAIL_EVALUATED, AUTOTEL_SAMPLING_TAIL_KEEP, AlwaysSampler } from "./sampling.js";
+import { a as getSdk, n as getConfig$1 } from "./init-CdEWjhvl.js";
+import { g as getContextStorage, h as getActiveContextWithBaggage, p as createTraceContext, t as getEventQueue } from "./track-BBcxEJEC.js";
+import { setSpanName } from "./trace-helpers.js";
+import { n as runInOperationContext } from "./operation-context-CKBoA4Qy.js";
+import { SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+import * as nodeFs from "node:fs";
+import * as nodeUrl from "node:url";
+
+//#region src/variable-name-inference.ts
+/**
+* Variable Name Inference Utility
+*
+* Attempts to infer variable names from const/export const assignments
+* by analyzing the call stack and parsing source code.
+*
+* This is a best-effort approach with graceful degradation - if inference
+* fails for any reason, it returns undefined without breaking the application.
+*/
+/**
+* LRU Cache for inferred variable names
+* Key: "file:line" (e.g., "/path/to/file.ts:42")
+* Value: inferred variable name or undefined
+*/
+const inferenceCache = /* @__PURE__ */ new Map();
+const MAX_CACHE_SIZE = 50;
+/**
+* Captures the current call stack
+*/
+function captureStackTrace() {
+	const originalStackTraceLimit = Error.stackTraceLimit;
+	Error.stackTraceLimit = 10;
+	const stack = (/* @__PURE__ */ new Error("Stack trace capture")).stack || "";
+	Error.stackTraceLimit = originalStackTraceLimit;
+	return stack;
+}
+/**
+* Parses the stack trace to find where trace() was called
+*
+* Stack trace format (Node.js):
+*   at functionName (file:line:column)
+*   at file:line:column
+*
+* We skip frames until we find one that's NOT in functional.ts or this file.
+* We also need to skip one additional frame (the trace/span/instrument function itself)
+* to get to the actual user code.
+*/
+function parseCallLocation(stack) {
+	const lines = stack.split("\n");
+	let skippedExternalFrame = false;
+	for (const line of lines) {
+		if (line.includes("variable-name-inference.ts") || line.includes("variable-name-inference.js") || line.includes("functional.ts") || line.includes("functional.js")) continue;
+		const match = line.match(/at\s+(?:.*\s+)?\(?([^:]+):(\d+):(\d+)\)?/) || line.match(/^.*?([^:]+):(\d+):(\d+)/);
+		if (match) {
+			let filePath = match[1].trim();
+			if (filePath.startsWith("file://")) try {
+				filePath = nodeUrl.fileURLToPath(filePath);
+			} catch {
+				continue;
+			}
+			if (!skippedExternalFrame) {
+				skippedExternalFrame = true;
+				continue;
+			}
+			return {
+				file: filePath,
+				line: Number.parseInt(match[2], 10),
+				column: Number.parseInt(match[3], 10)
+			};
+		}
+	}
+}
+/**
+* Reads a specific line from a source file
+*/
+function readSourceLine(filePath, lineNumber) {
+	try {
+		if (typeof nodeFs.readFileSync !== "function") return;
+		return nodeFs.readFileSync(filePath, "utf8").split("\n")[lineNumber - 1];
+	} catch {
+		return;
+	}
+}
+/**
+* Extracts variable name from source code line using regex patterns
+*
+* Supported patterns:
+* - const varName = anyFunction(
+* - export const varName = anyFunction(
+* - let varName = anyFunction(
+* - var varName = anyFunction(
+*
+* Note: This won't work with destructuring assignments or complex patterns
+*/
+function extractVariableName(sourceLine) {
+	const trimmed = sourceLine.trim();
+	for (const pattern of [
+		/export\s+const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
+		/const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
+		/export\s+let\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
+		/let\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
+		/export\s+var\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
+		/var\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/
+	]) {
+		const match = trimmed.match(pattern);
+		if (match && match[1]) return match[1];
+	}
+}
+/**
+* Adds an entry to the cache with LRU eviction
+*/
+function cacheInference(key, value) {
+	if (inferenceCache.size >= MAX_CACHE_SIZE) {
+		const firstKey = inferenceCache.keys().next().value;
+		if (firstKey) inferenceCache.delete(firstKey);
+	}
+	inferenceCache.set(key, value);
+}
+/**
+* Main entry point: Attempts to infer the variable name from the call stack
+*
+* This function:
+* 1. Captures the call stack
+* 2. Parses it to find where trace() was called (file + line)
+* 3. Reads that line from the source file
+* 4. Extracts the variable name using regex
+*
+* Returns undefined if inference fails at any step (graceful degradation).
+* Results are cached to avoid repeated file I/O.
+*
+* @returns The inferred variable name, or undefined if inference failed
+*/
+function inferVariableNameFromCallStack() {
+	try {
+		const callLocation = parseCallLocation(captureStackTrace());
+		if (!callLocation) return;
+		const cacheKey = `${callLocation.file}:${callLocation.line}`;
+		if (inferenceCache.has(cacheKey)) return inferenceCache.get(cacheKey);
+		const sourceLine = readSourceLine(callLocation.file, callLocation.line);
+		if (!sourceLine) return;
+		const variableName = extractVariableName(sourceLine);
+		cacheInference(cacheKey, variableName);
+		return variableName;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+//#region src/functional.ts
+/**
+* Functional API for non-class code
+*
+* Three approaches for different use cases:
+* 1. trace() - Zero-ceremony HOF for single functions
+* 2. withTracing() - Middleware-style composable wrapper
+* 3. instrument() - Batch auto-instrumentation for modules
+*
+* @example trace() - Single function
+* ```typescript
+* export const createUser = trace(async (data) => {
+*   getActiveTraceContext()?.setAttribute('user.id', data.id)
+*   return await db.users.create(data)
+* })
+* ```
+*
+* @example withTracing() - Composable middleware
+* ```typescript
+* export const createUser = withTracing({
+*   name: 'user.create'
+* })(ctx => async (data) => {
+*   ctx.setAttribute('user.id', data.id)
+*   return await db.users.create(data)
+* })
+* ```
+*
+* @example instrument() - Batch instrumentation
+* ```typescript
+* export default instrument({
+*   createUser: async (data) => { },
+*   updateUser: async (id, data) => { }
+* }, { serviceName: 'user' })
+* ```
+*/
+let unknownSpanNameWarningEmitted = false;
+function resolveVariableName(named, variableName) {
+	const suppliedFunctionName = inferFunctionName(named);
+	const callStackVariableName = suppliedFunctionName ? void 0 : inferVariableNameFromCallStack();
+	return variableName || suppliedFunctionName || callStackVariableName;
+}
+/**
+* Wrap an explicit context factory `(ctx) => (...args) => result`.
+* Used by {@link withTracing}; the input is a factory by contract, so there is
+* no plain-vs-factory detection. The factory is never invoked at construction
+* time — only when the wrapper is called.
+*/
+function wrapFactoryWithTracing(factory, options, variableName) {
+	return wrapWithTracingSync(factory, options, resolveVariableName(factory, variableName));
+}
+/**
+* Wrap a plain function `(...args) => result`. Used by {@link trace} and
+* {@link instrument}: the function receives its real arguments and no context
+* is injected. Reach the active span via {@link getActiveTraceContext} inside
+* the body (or any helper it calls).
+*/
+function wrapPlainWithTracing(fn, options, variableName) {
+	const effectiveVariableName = resolveVariableName(fn, variableName);
+	const factory = (_ctx) => fn;
+	return wrapWithTracingSync(factory, options, effectiveVariableName);
+}
+const MAX_ERROR_MESSAGE_LENGTH = 500;
+function createDummyCtx() {
+	return {
+		traceId: "",
+		spanId: "",
+		correlationId: "",
+		setAttribute: () => {},
+		setAttributes: () => {},
+		setStatus: () => {},
+		recordException: () => {},
+		addEvent: () => {},
+		addLink: () => {},
+		addLinks: () => {},
+		updateName: () => {},
+		isRecording: () => false,
+		getBaggage: () => {},
+		setBaggage: () => "",
+		deleteBaggage: () => {},
+		getAllBaggage: () => /* @__PURE__ */ new Map()
+	};
+}
+/** Attribute keys for opt-in function I/O capture (see TracingOptions). */
+const AUTOTEL_INPUT_ATTR = "autotel.input";
+const AUTOTEL_OUTPUT_ATTR = "autotel.output";
+const CAPTURE_MAX_CHARS = 4096;
+/** JSON-serialize a captured value, defensively (truncate, swallow cycles). */
+function serializeCapture(value) {
+	if (value === void 0) return void 0;
+	try {
+		const json = typeof value === "string" ? value : JSON.stringify(value);
+		if (json === void 0) return void 0;
+		return json.length > CAPTURE_MAX_CHARS ? `${json.slice(0, CAPTURE_MAX_CHARS)}…[truncated]` : json;
+	} catch {
+		return;
+	}
+}
+/** `autotel.input` from args (single arg captured directly, else the array). */
+function captureInputAttrs(args, enabled) {
+	if (!enabled) return {};
+	const s = serializeCapture(args.length === 1 ? args[0] : args);
+	return s === void 0 ? {} : { [AUTOTEL_INPUT_ATTR]: s };
+}
+/** `autotel.output` from the return value. */
+function captureOutputAttrs(result, enabled) {
+	if (!enabled) return {};
+	const s = serializeCapture(result);
+	return s === void 0 ? {} : { [AUTOTEL_OUTPUT_ATTR]: s };
+}
+const INSTRUMENTED_SYMBOL = Symbol.for("autotel.functional.instrumented");
+function hasInstrumentationFlag(value) {
+	return (typeof value === "function" || typeof value === "object") && value !== null && Boolean(value[INSTRUMENTED_SYMBOL]);
+}
+/**
+* Truncate error message to prevent span bloat
+*/
+function truncateErrorMessage(message) {
+	if (message.length <= MAX_ERROR_MESSAGE_LENGTH) return message;
+	return `${message.slice(0, MAX_ERROR_MESSAGE_LENGTH)}... (truncated)`;
+}
+/**
+* Terminal handling for a value thrown by a traced function. Shared by all four
+* `trace()` execution paths (immediate + wrapper, sync + async) so the outcome
+* rules live in exactly one place. Ends the span; the caller flushes (await/void)
+* and rethrows.
+*
+* If `isError` classifies the throw as expected control flow — e.g. a framework
+* `redirect()` / `notFound()` signal — it is recorded as a success outcome with
+* an OK status and no exception. Otherwise it is recorded as an error.
+*/
+function finalizeThrownSpan(error, isError, ctx) {
+	const { span, spanName, duration, callCounter, durationHistogram, handleTailSampling, extraAttributes } = ctx;
+	const baseAttributes = {
+		...extraAttributes,
+		"operation.name": spanName,
+		"code.function": spanName,
+		"operation.duration": duration
+	};
+	if (isError && !isError(error)) {
+		callCounter?.add(1, {
+			operation: spanName,
+			status: "success"
+		});
+		durationHistogram?.record(duration, {
+			operation: spanName,
+			status: "success"
+		});
+		span.setStatus({ code: SpanStatusCode.OK });
+		span.setAttributes({
+			...baseAttributes,
+			"operation.success": true
+		});
+		handleTailSampling(true, duration);
+		span.end();
+		return;
+	}
+	callCounter?.add(1, {
+		operation: spanName,
+		status: "error"
+	});
+	durationHistogram?.record(duration, {
+		operation: spanName,
+		status: "error"
+	});
+	const truncatedMessage = truncateErrorMessage(error instanceof Error ? error.message : "Unknown error");
+	span.setStatus({
+		code: SpanStatusCode.ERROR,
+		message: truncatedMessage
+	});
+	span.setAttributes({
+		...baseAttributes,
+		"operation.success": false,
+		error: true,
+		"exception.type": error instanceof Error ? error.constructor.name : "Error",
+		"exception.message": truncatedMessage
+	});
+	if (error instanceof Error && error.stack) span.setAttribute("exception.stack", error.stack.slice(0, MAX_ERROR_MESSAGE_LENGTH));
+	const thrown = error instanceof Error ? error : new Error(String(error));
+	span.recordException(thrown);
+	handleTailSampling(false, duration, thrown);
+	span.end();
+}
+/**
+* Try to infer function name from function properties
+* Checks for displayName, name, or other metadata that might be set
+*/
+function inferFunctionName(fn) {
+	const displayName = fn.displayName;
+	if (displayName) return displayName;
+	if (fn.name && fn.name !== "anonymous" && fn.name !== "") return fn.name;
+	const match = Function.prototype.toString.call(fn).match(/function\s+([^(\s]+)/);
+	if (match && match[1] && match[1] !== "anonymous") return match[1];
+}
+/**
+* Determine span name using priority:
+* 1. Explicit name option
+* 2. serviceName + functionName
+* 3. Inferred from function/variable name (including stack trace fallback)
+* 4. Fallback to 'unknown'
+*/
+function getSpanName(options, fn, variableName) {
+	if (options.name) return options.name;
+	let fnName = variableName || inferFunctionName(fn);
+	fnName = fnName || "anonymous";
+	if (options.serviceName) return `${options.serviceName}.${fnName}`;
+	if (fnName && fnName !== "anonymous") return fnName;
+	const initConfig = getConfig$1();
+	if (typeof process !== "undefined" && process.env.NODE_ENV !== "production" && !unknownSpanNameWarningEmitted && initConfig?.logger?.warn) {
+		unknownSpanNameWarningEmitted = true;
+		initConfig.logger.warn({}, "[autotel] Span name resolved to \"unknown\". Pass an explicit name, for example trace(\"operation.name\", fn).");
+	}
+	return "unknown";
+}
+/**
+* Check if function should be skipped
+*/
+function shouldSkip(key, fn, skip) {
+	if (key.startsWith("_")) return true;
+	if (!skip || skip.length === 0) return false;
+	for (const rule of skip) if (typeof rule === "string" && key === rule) return true;
+	else if (rule instanceof RegExp && rule.test(key)) return true;
+	else if (typeof rule === "function" && rule(key, fn)) return true;
+	return false;
+}
+/**
+* Get current trace context value (internal helper)
+*
+* Returns base context (trace IDs) + span methods from the active span.
+*/
+function getCtxValue() {
+	const activeSpan = trace.getActiveSpan();
+	if (!activeSpan) return null;
+	return createTraceContext(activeSpan);
+}
+/**
+* Get the autotel {@link TraceContext} for the currently active span.
+*
+* This is the ambient accessor for the functional API: instead of threading a
+* `ctx` parameter through a factory, call this inside any traced function (or a
+* helper it calls) to reach `setAttribute`, `setUser`, `getBaggage`, and the
+* rest of the context surface. Returns `undefined` when no span is active.
+*
+* @example
+* ```typescript
+* const getUser = trace('getUser', async (id: string) => {
+*   getActiveTraceContext()?.setAttribute('user.id', id);
+*   return db.users.find(id);
+* });
+* ```
+*
+* @see getActiveSpan for the raw OpenTelemetry span
+* @see getRequestLogger which reads the active context when called with no args
+*/
+function getActiveTraceContext() {
+	return getCtxValue() ?? void 0;
+}
+/**
+* Context object that lazily evaluates the active span on property access
+*
+* Access trace context directly without function call syntax.
+*
+* @example
+* ```typescript
+* import { trace, ctx } from 'autotel'
+*
+* export const createUser = trace(async (data) => {
+*   // Direct property access - no function call!
+*   if (ctx.traceId) {
+*     ctx.setAttribute('user.id', data.id)
+*     console.log('Trace:', ctx.traceId)
+*   }
+* })
+* ```
+*/
+const ctx = new Proxy({}, {
+	get(_target, prop) {
+		const ctxValue = getCtxValue();
+		if (!ctxValue) return;
+		return ctxValue[prop];
+	},
+	has(_target, prop) {
+		const ctxValue = getCtxValue();
+		if (!ctxValue) return false;
+		return prop in ctxValue;
+	},
+	ownKeys() {
+		const ctxValue = getCtxValue();
+		if (!ctxValue) return [];
+		return Object.keys(ctxValue);
+	},
+	getOwnPropertyDescriptor(_target, prop) {
+		const ctxValue = getCtxValue();
+		if (!ctxValue) return;
+		return Object.getOwnPropertyDescriptor(ctxValue, prop);
+	}
+});
+/**
+* Build the root-operation flush policy once and reuse it for wrapped and
+* immediate execution. Async operations await this function; sync operations
+* trigger it without blocking.
+*/
+function createRootTelemetryFlusher(options, isRootSpan) {
+	const initConfig = getConfig$1();
+	const shouldFlush = options.flushOnRootSpanEnd ?? initConfig?.flushOnRootSpanEnd ?? true;
+	const shouldFlushSpans = initConfig?.forceFlushOnShutdown ?? false;
+	return async () => {
+		if (!shouldFlush || !isRootSpan) return;
+		try {
+			const queue = getEventQueue();
+			if (queue && queue.size() > 0) await queue.flush();
+			if (shouldFlushSpans) await getForceFlushableProvider(getSdk())?.forceFlush();
+		} catch (error) {
+			(getConfig$1()?.logger)?.error?.({ err: error instanceof Error ? error : void 0 }, `[autotel] Auto-flush failed${error instanceof Error ? "" : `: ${String(error)}`}`);
+		}
+	};
+}
+/**
+* Give every root operation its own baggage context without replacing a
+* caller's existing scope. AsyncLocalStorage keeps the scope alive until an
+* async result settles and restores the previous store afterwards.
+*/
+function runWithTraceContextStorage(fn) {
+	const storage = getContextStorage();
+	if (storage.getStore()) return fn();
+	return storage.run({ value: context.active() }, fn);
+}
+/**
+* Core tracing wrapper for sync functions (internal implementation)
+*/
+function wrapWithTracingSync(fnFactory, options, variableName) {
+	if (hasInstrumentationFlag(fnFactory)) {}
+	const config = getConfig();
+	const tracer = config.tracer;
+	const meter = config.meter;
+	const sampler = options.sampler || new AlwaysSampler();
+	const spanName = getSpanName(options, fnFactory, variableName);
+	const callCounter = options.withMetrics ? meter.createCounter(`${spanName}.calls`, {
+		description: `Call count for ${spanName}`,
+		unit: "1"
+	}) : void 0;
+	const durationHistogram = options.withMetrics ? meter.createHistogram(`${spanName}.duration`, {
+		description: `Duration for ${spanName}`,
+		unit: "ms"
+	}) : void 0;
+	function wrappedFunction(...args) {
+		const samplingContext = {
+			operationName: spanName,
+			args,
+			metadata: {}
+		};
+		const shouldSample = sampler.shouldSample(samplingContext);
+		const sampleRate = sampler.sampleRate?.(samplingContext);
+		const needsTailSampling = sampler.needsTailSampling?.() ?? false;
+		if (!shouldSample && !needsTailSampling) return fnFactory(createDummyCtx()).call(this, ...args);
+		const startTime = performance.now();
+		const flushRootTelemetry = createRootTelemetryFlusher(options, options.startNewRoot || trace.getActiveSpan() === void 0);
+		const spanOptions = {};
+		if (options.startNewRoot) spanOptions.root = true;
+		if (options.spanKind !== void 0) spanOptions.kind = options.spanKind;
+		const parentContext = getActiveContextWithBaggage();
+		return tracer.startActiveSpan(spanName, spanOptions, parentContext, (span) => {
+			return runInOperationContext(spanName, () => runWithTraceContextStorage(() => {
+				let shouldKeepSpan = true;
+				setSpanName(span, spanName);
+				if (sampleRate !== void 0 && sampleRate > 1) span.setAttribute(AUTOTEL_SAMPLING_RATE, sampleRate);
+				const fn = fnFactory(createTraceContext(span));
+				const argsAttributes = {
+					...captureInputAttrs(args, options.captureInput),
+					...options.attributesFromArgs ? options.attributesFromArgs(args) : {}
+				};
+				const handleTailSampling = (success, duration, error) => {
+					if (needsTailSampling && sampler.shouldKeepTrace) {
+						shouldKeepSpan = sampler.shouldKeepTrace(samplingContext, {
+							success,
+							duration,
+							error
+						});
+						span.setAttribute(AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
+						span.setAttribute(AUTOTEL_SAMPLING_TAIL_EVALUATED, true);
+					}
+				};
+				const onSuccess = (result) => {
+					const duration = performance.now() - startTime;
+					callCounter?.add(1, {
+						operation: spanName,
+						status: "success"
+					});
+					durationHistogram?.record(duration, {
+						operation: spanName,
+						status: "success"
+					});
+					const resultAttributes = {
+						...captureOutputAttrs(result, options.captureOutput),
+						...options.attributesFromResult ? options.attributesFromResult(result) : {}
+					};
+					span.setStatus({ code: SpanStatusCode.OK });
+					span.setAttributes({
+						...argsAttributes,
+						...resultAttributes,
+						"operation.name": spanName,
+						"code.function": spanName,
+						"operation.duration": duration,
+						"operation.success": true
+					});
+					handleTailSampling(true, duration);
+					span.end();
+					return result;
+				};
+				const onError = (error) => {
+					finalizeThrownSpan(error, options.isError, {
+						span,
+						spanName,
+						duration: performance.now() - startTime,
+						callCounter,
+						durationHistogram,
+						handleTailSampling,
+						extraAttributes: argsAttributes
+					});
+					throw error;
+				};
+				try {
+					callCounter?.add(1, {
+						operation: spanName,
+						status: "started"
+					});
+					const result = context.with(getActiveContextWithBaggage(), () => fn.call(this, ...args));
+					if (result instanceof Promise) return result.then(async (value) => {
+						const completed = onSuccess(value);
+						await flushRootTelemetry();
+						return completed;
+					}, async (error) => {
+						try {
+							return onError(error);
+						} finally {
+							await flushRootTelemetry();
+						}
+					});
+					const completed = onSuccess(result);
+					flushRootTelemetry();
+					return completed;
+				} catch (error) {
+					try {
+						return onError(error);
+					} finally {
+						flushRootTelemetry();
+					}
+				}
+			}));
+		});
+	}
+	wrappedFunction[INSTRUMENTED_SYMBOL] = true;
+	Object.defineProperty(wrappedFunction, "name", {
+		value: variableName || "trace",
+		configurable: true
+	});
+	return wrappedFunction;
+}
+function trace$1(fnOrNameOrOptions, maybeFn) {
+	if (typeof fnOrNameOrOptions === "function") return wrapPlainWithTracing(fnOrNameOrOptions, {});
+	if (!maybeFn) throw new Error("trace(name|options, fn): fn is required");
+	return wrapPlainWithTracing(maybeFn, typeof fnOrNameOrOptions === "string" ? { name: fnOrNameOrOptions } : fnOrNameOrOptions);
+}
+/**
+* Approach 2: withTracing() - Middleware-style composable wrapper
+*
+* Returns a HOF that wraps functions with tracing.
+* Perfect for composition and reusable configuration.
+*
+* @example Standard usage
+* ```typescript
+* export const createUser = withTracing({
+*   name: 'user.create'
+* })(ctx => async (data) => {
+*   ctx.setAttribute('user.id', data.id)
+*   return await db.users.create(data)
+* })
+* ```
+*
+* @example Composable
+* ```typescript
+* const tracer = withTracing({ serviceName: 'user' })
+*
+* export const createUser = tracer(ctx => async (data) => { })
+* export const updateUser = tracer(ctx => async (id, data) => { })
+* ```
+*
+* @example With other middleware
+* ```typescript
+* export const createUser = compose(
+*   withAuth({ role: 'admin' }),
+*   withTracing({ name: 'user.create' }),
+*   withRateLimit({ max: 100 })
+* )(ctx => async (data) => { })
+* ```
+*/
+function withTracing(options = {}) {
+	return (fnFactory) => wrapFactoryWithTracing(fnFactory, options);
+}
+function instrument(options) {
+	if (!options || typeof options !== "object") throw new TypeError("instrument: expected { key, fn } or { functions: { name: fn } }");
+	if ("key" in options || "fn" in options) {
+		const { key, fn, ...tracingOptions } = options;
+		if (typeof key !== "string" || key.trim() === "") throw new TypeError("instrument: \"key\" must be a non-empty string in the { key, fn } form");
+		if (typeof fn !== "function") throw new TypeError("instrument: \"fn\" must be a function in the { key, fn } form");
+		return wrapPlainWithTracing(fn, tracingOptions, key);
+	}
+	const { functions, ...tracingOptions } = options;
+	if (!functions || typeof functions !== "object") throw new TypeError("instrument: expected { key, fn } or { functions: { name: fn } }");
+	const instrumented = {};
+	for (const key of Object.keys(functions)) {
+		const typedKey = key;
+		const fn = functions[typedKey];
+		if (!fn || typeof fn !== "function") {
+			instrumented[typedKey] = fn;
+			continue;
+		}
+		if (shouldSkip(key, fn, tracingOptions.skip)) {
+			instrumented[typedKey] = fn;
+			continue;
+		}
+		const fnOptions = {
+			...tracingOptions,
+			...tracingOptions.overrides?.[key],
+			name: tracingOptions.overrides?.[key]?.name
+		};
+		const boundFn = fn.bind(functions);
+		const fnFactory = (ctx) => {
+			return boundFn;
+		};
+		instrumented[typedKey] = wrapFactoryWithTracing(fnFactory, fnOptions, key);
+	}
+	return instrumented;
+}
+function span(nameOrOptions, fn) {
+	const options = typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions;
+	const tracer = getConfig().tracer;
+	const { name, attributes, spanKind } = options;
+	const executeSpan = (span) => {
+		return runInOperationContext(name, () => {
+			try {
+				if (attributes) for (const [key, value] of Object.entries(attributes)) span.setAttribute(key, value);
+				const result = fn(span);
+				if (result instanceof Promise) return result.then((resolved) => {
+					span.setStatus({ code: SpanStatusCode.OK });
+					span.end();
+					return resolved;
+				}).catch((error) => {
+					const errorMessage = error instanceof Error ? error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH) : String(error).slice(0, MAX_ERROR_MESSAGE_LENGTH);
+					span.setAttribute("error.message", errorMessage);
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: errorMessage
+					});
+					span.recordException(error instanceof Error ? error : new Error(String(error)));
+					span.end();
+					throw error;
+				});
+				else {
+					span.setStatus({ code: SpanStatusCode.OK });
+					span.end();
+					return result;
+				}
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH) : String(error).slice(0, MAX_ERROR_MESSAGE_LENGTH);
+				span.setAttribute("error.message", errorMessage);
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: errorMessage
+				});
+				span.recordException(error instanceof Error ? error : new Error(String(error)));
+				span.end();
+				throw error;
+			}
+		});
+	};
+	const parentContext = getActiveContextWithBaggage();
+	const result = tracer.startActiveSpan(name, spanKind === void 0 ? {} : { kind: spanKind }, parentContext, executeSpan);
+	if (result instanceof Promise) return result;
+	return result;
+}
+/**
+* Execute a function in a new root context (prevents span propagation)
+*
+* Useful when you want to start a completely new trace without
+* parent-child relationships.
+*
+* @example
+* ```typescript
+* async function handleWebhook(payload: WebhookPayload) {
+*   // This creates a new root trace, not connected to the HTTP request trace
+*   await withNewContext({
+*     fn: async () => {
+*       await span('webhook.process', async () => {
+*         await processWebhookPayload(payload)
+*       })
+*     }
+*   })
+* }
+* ```
+*/
+async function withNewContext(options) {
+	const { fn } = options;
+	return getConfig().tracer.startActiveSpan("root", { root: true }, async (span) => {
+		try {
+			const result = await fn();
+			span.setStatus({ code: SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.recordException(error instanceof Error ? error : new Error(String(error)));
+			span.setStatus({ code: SpanStatusCode.ERROR });
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+/**
+* Execute a function with updated baggage entries
+*
+* Baggage is immutable in OpenTelemetry, so this helper creates a new context
+* with the specified baggage entries and runs the function within that context.
+* All child spans created within the function will inherit the baggage.
+*
+* @example Setting baggage for downstream services
+* ```typescript
+* import { withTracing, withBaggage } from 'autotel';
+*
+* export const createOrder = withTracing({ name: 'order.create' })((ctx) => async (order: Order) => {
+*   // Set baggage that will be propagated to downstream HTTP calls
+*   return await withBaggage({
+*     baggage: {
+*       'tenant.id': order.tenantId,
+*       'user.id': order.userId,
+*     },
+*     fn: async () => {
+*       // This HTTP call will include the baggage in headers
+*       await fetch('/api/charge', {
+*         method: 'POST',
+*         body: JSON.stringify(order),
+*       });
+*     },
+*   });
+* });
+* ```
+*
+* @example Using with existing baggage
+* ```typescript
+* export const processOrder = withTracing({ name: 'order.process' })((ctx) => async (order: Order) => {
+*   // Read existing baggage
+*   const tenantId = ctx.getBaggage('tenant.id');
+*
+*   // Add additional baggage entries
+*   return await withBaggage({
+*     baggage: {
+*       'order.id': order.id,
+*       'order.amount': String(order.amount),
+*     },
+*     fn: async () => {
+*       await charge(order);
+*     },
+*   });
+* });
+* ```
+*/
+function withBaggage(options) {
+	const { baggage: baggageEntries, fn } = options;
+	const currentContext = context.active();
+	let updatedBaggage = propagation.getBaggage(currentContext) ?? propagation.createBaggage();
+	for (const [key, value] of Object.entries(baggageEntries)) updatedBaggage = updatedBaggage.setEntry(key, { value });
+	const newContext = propagation.setBaggage(currentContext, updatedBaggage);
+	const ctxStorage = getContextStorage();
+	const previousStored = ctxStorage.getStore();
+	const baggageEnrichedStored = previousStored ? { value: propagation.setBaggage(previousStored.value, updatedBaggage) } : { value: newContext };
+	const result = previousStored ? ctxStorage.run(baggageEnrichedStored, () => context.with(newContext, fn)) : context.with(newContext, fn);
+	if (result instanceof Promise) return result.then((value) => {
+		if (previousStored) return ctxStorage.run(previousStored, () => value);
+		return value;
+	}, (error) => {
+		if (previousStored) return ctxStorage.run(previousStored, () => {
+			throw error;
+		});
+		throw error;
+	});
+	return result;
+}
+
+//#endregion
+export { trace$1 as a, withTracing as c, span as i, getActiveTraceContext as n, withBaggage as o, instrument as r, withNewContext as s, ctx as t };
+//# sourceMappingURL=functional-Bit6noRu.js.map