autotel 3.6.0 → 3.7.0

package/dist/functional-BGkT8J-h.js

@@ -0,0 +1,1265 @@
+import { AUTOTEL_SAMPLING_TAIL_EVALUATED, AUTOTEL_SAMPLING_TAIL_KEEP, AlwaysSampler } from "./sampling.js";
+import { a as getSdk, n as getConfig } from "./init-Ch6t7MNI.js";
+import { getConfig as getConfig$1 } from "./config.js";
+import { _ as getContextStorage, g as getActiveContextWithBaggage, h as enterOrRun, p as createTraceContext, t as getEventQueue } from "./track-nsKVy-pj.js";
+import { setSpanName } from "./trace-helpers.js";
+import { n as runInOperationContext } from "./operation-context-C-2hmmtP.js";
+import { SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } 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 = 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 readFileSync !== "function") return;
+		return 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(ctx => async (data) => {
+*   ctx.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' })
+* ```
+*/
+const FACTORY_NAME_HINTS = new Set([
+	"ctx",
+	"_ctx",
+	"context",
+	"tracecontext",
+	"tracectx"
+]);
+const TRACE_FACTORY_SET = /* @__PURE__ */ new WeakSet();
+const SINGLE_LINE_COMMENT_REGEX = /\/\/.*$/gm;
+const MULTI_LINE_COMMENT_REGEX = /\/\*[\s\S]*?\*\//gm;
+const PARAM_TOKEN_SANITIZE_REGEX = new RegExp(String.raw`[{}\[\]\s]`, "g");
+function markAsTraceFactory(fn) {
+	TRACE_FACTORY_SET.add(fn);
+}
+function hasFactoryMark(fn) {
+	return TRACE_FACTORY_SET.has(fn);
+}
+function sanitizeParameterToken(token) {
+	const [firstToken] = token.split("=");
+	return (firstToken ?? "").replaceAll(PARAM_TOKEN_SANITIZE_REGEX, "").trim();
+}
+function getFirstParameterToken(fn) {
+	let source = Function.prototype.toString.call(fn);
+	source = source.replaceAll(MULTI_LINE_COMMENT_REGEX, "").replaceAll(SINGLE_LINE_COMMENT_REGEX, "").trim();
+	const arrowMatch = source.match(/^(?:async\s*)?(?:\(([^)]*)\)|([^=()]+))\s*=>/);
+	if (arrowMatch) {
+		const first = (arrowMatch[1] ?? arrowMatch[2] ?? "").split(",")[0]?.trim();
+		if (first) return sanitizeParameterToken(first);
+		return null;
+	}
+	const functionMatch = source.match(/^[^(]*\(([^)]*)\)/);
+	if (functionMatch) {
+		const first = (functionMatch[1]?.split(","))?.[0]?.trim();
+		if (first) return sanitizeParameterToken(first);
+	}
+	return null;
+}
+/**
+* Symbol that explicitly marks a function as immediate-execution-with-ctx
+* (`(ctx) => result`), bypassing parameter-name introspection. Library
+* authors who wrap user handlers — like `autotel-aws/lambda`'s `wrapHandler`
+* — should mark their inner trace function with this so dispatch survives
+* downstream bundlers that minify parameter names.
+*/
+const IMMEDIATE_EXECUTION_SYMBOL = Symbol.for("autotel.immediate-execution");
+function hasImmediateExecutionMark(fn) {
+	return typeof fn === "function" && fn[IMMEDIATE_EXECUTION_SYMBOL] === true;
+}
+/**
+* Mark a function as immediate-execution-with-ctx so `trace(name, fn)`
+* dispatch doesn't depend on the first parameter being named `ctx`.
+*
+* Necessary when the function will be bundled by a minifier (esbuild,
+* terser, etc.) that renames identifiers. The name-allowlist heuristic in
+* `looksLikeTraceFactory` cannot recover from that; the marker can.
+*
+* @example
+* ```ts
+* import { markAsImmediate, trace } from 'autotel';
+*
+* const inner = markAsImmediate(async (ctx) => {
+*   ctx.setAttribute('user.id', '123');
+*   return { ok: true };
+* });
+* const result = await trace('user.read', inner);
+* ```
+*/
+function markAsImmediate(fn) {
+	if (typeof fn === "function") fn[IMMEDIATE_EXECUTION_SYMBOL] = true;
+	return fn;
+}
+function looksLikeTraceFactory(fn) {
+	if (hasFactoryMark(fn)) return true;
+	if (hasImmediateExecutionMark(fn)) return true;
+	if (fn.length === 0) {
+		if (!isAsyncFunction(fn)) try {
+			return typeof fn() === "function";
+		} catch {
+			return false;
+		}
+		return false;
+	}
+	const firstParam = getFirstParameterToken(fn);
+	if (!firstParam) return false;
+	const normalized = firstParam.toLowerCase();
+	if (FACTORY_NAME_HINTS.has(normalized) || normalized.startsWith("ctx") || normalized.startsWith("_ctx") || normalized.startsWith("trace") || normalized.endsWith("ctx") || normalized.includes("context")) return true;
+	return false;
+}
+/**
+* Check if a function that takes ctx returns another function (factory pattern)
+* vs returning a value directly (immediate execution pattern)
+*
+* IMPORTANT: For async functions, we skip probing entirely and assume immediate execution.
+* This is because:
+* - Factory pattern: `(ctx) => async (...args) => result` - outer function is SYNC
+* - Immediate execution: `async (ctx) => result` - function itself is ASYNC
+*
+* Probing async functions by executing them causes side effects (like creating orphan spans)
+* because the async function starts executing synchronously until the first await.
+*/
+function isFactoryReturningFunction(fnWithCtx) {
+	if (isAsyncFunction(fnWithCtx)) return false;
+	try {
+		return typeof fnWithCtx(createDummyCtx()) === "function";
+	} catch {
+		return false;
+	}
+}
+function isTraceFactoryFunction(fn) {
+	if (typeof fn !== "function") return false;
+	if (hasFactoryMark(fn)) return true;
+	if (looksLikeTraceFactory(fn)) {
+		markAsTraceFactory(fn);
+		return true;
+	}
+	return false;
+}
+function ensureTraceFactory(fnOrFactory) {
+	if (isTraceFactoryFunction(fnOrFactory)) return fnOrFactory;
+	const plainFn = fnOrFactory;
+	const factory = (ctx) => {
+		return plainFn;
+	};
+	markAsTraceFactory(factory);
+	return factory;
+}
+function wrapFactoryWithTracing(fnOrFactory, options, variableName) {
+	const factory = ensureTraceFactory(fnOrFactory);
+	const sampleFn = factory(createDummyCtx());
+	const innerFunctionName = inferFunctionName(sampleFn);
+	const callStackVariableName = innerFunctionName ? void 0 : inferVariableNameFromCallStack();
+	const factoryName = inferFunctionName(factory);
+	const effectiveVariableName = variableName || innerFunctionName || callStackVariableName || factoryName;
+	if (isAsyncFunction(sampleFn)) return wrapWithTracing(factory, options, effectiveVariableName);
+	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 };
+}
+function isAsyncFunction(fn) {
+	return typeof fn === "function" && fn.constructor?.name === "AsyncFunction";
+}
+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)`;
+}
+/**
+* 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;
+	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);
+}
+/**
+* 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);
+	}
+});
+/**
+* Core tracing wrapper for async functions (internal implementation)
+*/
+function wrapWithTracing(fnFactory, options, variableName) {
+	if (hasInstrumentationFlag(fnFactory)) {}
+	const config = getConfig$1();
+	const tracer = config.tracer;
+	const meter = config.meter;
+	const sampler = options.sampler || new AlwaysSampler();
+	const tempFn = fnFactory(createDummyCtx());
+	const spanName = getSpanName(options, tempFn, 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;
+	const wrappedFunction = async function wrappedFunction(...args) {
+		const samplingContext = {
+			operationName: spanName,
+			args,
+			metadata: {}
+		};
+		const shouldSample = sampler.shouldSample(samplingContext);
+		const needsTailSampling = "needsTailSampling" in sampler && typeof sampler.needsTailSampling === "function" ? sampler.needsTailSampling() : false;
+		if (!shouldSample && !needsTailSampling) return await fnFactory(createDummyCtx()).call(this, ...args);
+		const startTime = performance.now();
+		const isRootSpan = options.startNewRoot || trace.getActiveSpan() === void 0;
+		const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig()?.flushOnRootSpanEnd ?? true;
+		const shouldAutoFlushSpans = getConfig()?.forceFlushOnShutdown ?? false;
+		const flushIfNeeded = async () => {
+			if (!shouldAutoFlush || !isRootSpan) return;
+			try {
+				const queue = getEventQueue();
+				if (queue && queue.size() > 0) await queue.flush();
+				if (shouldAutoFlushSpans) {
+					const sdk = getSdk();
+					if (sdk) try {
+						const sdkAny = sdk;
+						if (typeof sdkAny.getTracerProvider === "function") {
+							const tracerProvider = sdkAny.getTracerProvider();
+							if (tracerProvider && typeof tracerProvider.forceFlush === "function") await tracerProvider.forceFlush();
+						}
+					} catch {}
+				}
+			} catch (error) {
+				const logger = getConfig()?.logger;
+				if (logger?.error) logger.error({ err: error instanceof Error ? error : void 0 }, `[autotel] Auto-flush failed${error instanceof Error ? "" : `: ${String(error)}`}`);
+			}
+		};
+		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, async (span) => {
+			return runInOperationContext(spanName, async () => {
+				let shouldKeepSpan = true;
+				setSpanName(span, spanName);
+				const initialContext = context.active();
+				const contextStorage = getContextStorage();
+				if (!contextStorage.getStore()) enterOrRun(contextStorage, initialContext);
+				const fn = fnFactory(createTraceContext(span));
+				const argsAttributes = {
+					...captureInputAttrs(args, options.captureInput),
+					...options.attributesFromArgs ? options.attributesFromArgs(args) : {}
+				};
+				const handleTailSampling = (success, duration, error) => {
+					if (needsTailSampling && "shouldKeepTrace" in sampler && typeof sampler.shouldKeepTrace === "function") {
+						shouldKeepSpan = sampler.shouldKeepTrace(samplingContext, {
+							success,
+							duration,
+							error
+						});
+						span.setAttribute(AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
+						span.setAttribute(AUTOTEL_SAMPLING_TAIL_EVALUATED, true);
+					}
+				};
+				const onSuccess = async (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();
+					await flushIfNeeded();
+					return result;
+				};
+				const onError = async (error) => {
+					const duration = performance.now() - startTime;
+					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({
+						...argsAttributes,
+						"operation.name": spanName,
+						"code.function": spanName,
+						"operation.duration": duration,
+						"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));
+					span.recordException(error instanceof Error ? error : new Error(String(error)));
+					handleTailSampling(false, duration, error);
+					span.end();
+					await flushIfNeeded();
+					throw error;
+				};
+				try {
+					callCounter?.add(1, {
+						operation: spanName,
+						status: "started"
+					});
+					const executeWithContext = async () => {
+						const currentContext = getActiveContextWithBaggage();
+						return context.with(currentContext, async () => {
+							return fn.call(this, ...args);
+						});
+					};
+					return await onSuccess(await executeWithContext());
+				} catch (error) {
+					await onError(error);
+					throw error;
+				}
+			});
+		});
+	};
+	wrappedFunction[INSTRUMENTED_SYMBOL] = true;
+	Object.defineProperty(wrappedFunction, "name", {
+		value: tempFn.name || "trace",
+		configurable: true
+	});
+	return wrappedFunction;
+}
+/**
+* Core tracing wrapper for sync functions (internal implementation)
+*/
+function wrapWithTracingSync(fnFactory, options, variableName) {
+	if (hasInstrumentationFlag(fnFactory)) {}
+	const config = getConfig$1();
+	const tracer = config.tracer;
+	const meter = config.meter;
+	const sampler = options.sampler || new AlwaysSampler();
+	const tempFn = fnFactory(createDummyCtx());
+	const spanName = getSpanName(options, tempFn, 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 needsTailSampling = "needsTailSampling" in sampler && typeof sampler.needsTailSampling === "function" ? sampler.needsTailSampling() : false;
+		if (!shouldSample && !needsTailSampling) return fnFactory(createDummyCtx()).call(this, ...args);
+		const startTime = performance.now();
+		const isRootSpan = options.startNewRoot || trace.getActiveSpan() === void 0;
+		const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig()?.flushOnRootSpanEnd ?? true;
+		const shouldAutoFlushSpans = getConfig()?.forceFlushOnShutdown ?? false;
+		const flushIfNeeded = () => {
+			if (!shouldAutoFlush || !isRootSpan) return;
+			const queue = getEventQueue();
+			if (queue && queue.size() > 0) queue.flush().catch((error) => {
+				const logger = getConfig()?.logger;
+				if (logger?.error) logger.error({ err: error instanceof Error ? error : void 0 }, `[autotel] Auto-flush failed${error instanceof Error ? "" : `: ${String(error)}`}`);
+			});
+			if (shouldAutoFlushSpans) {
+				const sdk = getSdk();
+				if (sdk) try {
+					const sdkAny = sdk;
+					if (typeof sdkAny.getTracerProvider === "function") {
+						const tracerProvider = sdkAny.getTracerProvider();
+						if (tracerProvider && typeof tracerProvider.forceFlush === "function") tracerProvider.forceFlush().catch((error) => {
+							const logger = getConfig()?.logger;
+							if (logger?.error) logger.error({ err: error instanceof Error ? error : void 0 }, `[autotel] Span flush failed${error instanceof Error ? "" : `: ${String(error)}`}`);
+						});
+					}
+				} catch {}
+			}
+		};
+		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, () => {
+				let shouldKeepSpan = true;
+				setSpanName(span, spanName);
+				const fn = fnFactory(createTraceContext(span));
+				const argsAttributes = {
+					...captureInputAttrs(args, options.captureInput),
+					...options.attributesFromArgs ? options.attributesFromArgs(args) : {}
+				};
+				const handleTailSampling = (success, duration, error) => {
+					if (needsTailSampling && "shouldKeepTrace" in sampler && typeof sampler.shouldKeepTrace === "function") {
+						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();
+					flushIfNeeded();
+					return result;
+				};
+				const onError = (error) => {
+					const duration = performance.now() - startTime;
+					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({
+						...argsAttributes,
+						"operation.name": spanName,
+						"code.function": spanName,
+						"operation.duration": duration,
+						"operation.success": false,
+						error: true,
+						"exception.type": error instanceof Error ? error.constructor.name : "Error",
+						"exception.message": truncatedMessage
+					});
+					span.recordException(error instanceof Error ? error : new Error(String(error)));
+					handleTailSampling(false, duration, error);
+					span.end();
+					flushIfNeeded();
+					throw error;
+				};
+				try {
+					callCounter?.add(1, {
+						operation: spanName,
+						status: "started"
+					});
+					const result = fn.call(this, ...args);
+					if (result instanceof Promise) return result.then(onSuccess, onError);
+					return onSuccess(result);
+				} catch (error) {
+					return onError(error);
+				}
+			});
+		});
+	}
+	wrappedFunction[INSTRUMENTED_SYMBOL] = true;
+	Object.defineProperty(wrappedFunction, "name", {
+		value: tempFn.name || "trace",
+		configurable: true
+	});
+	return wrappedFunction;
+}
+/**
+* Execute a function immediately within a trace span
+* Used for the immediate execution pattern: trace((ctx) => result)
+*/
+function executeImmediately(fn, options) {
+	const config = getConfig$1();
+	const tracer = config.tracer;
+	const meter = config.meter;
+	const sampler = options.sampler || new AlwaysSampler();
+	const spanName = options.name || "anonymous";
+	const samplingContext = {
+		operationName: spanName,
+		args: [],
+		metadata: {}
+	};
+	const shouldSample = sampler.shouldSample(samplingContext);
+	const needsTailSampling = "needsTailSampling" in sampler && typeof sampler.needsTailSampling === "function" ? sampler.needsTailSampling() : false;
+	if (!shouldSample && !needsTailSampling) return fn(createDummyCtx());
+	const startTime = performance.now();
+	const isRootSpan = options.startNewRoot || trace.getActiveSpan() === void 0;
+	const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig()?.flushOnRootSpanEnd ?? true;
+	const shouldAutoFlushSpans = getConfig()?.forceFlushOnShutdown ?? false;
+	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;
+	const flushIfNeeded = async () => {
+		if (!shouldAutoFlush || !isRootSpan) return;
+		try {
+			const queue = getEventQueue();
+			if (queue && queue.size() > 0) await queue.flush();
+			if (shouldAutoFlushSpans) {
+				const sdk = getSdk();
+				if (sdk) try {
+					const sdkAny = sdk;
+					if (typeof sdkAny.getTracerProvider === "function") {
+						const tracerProvider = sdkAny.getTracerProvider();
+						if (tracerProvider && typeof tracerProvider.forceFlush === "function") await tracerProvider.forceFlush();
+					}
+				} catch {}
+			}
+		} catch (error) {
+			const logger = getConfig()?.logger;
+			if (logger?.error) logger.error({ err: error instanceof Error ? error : void 0 }, `[autotel] Auto-flush failed${error instanceof Error ? "" : `: ${String(error)}`}`);
+		}
+	};
+	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, () => {
+			let shouldKeepSpan = true;
+			setSpanName(span, spanName);
+			const ctxValue = createTraceContext(span);
+			const handleTailSampling = (success, duration, error) => {
+				if (needsTailSampling && "shouldKeepTrace" in sampler && typeof sampler.shouldKeepTrace === "function") {
+					shouldKeepSpan = sampler.shouldKeepTrace(samplingContext, {
+						success,
+						duration,
+						error
+					});
+					span.setAttribute(AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
+					span.setAttribute(AUTOTEL_SAMPLING_TAIL_EVALUATED, true);
+				}
+			};
+			const onSuccessSync = (result) => {
+				const duration = performance.now() - startTime;
+				callCounter?.add(1, {
+					operation: spanName,
+					status: "success"
+				});
+				durationHistogram?.record(duration, {
+					operation: spanName,
+					status: "success"
+				});
+				span.setStatus({ code: SpanStatusCode.OK });
+				span.setAttributes({
+					"operation.name": spanName,
+					"code.function": spanName,
+					"operation.duration": duration,
+					"operation.success": true
+				});
+				handleTailSampling(true, duration);
+				span.end();
+				flushIfNeeded();
+				return result;
+			};
+			const onErrorSync = (error) => {
+				const duration = performance.now() - startTime;
+				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({
+					"operation.name": spanName,
+					"code.function": spanName,
+					"operation.duration": duration,
+					"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));
+				span.recordException(error instanceof Error ? error : new Error(String(error)));
+				handleTailSampling(false, duration, error);
+				span.end();
+				flushIfNeeded();
+				throw error;
+			};
+			const onSuccessAsync = async (result) => {
+				const duration = performance.now() - startTime;
+				callCounter?.add(1, {
+					operation: spanName,
+					status: "success"
+				});
+				durationHistogram?.record(duration, {
+					operation: spanName,
+					status: "success"
+				});
+				span.setStatus({ code: SpanStatusCode.OK });
+				span.setAttributes({
+					"operation.name": spanName,
+					"code.function": spanName,
+					"operation.duration": duration,
+					"operation.success": true
+				});
+				handleTailSampling(true, duration);
+				span.end();
+				await flushIfNeeded();
+				return result;
+			};
+			const onErrorAsync = async (error) => {
+				const duration = performance.now() - startTime;
+				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({
+					"operation.name": spanName,
+					"code.function": spanName,
+					"operation.duration": duration,
+					"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));
+				span.recordException(error instanceof Error ? error : new Error(String(error)));
+				handleTailSampling(false, duration, error);
+				span.end();
+				await flushIfNeeded();
+				throw error;
+			};
+			try {
+				callCounter?.add(1, {
+					operation: spanName,
+					status: "started"
+				});
+				const result = fn(ctxValue);
+				if (result instanceof Promise) return result.then(onSuccessAsync, onErrorAsync);
+				return onSuccessSync(result);
+			} catch (error) {
+				return onErrorSync(error);
+			}
+		});
+	});
+}
+function trace$1(fnOrNameOrOptions, maybeFn) {
+	if (typeof fnOrNameOrOptions === "function") {
+		if (looksLikeTraceFactory(fnOrNameOrOptions) && !isFactoryReturningFunction(fnOrNameOrOptions)) return executeImmediately(fnOrNameOrOptions, {});
+		return wrapFactoryWithTracing(fnOrNameOrOptions, {});
+	}
+	if (typeof fnOrNameOrOptions === "string") {
+		if (!maybeFn) throw new Error("trace(name, fn): fn is required");
+		if (looksLikeTraceFactory(maybeFn) && !isFactoryReturningFunction(maybeFn)) return executeImmediately(maybeFn, { name: fnOrNameOrOptions });
+		return wrapFactoryWithTracing(maybeFn, { name: fnOrNameOrOptions });
+	}
+	if (!maybeFn) throw new Error("trace(options, fn): fn is required");
+	if (looksLikeTraceFactory(maybeFn) && !isFactoryReturningFunction(maybeFn)) return executeImmediately(maybeFn, fnOrNameOrOptions);
+	return wrapFactoryWithTracing(maybeFn, 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 trace = withTracing({ serviceName: 'user' })
+*
+* export const createUser = trace(ctx => async (data) => { })
+* export const updateUser = trace(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);
+}
+/**
+* Approach 3: instrument() - Batch auto-instrumentation
+*
+* Instrument an entire module/object at once.
+* Closest to @Instrumented decorator pattern.
+*
+* @example Basic usage
+* ```typescript
+* export default instrument({
+*   functions: {
+*     createUser: async (data) => { },
+*     updateUser: async (id, data) => { },
+*     deleteUser: async (id) => { }
+*   },
+*   serviceName: 'user',
+*   sampler: new AdaptiveSampler()
+* })
+* // → Traced as "user.createUser", "user.updateUser", "user.deleteUser"
+* ```
+*
+* @example Per-function overrides
+* ```typescript
+* export default instrument({
+*   functions: {
+*     createUser: async (data) => { },
+*     deleteUser: async (id) => { }
+*   },
+*   serviceName: 'user',
+*   overrides: {
+*     deleteUser: {
+*       sampler: new AlwaysSampler(),
+*       withMetrics: true
+*     }
+*   }
+* })
+* ```
+*
+* @example Skip functions
+* ```typescript
+* export default instrument({
+*   functions: {
+*     createUser: async (data) => { },
+*     _internal: async () => { }, // Auto-skipped (_-prefix)
+*     deleteUser: async (id) => { }
+*   },
+*   serviceName: 'user',
+*   skip: [/^test/, (key) => key.includes('debug')]
+* })
+* ```
+*/
+function instrument(options) {
+	const { functions, ...tracingOptions } = options;
+	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$1().tracer;
+	const { name, attributes } = 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, {}, 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 trace(ctx => async () => {
+*         await processWebhookPayload(payload)
+*       })()
+*     }
+*   })
+* }
+* ```
+*/
+async function withNewContext(options) {
+	const { fn } = options;
+	return getConfig$1().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 { trace, withBaggage } from 'autotel';
+*
+* export const createOrder = trace((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 = trace((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, instrument as n, withBaggage as o, markAsImmediate as r, withNewContext as s, ctx as t };
+//# sourceMappingURL=functional-BGkT8J-h.js.map