autotel 3.6.0 → 4.0.0

package/dist/chunk-T7JO2TCP.js

@@ -1,1233 +0,0 @@
-import { setSpanName } from './chunk-HT5JQKN2.js';
-import { runInOperationContext } from './chunk-SEO6NAQT.js';
-import { createTraceContext, getActiveContextWithBaggage, getContextStorage, getEventQueue, enterOrRun } from './chunk-66YJ66GG.js';
-import { getConfig as getConfig$1, getSdk } from './chunk-ALPYR2GC.js';
-import { AlwaysSampler, AUTOTEL_SAMPLING_TAIL_KEEP, AUTOTEL_SAMPLING_TAIL_EVALUATED } from './chunk-DPSA4QLA.js';
-import { getConfig } from './chunk-J5QENANM.js';
-import { trace as trace$1, SpanStatusCode, context, propagation } from '@opentelemetry/api';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-
-var inferenceCache = /* @__PURE__ */ new Map();
-var MAX_CACHE_SIZE = 50;
-function captureStackTrace() {
-  const originalStackTraceLimit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 10;
-  const err = new Error("Stack trace capture");
-  const stack = err.stack || "";
-  Error.stackTraceLimit = originalStackTraceLimit;
-  return stack;
-}
-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)
-      };
-    }
-  }
-  return void 0;
-}
-function readSourceLine(filePath, lineNumber) {
-  try {
-    if (typeof readFileSync !== "function") {
-      return void 0;
-    }
-    const content = readFileSync(filePath, "utf8");
-    const lines = content.split("\n");
-    return lines[lineNumber - 1];
-  } catch {
-    return void 0;
-  }
-}
-function extractVariableName(sourceLine) {
-  const trimmed = sourceLine.trim();
-  const patterns = [
-    // export const varName = anyFunction(
-    /export\s+const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
-    // const varName = anyFunction(
-    /const\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
-    // export let varName = anyFunction(
-    /export\s+let\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
-    // let varName = anyFunction(
-    /let\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
-    // export var varName = anyFunction(
-    /export\s+var\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/,
-    // var varName = anyFunction(
-    /var\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*[a-zA-Z_$][a-zA-Z0-9_$]*\s*\(/
-  ];
-  for (const pattern of patterns) {
-    const match = trimmed.match(pattern);
-    if (match && match[1]) {
-      return match[1];
-    }
-  }
-  return void 0;
-}
-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);
-}
-function inferVariableNameFromCallStack() {
-  try {
-    const stack = captureStackTrace();
-    const callLocation = parseCallLocation(stack);
-    if (!callLocation) {
-      return void 0;
-    }
-    const cacheKey = `${callLocation.file}:${callLocation.line}`;
-    if (inferenceCache.has(cacheKey)) {
-      return inferenceCache.get(cacheKey);
-    }
-    const sourceLine = readSourceLine(callLocation.file, callLocation.line);
-    if (!sourceLine) {
-      return void 0;
-    }
-    const variableName = extractVariableName(sourceLine);
-    cacheInference(cacheKey, variableName);
-    return variableName;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/functional.ts
-var FACTORY_NAME_HINTS = /* @__PURE__ */ new Set([
-  "ctx",
-  "_ctx",
-  "context",
-  "tracecontext",
-  "tracectx"
-]);
-var TRACE_FACTORY_SET = /* @__PURE__ */ new WeakSet();
-var SINGLE_LINE_COMMENT_REGEX = /\/\/.*$/gm;
-var MULTI_LINE_COMMENT_REGEX = /\/\*[\s\S]*?\*\//gm;
-var 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 params = (arrowMatch[1] ?? arrowMatch[2] ?? "").split(",");
-    const first = params[0]?.trim();
-    if (first) {
-      return sanitizeParameterToken(first);
-    }
-    return null;
-  }
-  const functionMatch = source.match(/^[^(]*\(([^)]*)\)/);
-  if (functionMatch) {
-    const params = functionMatch[1]?.split(",");
-    const first = params?.[0]?.trim();
-    if (first) {
-      return sanitizeParameterToken(first);
-    }
-  }
-  return null;
-}
-var IMMEDIATE_EXECUTION_SYMBOL = /* @__PURE__ */ Symbol.for("autotel.immediate-execution");
-function hasImmediateExecutionMark(fn) {
-  return typeof fn === "function" && fn[IMMEDIATE_EXECUTION_SYMBOL] === true;
-}
-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 {
-        const result = fn();
-        return typeof result === "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") || // Match baseCtx, spanCtx, etc.
-  normalized.includes("context")) {
-    return true;
-  }
-  return false;
-}
-function isFactoryReturningFunction(fnWithCtx) {
-  if (isAsyncFunction(fnWithCtx)) {
-    return false;
-  }
-  try {
-    const result = fnWithCtx(createDummyCtx());
-    return typeof result === "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 = (ctx2) => {
-    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;
-  const useAsyncWrapper = isAsyncFunction(sampleFn);
-  if (useAsyncWrapper) {
-    return wrapWithTracing(
-      factory,
-      options,
-      effectiveVariableName
-    );
-  }
-  return wrapWithTracingSync(
-    factory,
-    options,
-    effectiveVariableName
-  );
-}
-var 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()
-  };
-}
-var AUTOTEL_INPUT_ATTR = "autotel.input";
-var AUTOTEL_OUTPUT_ATTR = "autotel.output";
-var CAPTURE_MAX_CHARS = 4096;
-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)}\u2026[truncated]` : json;
-  } catch {
-    return void 0;
-  }
-}
-function captureInputAttrs(args, enabled) {
-  if (!enabled) return {};
-  const s = serializeCapture(args.length === 1 ? args[0] : args);
-  return s === void 0 ? {} : { [AUTOTEL_INPUT_ATTR]: s };
-}
-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";
-}
-var INSTRUMENTED_SYMBOL = /* @__PURE__ */ Symbol.for("autotel.functional.instrumented");
-function hasInstrumentationFlag(value) {
-  return (typeof value === "function" || typeof value === "object") && value !== null && Boolean(value[INSTRUMENTED_SYMBOL]);
-}
-function truncateErrorMessage(message) {
-  if (message.length <= MAX_ERROR_MESSAGE_LENGTH) {
-    return message;
-  }
-  return `${message.slice(0, MAX_ERROR_MESSAGE_LENGTH)}... (truncated)`;
-}
-function inferFunctionName(fn) {
-  const displayName = fn.displayName;
-  if (displayName) {
-    return displayName;
-  }
-  if (fn.name && fn.name !== "anonymous" && fn.name !== "") {
-    return fn.name;
-  }
-  const source = Function.prototype.toString.call(fn);
-  const match = source.match(/function\s+([^(\s]+)/);
-  if (match && match[1] && match[1] !== "anonymous") {
-    return match[1];
-  }
-  return void 0;
-}
-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";
-}
-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;
-}
-function getCtxValue() {
-  const activeSpan = trace$1.getActiveSpan();
-  if (!activeSpan) return null;
-  return createTraceContext(activeSpan);
-}
-var 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);
-    }
-  }
-);
-function wrapWithTracing(fnFactory, options, variableName) {
-  if (hasInstrumentationFlag(fnFactory)) ;
-  const config = getConfig();
-  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 wrappedFunction2(...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) {
-      const fn = fnFactory(createDummyCtx());
-      return await fn.call(this, ...args);
-    }
-    const startTime = performance.now();
-    const isRootSpan = options.startNewRoot || trace$1.getActiveSpan() === void 0;
-    const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig$1()?.flushOnRootSpanEnd ?? true;
-    const shouldAutoFlushSpans = getConfig$1()?.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 initConfig = getConfig$1();
-        const logger = initConfig?.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 (span2) => {
-        return runInOperationContext(spanName, async () => {
-          let shouldKeepSpan = true;
-          setSpanName(span2, spanName);
-          const initialContext = context.active();
-          const contextStorage = getContextStorage();
-          if (!contextStorage.getStore()) {
-            enterOrRun(contextStorage, initialContext);
-          }
-          const ctxValue = createTraceContext(span2);
-          const fn = fnFactory(ctxValue);
-          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
-              });
-              span2.setAttribute(AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
-              span2.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) : {}
-            };
-            span2.setStatus({ code: SpanStatusCode.OK });
-            span2.setAttributes({
-              ...argsAttributes,
-              ...resultAttributes,
-              "operation.name": spanName,
-              "code.function": spanName,
-              "operation.duration": duration,
-              "operation.success": true
-            });
-            handleTailSampling(true, duration);
-            span2.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 errorMessage = error instanceof Error ? error.message : "Unknown error";
-            const truncatedMessage = truncateErrorMessage(errorMessage);
-            span2.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: truncatedMessage
-            });
-            span2.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) {
-              span2.setAttribute(
-                "exception.stack",
-                error.stack.slice(0, MAX_ERROR_MESSAGE_LENGTH)
-              );
-            }
-            span2.recordException(
-              error instanceof Error ? error : new Error(String(error))
-            );
-            handleTailSampling(false, duration, error);
-            span2.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);
-              });
-            };
-            const result = await executeWithContext();
-            return await onSuccess(result);
-          } catch (error) {
-            await onError(error);
-            throw error;
-          }
-        });
-      }
-    );
-  };
-  wrappedFunction[INSTRUMENTED_SYMBOL] = true;
-  Object.defineProperty(wrappedFunction, "name", {
-    value: tempFn.name || "trace",
-    configurable: true
-  });
-  return wrappedFunction;
-}
-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 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) {
-      const fn = fnFactory(createDummyCtx());
-      return fn.call(this, ...args);
-    }
-    const startTime = performance.now();
-    const isRootSpan = options.startNewRoot || trace$1.getActiveSpan() === void 0;
-    const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig$1()?.flushOnRootSpanEnd ?? true;
-    const shouldAutoFlushSpans = getConfig$1()?.forceFlushOnShutdown ?? false;
-    const flushIfNeeded = () => {
-      if (!shouldAutoFlush || !isRootSpan) return;
-      const queue = getEventQueue();
-      if (queue && queue.size() > 0) {
-        void queue.flush().catch((error) => {
-          const initConfig = getConfig$1();
-          const logger = initConfig?.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") {
-                void tracerProvider.forceFlush().catch((error) => {
-                  const initConfig = getConfig$1();
-                  const logger = initConfig?.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,
-      (span2) => {
-        return runInOperationContext(spanName, () => {
-          let shouldKeepSpan = true;
-          setSpanName(span2, spanName);
-          const ctxValue = createTraceContext(span2);
-          const fn = fnFactory(ctxValue);
-          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
-              });
-              span2.setAttribute(AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
-              span2.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) : {}
-            };
-            span2.setStatus({ code: SpanStatusCode.OK });
-            span2.setAttributes({
-              ...argsAttributes,
-              ...resultAttributes,
-              "operation.name": spanName,
-              "code.function": spanName,
-              "operation.duration": duration,
-              "operation.success": true
-            });
-            handleTailSampling(true, duration);
-            span2.end();
-            void 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 errorMessage = error instanceof Error ? error.message : "Unknown error";
-            const truncatedMessage = truncateErrorMessage(errorMessage);
-            span2.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: truncatedMessage
-            });
-            span2.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
-            });
-            span2.recordException(
-              error instanceof Error ? error : new Error(String(error))
-            );
-            handleTailSampling(false, duration, error);
-            span2.end();
-            void 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;
-}
-function executeImmediately(fn, options) {
-  const config = getConfig();
-  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$1.getActiveSpan() === void 0;
-  const shouldAutoFlush = options.flushOnRootSpanEnd ?? getConfig$1()?.flushOnRootSpanEnd ?? true;
-  const shouldAutoFlushSpans = getConfig$1()?.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 initConfig = getConfig$1();
-      const logger = initConfig?.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,
-    (span2) => {
-      return runInOperationContext(spanName, () => {
-        let shouldKeepSpan = true;
-        setSpanName(span2, spanName);
-        const ctxValue = createTraceContext(span2);
-        const handleTailSampling = (success, duration, error) => {
-          if (needsTailSampling && "shouldKeepTrace" in sampler && typeof sampler.shouldKeepTrace === "function") {
-            shouldKeepSpan = sampler.shouldKeepTrace(samplingContext, {
-              success,
-              duration,
-              error
-            });
-            span2.setAttribute(AUTOTEL_SAMPLING_TAIL_KEEP, shouldKeepSpan);
-            span2.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"
-          });
-          span2.setStatus({ code: SpanStatusCode.OK });
-          span2.setAttributes({
-            "operation.name": spanName,
-            "code.function": spanName,
-            "operation.duration": duration,
-            "operation.success": true
-          });
-          handleTailSampling(true, duration);
-          span2.end();
-          void 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 errorMessage = error instanceof Error ? error.message : "Unknown error";
-          const truncatedMessage = truncateErrorMessage(errorMessage);
-          span2.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: truncatedMessage
-          });
-          span2.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) {
-            span2.setAttribute(
-              "exception.stack",
-              error.stack.slice(0, MAX_ERROR_MESSAGE_LENGTH)
-            );
-          }
-          span2.recordException(
-            error instanceof Error ? error : new Error(String(error))
-          );
-          handleTailSampling(false, duration, error);
-          span2.end();
-          void 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"
-          });
-          span2.setStatus({ code: SpanStatusCode.OK });
-          span2.setAttributes({
-            "operation.name": spanName,
-            "code.function": spanName,
-            "operation.duration": duration,
-            "operation.success": true
-          });
-          handleTailSampling(true, duration);
-          span2.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 errorMessage = error instanceof Error ? error.message : "Unknown error";
-          const truncatedMessage = truncateErrorMessage(errorMessage);
-          span2.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: truncatedMessage
-          });
-          span2.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) {
-            span2.setAttribute(
-              "exception.stack",
-              error.stack.slice(0, MAX_ERROR_MESSAGE_LENGTH)
-            );
-          }
-          span2.recordException(
-            error instanceof Error ? error : new Error(String(error))
-          );
-          handleTailSampling(false, duration, error);
-          span2.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(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
-  );
-}
-function withTracing(options = {}) {
-  return (fnFactory) => wrapFactoryWithTracing(fnFactory, options);
-}
-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],
-      // If no explicit name, use key as function name
-      name: tracingOptions.overrides?.[key]?.name
-    };
-    const boundFn = fn.bind(functions);
-    const fnFactory = (ctx2) => {
-      return boundFn;
-    };
-    instrumented[typedKey] = wrapFactoryWithTracing(
-      fnFactory,
-      fnOptions,
-      key
-    );
-  }
-  return instrumented;
-}
-function span(nameOrOptions, fn) {
-  const options = typeof nameOrOptions === "string" ? { name: nameOrOptions } : nameOrOptions;
-  const config = getConfig();
-  const tracer = config.tracer;
-  const { name, attributes } = options;
-  const executeSpan = (span2) => {
-    return runInOperationContext(name, () => {
-      try {
-        if (attributes) {
-          for (const [key, value] of Object.entries(attributes)) {
-            span2.setAttribute(key, value);
-          }
-        }
-        const result2 = fn(span2);
-        if (result2 instanceof Promise) {
-          return result2.then((resolved) => {
-            span2.setStatus({ code: SpanStatusCode.OK });
-            span2.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);
-            span2.setAttribute("error.message", errorMessage);
-            span2.setStatus({
-              code: SpanStatusCode.ERROR,
-              message: errorMessage
-            });
-            span2.recordException(
-              error instanceof Error ? error : new Error(String(error))
-            );
-            span2.end();
-            throw error;
-          });
-        } else {
-          span2.setStatus({ code: SpanStatusCode.OK });
-          span2.end();
-          return result2;
-        }
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message.slice(0, MAX_ERROR_MESSAGE_LENGTH) : String(error).slice(0, MAX_ERROR_MESSAGE_LENGTH);
-        span2.setAttribute("error.message", errorMessage);
-        span2.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: errorMessage
-        });
-        span2.recordException(
-          error instanceof Error ? error : new Error(String(error))
-        );
-        span2.end();
-        throw error;
-      }
-    });
-  };
-  const parentContext = getActiveContextWithBaggage();
-  const result = tracer.startActiveSpan(name, {}, parentContext, executeSpan);
-  if (result instanceof Promise) {
-    return result;
-  }
-  return result;
-}
-async function withNewContext(options) {
-  const { fn } = options;
-  const config = getConfig();
-  const tracer = config.tracer;
-  return tracer.startActiveSpan("root", { root: true }, async (span2) => {
-    try {
-      const result = await fn();
-      span2.setStatus({ code: SpanStatusCode.OK });
-      return result;
-    } catch (error) {
-      span2.recordException(
-        error instanceof Error ? error : new Error(String(error))
-      );
-      span2.setStatus({ code: SpanStatusCode.ERROR });
-      throw error;
-    } finally {
-      span2.end();
-    }
-  });
-}
-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;
-}
-
-export { ctx, instrument, markAsImmediate, span, trace, withBaggage, withNewContext, withTracing };
-//# sourceMappingURL=chunk-T7JO2TCP.js.map
-//# sourceMappingURL=chunk-T7JO2TCP.js.map