autotel 6.2.1 → 6.4.0

package/dist/{functional-CogDARqC.cjs → functional-BEEhlVKD.cjs}

@@ -2,7 +2,7 @@ const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
 const require_tracer_provider = require('./tracer-provider.cjs');
 const require_config = require('./config.cjs');
 const require_sampling = require('./sampling.cjs');
-const require_init = require('./init-BzVuFs5a.cjs');
+const require_init = require('./init-C5V4z7S5.cjs');
 const require_trace_helpers = require('./trace-helpers.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 let node_fs = require("node:fs");
@@ -37,6 +37,11 @@ function captureStackTrace() {
 	Error.stackTraceLimit = originalStackTraceLimit;
 	return stack;
 }
+const INTERNAL_FRAME = new RegExp(String.raw`(?:${[
+	"variable-name-inference",
+	"functional",
+	"functional-wrapper"
+].join("|")})\.(?:ts|js)`);
 /**
 * Parses the stack trace to find where trace() was called
 *
@@ -44,7 +49,7 @@ function captureStackTrace() {
 *   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 skip frames until we find one that's not in the functional API internals.
 * We also need to skip one additional frame (the trace/span/instrument function itself)
 * to get to the actual user code.
 */
@@ -52,7 +57,7 @@ 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;
+		if (INTERNAL_FRAME.test(line)) continue;
 		const match = line.match(/at\s+(?:.*\s+)?\(?([^:]+):(\d+):(\d+)\)?/) || line.match(/^.*?([^:]+):(\d+):(\d+)/);
 		if (match) {
 			let filePath = match[1].trim();
@@ -150,68 +155,35 @@ function inferVariableNameFromCallStack() {
 }
 
 //#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' })
-* ```
-*/
+//#region src/functional-wrapper.ts
+const FUNCTIONAL_ERROR_MESSAGE_LIMIT = 500;
+const AUTOTEL_INPUT_ATTR = "autotel.input";
+const AUTOTEL_OUTPUT_ATTR = "autotel.output";
+const CAPTURE_MAX_CHARS = 4096;
 let unknownSpanNameWarningEmitted = false;
+function inferFunctionName(fn) {
+	if (fn.displayName) return fn.displayName;
+	if (fn.name && fn.name !== "anonymous") return fn.name;
+	const match = Function.prototype.toString.call(fn).match(/function\s+([^(\s]+)/);
+	return match?.[1] && match[1] !== "anonymous" ? match[1] : void 0;
+}
 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);
+function getSpanName(options, fn, variableName) {
+	if (options.name) return options.name;
+	const fnName = variableName || inferFunctionName(fn) || "anonymous";
+	if (options.serviceName) return `${options.serviceName}.${fnName}`;
+	if (fnName !== "anonymous") return fnName;
+	const initConfig = require_init.getConfig();
+	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";
 }
-const MAX_ERROR_MESSAGE_LENGTH = 500;
 function createDummyCtx() {
 	return {
 		traceId: "",
@@ -232,11 +204,6 @@ function createDummyCtx() {
 		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 {
@@ -247,41 +214,21 @@ function serializeCapture(value) {
 		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 };
+	const serialized = serializeCapture(args.length === 1 ? args[0] : args);
+	return serialized === void 0 ? {} : { [AUTOTEL_INPUT_ATTR]: serialized };
 }
-/** `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]);
+	const serialized = serializeCapture(result);
+	return serialized === void 0 ? {} : { [AUTOTEL_OUTPUT_ATTR]: serialized };
 }
