autotel-edge 3.0.0

package/dist/index.js

@@ -0,0 +1,921 @@
+export { OTLPExporter, createInitialiser, getActiveConfig, parseConfig, setConfig } from './chunk-F32WSLNX.js';
+import { sanitizeAttributes, isAttributeValue, isTimeInput, hrTimeDuration } from '@opentelemetry/core';
+import { SEMATTRS_EXCEPTION_MESSAGE, SEMATTRS_EXCEPTION_TYPE, SEMATTRS_EXCEPTION_STACKTRACE } from '@opentelemetry/semantic-conventions';
+import { context, trace, ROOT_CONTEXT, SpanStatusCode } from '@opentelemetry/api';
+export { context, propagation } from '@opentelemetry/api';
+import { RandomIdGenerator, SamplingDecision } from '@opentelemetry/sdk-trace-base';
+import { AsyncLocalStorage } from 'async_hooks';
+import { EventEmitter } from 'events';
+import { Buffer } from 'buffer';
+export { Buffer } from 'buffer';
+
+function transformExceptionAttributes(exception) {
+  const attributes = {};
+  if (typeof exception === "string") {
+    attributes[SEMATTRS_EXCEPTION_MESSAGE] = exception;
+  } else {
+    if (exception.code) {
+      attributes[SEMATTRS_EXCEPTION_TYPE] = exception.code.toString();
+    } else if (exception.name) {
+      attributes[SEMATTRS_EXCEPTION_TYPE] = exception.name;
+    }
+    if (exception.message) {
+      attributes[SEMATTRS_EXCEPTION_MESSAGE] = exception.message;
+    }
+    if (exception.stack) {
+      attributes[SEMATTRS_EXCEPTION_STACKTRACE] = exception.stack;
+    }
+  }
+  return attributes;
+}
+function millisToHr(millis) {
+  return [Math.trunc(millis / 1e3), millis % 1e3 * 1e6];
+}
+function getHrTime(input) {
+  const now = Date.now();
+  if (!input) {
+    return millisToHr(now);
+  } else if (input instanceof Date) {
+    return millisToHr(input.getTime());
+  } else if (typeof input === "number") {
+    return millisToHr(input);
+  } else if (Array.isArray(input)) {
+    return input;
+  }
+  const v = input;
+  throw new Error(`unreachable value: ${JSON.stringify(v)}`);
+}
+function isAttributeKey(key) {
+  return typeof key === "string" && key.length > 0;
+}
+var SpanImpl = class {
+  name;
+  _spanContext;
+  onEnd;
+  parentSpanId;
+  parentSpanContext;
+  kind;
+  attributes;
+  status = {
+    code: 0
+    // SpanStatusCode.UNSET
+  };
+  endTime = [0, 0];
+  _duration = [0, 0];
+  startTime;
+  events = [];
+  links;
+  resource;
+  instrumentationScope = {
+    name: "autotel-edge"
+  };
+  _ended = false;
+  _droppedAttributesCount = 0;
+  _droppedEventsCount = 0;
+  _droppedLinksCount = 0;
+  constructor(init) {
+    this.name = init.name;
+    this._spanContext = init.spanContext;
+    this.parentSpanId = init.parentSpanId;
+    this.parentSpanContext = init.parentSpanContext;
+    this.kind = init.spanKind || 0;
+    this.attributes = sanitizeAttributes(init.attributes);
+    this.startTime = getHrTime(init.startTime);
+    this.links = init.links || [];
+    this.resource = init.resource;
+    this.onEnd = init.onEnd;
+  }
+  addLink(link) {
+    this.links.push(link);
+    return this;
+  }
+  addLinks(links) {
+    this.links.push(...links);
+    return this;
+  }
+  spanContext() {
+    return this._spanContext;
+  }
+  setAttribute(key, value) {
+    if (isAttributeKey(key) && isAttributeValue(value)) {
+      this.attributes[key] = value;
+    }
+    return this;
+  }
+  setAttributes(attributes) {
+    for (const [key, value] of Object.entries(attributes)) {
+      this.setAttribute(key, value);
+    }
+    return this;
+  }
+  addEvent(name, attributesOrStartTime, startTime) {
+    if (isTimeInput(attributesOrStartTime)) {
+      startTime = attributesOrStartTime;
+      attributesOrStartTime = void 0;
+    }
+    const attributes = sanitizeAttributes(attributesOrStartTime);
+    const time = getHrTime(startTime);
+    this.events.push({ name, attributes, time });
+    return this;
+  }
+  setStatus(status) {
+    this.status = status;
+    return this;
+  }
+  updateName(name) {
+    this.name = name;
+    return this;
+  }
+  end(endTime) {
+    if (this._ended) {
+      return;
+    }
+    this._ended = true;
+    this.endTime = getHrTime(endTime);
+    this._duration = hrTimeDuration(this.startTime, this.endTime);
+    this.onEnd(this);
+  }
+  isRecording() {
+    return !this._ended;
+  }
+  recordException(exception, time) {
+    const attributes = transformExceptionAttributes(exception);
+    this.addEvent("exception", attributes, time);
+  }
+  get duration() {
+    return this._duration;
+  }
+  get ended() {
+    return this._ended;
+  }
+  get droppedAttributesCount() {
+    return this._droppedAttributesCount;
+  }
+  get droppedEventsCount() {
+    return this._droppedEventsCount;
+  }
+  get droppedLinksCount() {
+    return this._droppedLinksCount;
+  }
+};
+var NewTraceFlags = {
+  RANDOM_TRACE_ID_SET: 2};
+var idGenerator = new RandomIdGenerator();
+var withNextSpanAttributes;
+function getFlagAt(flagSequence, position) {
+  return (flagSequence >> position - 1 & 1) * position;
+}
+var WorkerTracer = class {
+  spanProcessors;
+  resource;
+  headSampler;
+  // Will be set via setHeadSampler
+  constructor(spanProcessors, resource) {
+    this.spanProcessors = spanProcessors;
+    this.resource = resource;
+  }
+  /**
+   * Set the head sampler (called from config)
+   */
+  setHeadSampler(sampler) {
+    this.headSampler = sampler;
+  }
+  /**
+   * Force flush spans for a specific trace
+   */
+  async forceFlush(traceId) {
+    const promises = this.spanProcessors.map(async (spanProcessor) => {
+      await spanProcessor.forceFlush(traceId);
+    });
+    await Promise.allSettled(promises);
+  }
+  /**
+   * Add extra resource attributes
+   */
+  addToResource(extra) {
+    this.resource.merge(extra);
+  }
+  /**
+   * Start a new span
+   */
+  startSpan(name, options = {}, context2 = context.active()) {
+    if (options.root) {
+      context2 = trace.deleteSpan(context2);
+    }
+    if (!this.headSampler) {
+      throw new Error(
+        "Head sampler not configured. This is a bug in the instrumentation logic"
+      );
+    }
+    const parentSpanContext = trace.getSpan(context2)?.spanContext();
+    const { traceId, randomTraceFlag } = getTraceInfo(parentSpanContext);
+    const spanKind = options.kind || 0;
+    const sanitisedAttrs = sanitizeAttributes(options.attributes);
+    const optionsWithSampler = options;
+    const sampler = optionsWithSampler.sampler || this.headSampler;
+    const samplingDecision = sampler.shouldSample(
+      context2,
+      traceId,
+      name,
+      spanKind,
+      sanitisedAttrs,
+      []
+    );
+    const { decision, traceState, attributes: attrs } = samplingDecision;
+    const attributes = Object.assign(
+      {},
+      options.attributes,
+      attrs,
+      withNextSpanAttributes
+    );
+    withNextSpanAttributes = {};
+    const spanId = idGenerator.generateSpanId();
+    const parentSpanId = parentSpanContext?.spanId;
+    const sampleFlag = decision === SamplingDecision.RECORD_AND_SAMPLED ? 1 : 0;
+    const traceFlags = sampleFlag + randomTraceFlag;
+    const spanContext = { traceId, spanId, traceFlags, traceState };
+    const span2 = new SpanImpl({
+      attributes: sanitizeAttributes(attributes),
+      name,
+      onEnd: (span3) => {
+        for (const sp of this.spanProcessors) {
+          sp.onEnd(span3);
+        }
+      },
+      resource: this.resource,
+      spanContext,
+      parentSpanContext,
+      parentSpanId,
+      spanKind,
+      startTime: options.startTime
+    });
+    for (const sp of this.spanProcessors) {
+      sp.onStart(span2, context2);
+    }
+    return span2;
+  }
+  startActiveSpan(name, ...args) {
+    const options = args.length > 1 ? args[0] : void 0;
+    const parentContext = args.length > 2 ? args[1] : context.active();
+    const fn = args.at(-1);
+    const span2 = this.startSpan(name, options, parentContext);
+    const contextWithSpanSet = trace.setSpan(parentContext, span2);
+    return context.with(contextWithSpanSet, fn, void 0, span2);
+  }
+};
+function withNextSpan(attrs) {
+  withNextSpanAttributes = Object.assign({}, withNextSpanAttributes, attrs);
+}
+function getTraceInfo(parentSpanContext) {
+  if (parentSpanContext && trace.isSpanContextValid(parentSpanContext)) {
+    const { traceId, traceFlags } = parentSpanContext;
+    return { traceId, randomTraceFlag: getFlagAt(traceFlags, 2) };
+  } else {
+    return {
+      traceId: idGenerator.generateTraceId(),
+      randomTraceFlag: NewTraceFlags.RANDOM_TRACE_ID_SET
+    };
+  }
+}
+var ADD_LISTENER_METHODS = [
+  "addListener",
+  "on",
+  "once",
+  "prependListener",
+  "prependOnceListener"
+];
+var AbstractAsyncHooksContextManager = class {
+  /**
+   * Binds a context to the target function or event emitter
+   */
+  bind(context2, target) {
+    if (target instanceof EventEmitter) {
+      return this._bindEventEmitter(context2, target);
+    }
+    if (typeof target === "function") {
+      return this._bindFunction(context2, target);
+    }
+    return target;
+  }
+  _bindFunction(context2, target) {
+    const manager = this;
+    const contextWrapper = function(...args) {
+      return manager.with(context2, () => target.apply(this, args));
+    };
+    Object.defineProperty(contextWrapper, "length", {
+      enumerable: false,
+      configurable: true,
+      writable: false,
+      value: target.length
+    });
+    return contextWrapper;
+  }
+  /**
+   * By default, EventEmitter calls callbacks with their context, which we do
+   * not want. Instead we bind a specific context to all callbacks.
+   */
+  _bindEventEmitter(context2, ee) {
+    const map = this._getPatchMap(ee);
+    if (map !== void 0) return ee;
+    this._createPatchMap(ee);
+    for (const methodName of ADD_LISTENER_METHODS) {
+      if (ee[methodName] === void 0) continue;
+      ee[methodName] = this._patchAddListener(ee, ee[methodName], context2);
+    }
+    if (typeof ee.removeListener === "function") {
+      ee.removeListener = this._patchRemoveListener(ee, ee.removeListener);
+    }
+    if (typeof ee.off === "function") {
+      ee.off = this._patchRemoveListener(ee, ee.off);
+    }
+    if (typeof ee.removeAllListeners === "function") {
+      ee.removeAllListeners = this._patchRemoveAllListeners(
+        ee,
+        ee.removeAllListeners
+      );
+    }
+    return ee;
+  }
+  _patchRemoveListener(ee, original) {
+    const contextManager = this;
+    return function(event, listener) {
+      const events = contextManager._getPatchMap(ee)?.[event];
+      if (events === void 0) {
+        return original.call(this, event, listener);
+      }
+      const patchedListener = events.get(listener);
+      return original.call(this, event, patchedListener || listener);
+    };
+  }
+  _patchRemoveAllListeners(ee, original) {
+    const contextManager = this;
+    return function(event) {
+      const map = contextManager._getPatchMap(ee);
+      if (map !== void 0) {
+        if (arguments.length === 0) {
+          contextManager._createPatchMap(ee);
+        } else if (map[event] !== void 0) {
+          delete map[event];
+        }
+      }
+      return Reflect.apply(original, this, arguments);
+    };
+  }
+  _patchAddListener(ee, original, context2) {
+    const contextManager = this;
+    return function(event, listener) {
+      if (contextManager._wrapped) {
+        return original.call(this, event, listener);
+      }
+      let map = contextManager._getPatchMap(ee);
+      if (map === void 0) {
+        map = contextManager._createPatchMap(ee);
+      }
+      let listeners = map[event];
+      if (listeners === void 0) {
+        listeners = /* @__PURE__ */ new WeakMap();
+        map[event] = listeners;
+      }
+      const patchedListener = contextManager.bind(context2, listener);
+      listeners.set(listener, patchedListener);
+      contextManager._wrapped = true;
+      try {
+        return original.call(this, event, patchedListener);
+      } finally {
+        contextManager._wrapped = false;
+      }
+    };
+  }
+  _createPatchMap(ee) {
+    const map = /* @__PURE__ */ Object.create(null);
+    ee[this._kOtListeners] = map;
+    return map;
+  }
+  _getPatchMap(ee) {
+    return ee[this._kOtListeners];
+  }
+  _kOtListeners = Symbol("OtListeners");
+  _wrapped = false;
+};
+var AsyncLocalStorageContextManager = class extends AbstractAsyncHooksContextManager {
+  _asyncLocalStorage;
+  constructor() {
+    super();
+    this._asyncLocalStorage = new AsyncLocalStorage();
+  }
+  active() {
+    return this._asyncLocalStorage.getStore() ?? ROOT_CONTEXT;
+  }
+  with(context2, fn, thisArg, ...args) {
+    const cb = thisArg == null ? fn : fn.bind(thisArg);
+    return this._asyncLocalStorage.run(context2, cb, ...args);
+  }
+  enable() {
+    return this;
+  }
+  disable() {
+    this._asyncLocalStorage.disable();
+    return this;
+  }
+};
+var WorkerTracerProvider = class {
+  tracer;
+  contextManager;
+  constructor(spanProcessors, resource) {
+    this.tracer = new WorkerTracer(spanProcessors, resource);
+    this.contextManager = new AsyncLocalStorageContextManager();
+  }
+  /**
+   * Get the tracer instance
+   */
+  getTracer(_name, _version, _config) {
+    return this.tracer;
+  }
+  /**
+   * Register this provider as the global tracer
+   */
+  register() {
+    this.contextManager.enable();
+    const provider = {
+      getTracer: (_name, _version) => this.tracer
+    };
+    trace.setGlobalTracerProvider(provider);
+  }
+};
+globalThis.Buffer = Buffer;
+
+// src/core/trace-context.ts
+var spanNameMap = /* @__PURE__ */ new WeakMap();
+function createTraceContext(span2) {
+  const spanContext = span2.spanContext();
+  return {
+    traceId: spanContext.traceId,
+    spanId: spanContext.spanId,
+    correlationId: spanContext.traceId.slice(0, 16),
+    "code.function": spanNameMap.get(span2),
+    setAttribute: span2.setAttribute.bind(span2),
+    setAttributes: span2.setAttributes.bind(span2),
+    setStatus: span2.setStatus.bind(span2),
+    recordException: span2.recordException.bind(span2)
+  };
+}
+function setSpanName(span2, name) {
+  spanNameMap.set(span2, name);
+}
+
+// src/functional.ts
+var TRACE_FACTORY_SYMBOL = Symbol.for("autotel.edge.functional.factory");
+var FACTORY_NAME_HINTS = /* @__PURE__ */ new Set(["ctx", "_ctx", "context", "tracecontext", "tracectx"]);
+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) {
+  try {
+    Object.defineProperty(fn, TRACE_FACTORY_SYMBOL, {
+      value: true,
+      configurable: true
+    });
+  } catch {
+    fn[TRACE_FACTORY_SYMBOL] = true;
+  }
+}
+function hasFactoryMark(fn) {
+  return Boolean(fn[TRACE_FACTORY_SYMBOL]);
+}
+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;
+}
+function looksLikeTraceFactory(fn) {
+  if (hasFactoryMark(fn)) {
+    return true;
+  }
+  if (fn.length === 0) {
+    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")) {
+    return true;
+  }
+  return false;
+}
+function isFactoryReturningFunction(fnWithCtx) {
+  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 = (ctx) => {
+    return plainFn;
+  };
+  markAsTraceFactory(factory);
+  return factory;
+}
+var MAX_ERROR_MESSAGE_LENGTH = 500;
+function createDummyCtx() {
+  return {
+    traceId: "",
+    spanId: "",
+    correlationId: "",
+    setAttribute: () => {
+    },
+    setAttributes: () => {
+    },
+    setStatus: () => {
+    },
+    recordException: () => {
+    }
+  };
+}
+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") {
+    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 isAsyncFunction(fn) {
+  return typeof fn === "function" && fn.constructor?.name === "AsyncFunction";
+}
+var INSTRUMENTED_SYMBOL = Symbol.for("autotel.edge.functional.instrumented");
+function wrapWithTracingAsync(fnFactory, options, variableName) {
+  const tempFn = fnFactory(createDummyCtx());
+  const spanName = getSpanName(options, tempFn, variableName);
+  const wrappedFunction = async function wrappedFunction2(...args) {
+    const tracer = trace.getTracer("autotel-edge");
+    const spanOptions = options.sampler ? { sampler: options.sampler } : {};
+    return tracer.startActiveSpan(spanName, spanOptions, async (span2) => {
+      setSpanName(span2, spanName);
+      try {
+        const actualFn = fnFactory(createTraceContext(span2));
+        if (options.attributes) {
+          span2.setAttributes(options.attributes);
+        }
+        if (options.attributesFromArgs) {
+          const argsAttrs = options.attributesFromArgs(args);
+          span2.setAttributes(argsAttrs);
+        }
+        const result = await actualFn(...args);
+        if (options.attributesFromResult) {
+          const resultAttrs = options.attributesFromResult(result);
+          span2.setAttributes(resultAttrs);
+        }
+        span2.setAttribute("code.function", spanName);
+        span2.setStatus({ code: SpanStatusCode.OK });
+        span2.end();
+        return result;
+      } catch (error) {
+        const message = truncateErrorMessage(
+          error instanceof Error ? error.message : String(error ?? "Unknown error")
+        );
+        span2.setAttribute("code.function", spanName);
+        span2.setStatus({ code: SpanStatusCode.ERROR, message });
+        span2.recordException(error instanceof Error ? error : new Error(String(error)));
+        span2.end();
+        throw error;
+      }
+    });
+  };
+  Object.defineProperty(wrappedFunction, "name", {
+    value: tempFn.name || "trace",
+    configurable: true
+  });
+  wrappedFunction[INSTRUMENTED_SYMBOL] = true;
+  return wrappedFunction;
+}
+function wrapWithTracingSync(fnFactory, options, variableName) {
+  const tempFn = fnFactory(createDummyCtx());
+  const spanName = getSpanName(options, tempFn, variableName);
+  const wrappedFunction = function wrappedFunction2(...args) {
+    const tracer = trace.getTracer("autotel-edge");
+    const spanOptions = options.sampler ? { sampler: options.sampler } : {};
+    return tracer.startActiveSpan(spanName, spanOptions, (span2) => {
+      setSpanName(span2, spanName);
+      try {
+        const actualFn = fnFactory(createTraceContext(span2));
+        if (options.attributes) {
+          span2.setAttributes(options.attributes);
+        }
+        if (options.attributesFromArgs) {
+          const argsAttrs = options.attributesFromArgs(args);
+          span2.setAttributes(argsAttrs);
+        }
+        const result = actualFn(...args);
+        if (options.attributesFromResult) {
+          const resultAttrs = options.attributesFromResult(result);
+          span2.setAttributes(resultAttrs);
+        }
+        span2.setAttribute("code.function", spanName);
+        span2.setStatus({ code: SpanStatusCode.OK });
+        span2.end();
+        return result;
+      } catch (error) {
+        const message = truncateErrorMessage(
+          error instanceof Error ? error.message : String(error ?? "Unknown error")
+        );
+        span2.setAttribute("code.function", spanName);
+        span2.setStatus({ code: SpanStatusCode.ERROR, message });
+        span2.recordException(error instanceof Error ? error : new Error(String(error)));
+        span2.end();
+        throw error;
+      }
+    });
+  };
+  Object.defineProperty(wrappedFunction, "name", {
+    value: tempFn.name || "trace",
+    configurable: true
+  });
+  wrappedFunction[INSTRUMENTED_SYMBOL] = true;
+  return wrappedFunction;
+}
+function wrapFactoryWithTracing(fnOrFactory, options, variableName) {
+  const factory = ensureTraceFactory(fnOrFactory);
+  const sampleFn = factory(createDummyCtx());
+  const useAsyncWrapper = isAsyncFunction(sampleFn);
+  if (useAsyncWrapper) {
+    return wrapWithTracingAsync(
+      factory,
+      options,
+      variableName
+    );
+  }
+  return wrapWithTracingSync(
+    factory,
+    options,
+    variableName
+  );
+}
+function executeImmediately(fn, options) {
+  const tracer = trace.getTracer("@autotel/edge");
+  const spanName = options.name || "anonymous";
+  return tracer.startActiveSpan(spanName, (span2) => {
+    try {
+      setSpanName(span2, spanName);
+      const ctxValue = createTraceContext(span2);
+      const onSuccess = (result2) => {
+        span2.setStatus({ code: SpanStatusCode.OK });
+        if (options.attributes) {
+          for (const [key, value] of Object.entries(options.attributes)) {
+            span2.setAttribute(key, value);
+          }
+        }
+        span2.end();
+        return result2;
+      };
+      const onError = (error) => {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        const truncatedMessage = truncateErrorMessage(errorMessage);
+        span2.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: truncatedMessage
+        });
+        span2.setAttribute("error", true);
+        span2.setAttribute(
+          "exception.type",
+          error instanceof Error ? error.constructor.name : "Error"
+        );
+        span2.setAttribute("exception.message", truncatedMessage);
+        span2.recordException(
+          error instanceof Error ? error : new Error(String(error))
+        );
+        span2.end();
+        throw error;
+      };
+      const result = fn(ctxValue);
+      if (result instanceof Promise) {
+        return result.then(onSuccess, onError);
+      }
+      return onSuccess(result);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      const truncatedMessage = truncateErrorMessage(errorMessage);
+      span2.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: truncatedMessage
+      });
+      span2.setAttribute("error", true);
+      span2.setAttribute("exception.message", truncatedMessage);
+      span2.recordException(
+        error instanceof Error ? error : new Error(String(error))
+      );
+      span2.end();
+      throw error;
+    }
+  });
+}
+function trace3(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 (fnOrFactory) => wrapFactoryWithTracing(fnOrFactory, options);
+}
+function shouldSkip(key, fn, skip) {
+  if (key.startsWith("_")) {
+    return true;
+  }
+  if (!skip || skip.length === 0) {
+    return false;
+  }
+  for (const pattern of skip) {
+    if (typeof pattern === "string" && key === pattern) {
+      return true;
+    }
+    if (pattern instanceof RegExp && pattern.test(key)) {
+      return true;
+    }
+    if (typeof pattern === "function" && pattern(key, fn)) {
+      return true;
+    }
+  }
+  return false;
+}
+function instrument(options) {
+  const { functions, ...tracingOptions } = options;
+  const instrumented = {};
+  for (const key of Object.keys(functions)) {
+    const fn = functions[key];
+    if (typeof fn !== "function") {
+      instrumented[key] = fn;
+      continue;
+    }
+    if (shouldSkip(key, fn, tracingOptions.skip)) {
+      instrumented[key] = fn;
+      continue;
+    }
+    const fnOptions = {
+      ...tracingOptions,
+      ...tracingOptions.overrides?.[key],
+      name: tracingOptions.overrides?.[key]?.name ?? tracingOptions.name
+    };
+    const boundFn = fn.bind(functions);
+    const fnFactory = (_ctx) => boundFn;
+    instrumented[key] = wrapFactoryWithTracing(fnFactory, fnOptions, key);
+  }
+  return instrumented;
+}
+function span(options, fn) {
+  const tracer = trace.getTracer("autotel-edge");
+  const execute = (span2) => {
+    setSpanName(span2, options.name);
+    try {
+      if (options.attributes) {
+        for (const [key, value] of Object.entries(options.attributes)) {
+          span2.setAttribute(key, value);
+        }
+      }
+      const result2 = fn(span2);
+      if (result2 instanceof Promise) {
+        return result2.then((value) => {
+          span2.setAttribute("code.function", options.name);
+          span2.setStatus({ code: SpanStatusCode.OK });
+          span2.end();
+          return value;
+        }).catch((error) => {
+          const message = truncateErrorMessage(
+            error instanceof Error ? error.message : String(error ?? "Unknown error")
+          );
+          span2.setAttribute("code.function", options.name);
+          span2.setStatus({ code: SpanStatusCode.ERROR, message });
+          span2.recordException(error instanceof Error ? error : new Error(String(error)));
+          span2.end();
+          throw error;
+        });
+      }
+      span2.setAttribute("code.function", options.name);
+      span2.setStatus({ code: SpanStatusCode.OK });
+      span2.end();
+      return result2;
+    } catch (error) {
+      const message = truncateErrorMessage(
+        error instanceof Error ? error.message : String(error ?? "Unknown error")
+      );
+      span2.setAttribute("code.function", options.name);
+      span2.setStatus({ code: SpanStatusCode.ERROR, message });
+      span2.recordException(error instanceof Error ? error : new Error(String(error)));
+      span2.end();
+      throw error;
+    }
+  };
+  const result = tracer.startActiveSpan(options.name, execute);
+  if (result instanceof Promise) {
+    return result;
+  }
+  return result;
+}
+
+export { AsyncLocalStorageContextManager, SpanImpl, WorkerTracer, WorkerTracerProvider, instrument as instrumentFunctions, span, trace3 as trace, withNextSpan, withTracing };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map