-/**
-* 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)`;
+	return message.length <= 500 ? message : `${message.slice(0, 500)}... (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;
+function finalizeThrownSpan(error, isError, finalizeContext) {
+	const { span, spanName, duration, callCounter, durationHistogram, handleTailSampling, extraAttributes } = finalizeContext;
 	const baseAttributes = {
 		...extraAttributes,
 		"operation.name": spanName,
@@ -326,45 +273,197 @@ function finalizeThrownSpan(error, isError, ctx) {
 		"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));
+	if (error instanceof Error && error.stack) span.setAttribute("exception.stack", error.stack.slice(0, 500));
 	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;
+function createRootTelemetryFlusher(options, isRootSpan) {
 	const initConfig = require_init.getConfig();
-	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).");
+	const shouldFlush = options.flushOnRootSpanEnd ?? initConfig?.flushOnRootSpanEnd ?? true;
+	const shouldFlushSpans = initConfig?.forceFlushOnShutdown ?? false;
+	return async () => {
+		if (!shouldFlush || !isRootSpan) return;
+		try {
+			const queue = require_init.getEventQueue();
+			if (queue && queue.size() > 0) await queue.flush();
+			if (shouldFlushSpans) await require_tracer_provider.getForceFlushableProvider(require_init.getSdk())?.forceFlush();
+		} catch (error) {
+			require_init.getConfig()?.logger?.error?.({ err: error instanceof Error ? error : void 0 }, `[autotel] Auto-flush failed${error instanceof Error ? "" : `: ${String(error)}`}`);
+		}
+	};
+}
+function runWithTraceContextStorage(fn) {
+	const storage = require_init.getContextStorage();
+	if (storage.getStore()) return fn();
+	return storage.run({ value: _opentelemetry_api.context.active() }, fn);
+}
+function wrapWithTracingSync(fnFactory, options, variableName) {
+	const { tracer, meter } = require_config.getConfig();
+	const sampler = options.sampler || new require_sampling.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 || _opentelemetry_api.trace.getActiveSpan() === void 0);
+		const spanOptions = {};
+		if (options.startNewRoot) spanOptions.root = true;
+		if (options.spanKind !== void 0) spanOptions.kind = options.spanKind;
+		return tracer.startActiveSpan(spanName, spanOptions, require_init.getActiveContextWithBaggage(), (span) => require_init.runInOperationContext(spanName, () => runWithTraceContextStorage(() => {
+			let shouldKeepSpan = true;
+			require_trace_helpers.setSpanName(span, spanName);
+			if (sampleRate !== void 0 && sampleRate > 1) span.setAttribute(require_sampling.AUTOTEL_SAMPLING_RATE, sampleRate);
+			const fn = fnFactory(require_init.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(require_sampling.AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
+					span.setAttribute(require_sampling.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: _opentelemetry_api.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 = _opentelemetry_api.context.with(_opentelemetry_api.trace.setSpan(require_init.getActiveContextWithBaggage(), span), () => 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();
+				}
+			}
+		})));
 	}
-	return "unknown";
+	Object.defineProperty(wrappedFunction, "name", {
+		value: variableName || "trace",
+		configurable: true
+	});
+	return wrappedFunction;
 }
+/** Wrap an explicit `(ctx) => (...args) => result` context factory. */
+function wrapFactoryWithTracing(factory, options, variableName) {
+	return wrapWithTracingSync(factory, options, resolveVariableName(factory, variableName));
+}
+/** Wrap a plain function without injecting a context argument. */
+function wrapPlainWithTracing(fn, options, variableName) {
+	return wrapWithTracingSync((_ctx) => fn, options, resolveVariableName(fn, variableName));
+}
+
+//#endregion
+//#region src/functional.ts
 /**
-* Check if function should be skipped
+* 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' })
+* ```
 */
 function shouldSkip(key, fn, skip) {
 	if (key.startsWith("_")) return true;
@@ -446,167 +545,6 @@ const ctx = new Proxy({}, {
 		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 = require_init.getConfig();
-	const shouldFlush = options.flushOnRootSpanEnd ?? initConfig?.flushOnRootSpanEnd ?? true;
-	const shouldFlushSpans = initConfig?.forceFlushOnShutdown ?? false;
-	return async () => {
-		if (!shouldFlush || !isRootSpan) return;
-		try {
-			const queue = require_init.getEventQueue();
-			if (queue && queue.size() > 0) await queue.flush();
-			if (shouldFlushSpans) await require_tracer_provider.getForceFlushableProvider(require_init.getSdk())?.forceFlush();
-		} catch (error) {
-			(require_init.getConfig()?.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 = require_init.getContextStorage();
-	if (storage.getStore()) return fn();
-	return storage.run({ value: _opentelemetry_api.context.active() }, fn);
-}
-/**
-* Core tracing wrapper for sync functions (internal implementation)
-*/
-function wrapWithTracingSync(fnFactory, options, variableName) {
-	if (hasInstrumentationFlag(fnFactory)) {}
-	const config = require_config.getConfig();
-	const tracer = config.tracer;
-	const meter = config.meter;
-	const sampler = options.sampler || new require_sampling.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 || _opentelemetry_api.trace.getActiveSpan() === void 0);
-		const spanOptions = {};
-		if (options.startNewRoot) spanOptions.root = true;
-		if (options.spanKind !== void 0) spanOptions.kind = options.spanKind;
-		const parentContext = require_init.getActiveContextWithBaggage();
-		return tracer.startActiveSpan(spanName, spanOptions, parentContext, (span) => {
-			return require_init.runInOperationContext(spanName, () => runWithTraceContextStorage(() => {
-				let shouldKeepSpan = true;
-				require_trace_helpers.setSpanName(span, spanName);
-				if (sampleRate !== void 0 && sampleRate > 1) span.setAttribute(require_sampling.AUTOTEL_SAMPLING_RATE, sampleRate);
-				const fn = fnFactory(require_init.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(require_sampling.AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
-						span.setAttribute(require_sampling.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: _opentelemetry_api.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 = _opentelemetry_api.context.with(require_init.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(fnOrNameOrOptions, maybeFn) {
 	if (typeof fnOrNameOrOptions === "function") return wrapPlainWithTracing(fnOrNameOrOptions, {});
 	if (!maybeFn) throw new Error("trace(name|options, fn): fn is required");
@@ -697,7 +635,7 @@ function span(nameOrOptions, fn) {
 					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);
+					const errorMessage = error instanceof Error ? error.message.slice(0, 500) : String(error).slice(0, 500);
 					span.setAttribute("error.message", errorMessage);
 					span.setStatus({
 						code: _opentelemetry_api.SpanStatusCode.ERROR,
@@ -713,7 +651,7 @@ function span(nameOrOptions, fn) {
 					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);
+				const errorMessage = error instanceof Error ? error.message.slice(0, 500) : String(error).slice(0, 500);
 				span.setAttribute("error.message", errorMessage);
 				span.setStatus({
 					code: _opentelemetry_api.SpanStatusCode.ERROR,