@glasstrace/sdk 0.2.0 → 0.2.3

package/dist/index.js

@@ -1,8 +1,32 @@
 import {
+  AnonApiKeySchema,
+  DEFAULT_CAPTURE_CONFIG,
+  GLASSTRACE_ATTRIBUTE_NAMES,
+  SdkCachedConfigSchema,
+  SdkInitResponseSchema,
+  SessionIdSchema,
+  SourceMapUploadResponseSchema,
   buildImportGraph,
+  createAnonApiKey,
   discoverTestFiles,
   extractImports
-} from "./chunk-BKMITIEZ.js";
+} from "./chunk-CUFIV225.js";
+import {
+  INVALID_SPAN_CONTEXT,
+  SamplingDecision,
+  SpanKind,
+  SpanStatusCode,
+  TraceFlags,
+  baggageEntryMetadataFromString,
+  context,
+  createContextKey,
+  createNoopMeter,
+  diag,
+  isSpanContextValid,
+  isValidTraceId,
+  trace
+} from "./chunk-DQ25VOKK.js";
+import "./chunk-PZ5AY32C.js";
 
 // src/errors.ts
 var SdkError = class extends Error {
@@ -18,7 +42,7 @@ var SdkError = class extends Error {
 var DEFAULT_ENDPOINT = "https://api.glasstrace.dev";
 function readEnvVars() {
   return {
-    GLASSTRACE_API_KEY: process.env.GLASSTRACE_API_KEY,
+    GLASSTRACE_API_KEY: process.env.GLASSTRACE_API_KEY?.trim() || void 0,
     GLASSTRACE_FORCE_ENABLE: process.env.GLASSTRACE_FORCE_ENABLE,
     GLASSTRACE_ENV: process.env.GLASSTRACE_ENV,
     GLASSTRACE_COVERAGE_MAP: process.env.GLASSTRACE_COVERAGE_MAP,
@@ -66,7 +90,6 @@ function isAnonymousMode(config) {
 
 // src/session.ts
 import { createHash } from "crypto";
-import { SessionIdSchema } from "@glasstrace/protocol";
 var FOUR_HOURS_MS = 4 * 60 * 60 * 1e3;
 var cachedGlasstraceEnv = process.env.GLASSTRACE_ENV;
 var cachedPort = process.env.PORT ?? "3000";
@@ -160,7 +183,6 @@ function classifyFetchTarget(url) {
 // src/anon-key.ts
 import { readFile, writeFile, mkdir, chmod } from "fs/promises";
 import { join } from "path";
-import { AnonApiKeySchema, createAnonApiKey } from "@glasstrace/protocol";
 var GLASSTRACE_DIR = ".glasstrace";
 var ANON_KEY_FILE = "anon_key";
 var ephemeralKeyCache = /* @__PURE__ */ new Map();
@@ -211,11 +233,6 @@ async function getOrCreateAnonKey(projectRoot) {
 import { readFileSync } from "fs";
 import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join2 } from "path";
-import {
-  SdkInitResponseSchema,
-  SdkCachedConfigSchema,
-  DEFAULT_CAPTURE_CONFIG
-} from "@glasstrace/protocol";
 var GLASSTRACE_DIR2 = ".glasstrace";
 var CONFIG_FILE = "config";
 var TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1e3;
@@ -263,7 +280,7 @@ async function saveCachedConfig(response, projectRoot) {
   }
 }
 async function sendInitRequest(config, anonKey, sdkVersion, importGraph, healthReport, diagnostics, signal) {
-  const effectiveKey = config.apiKey ?? anonKey;
+  const effectiveKey = config.apiKey || anonKey;
   if (!effectiveKey) {
     throw new Error("No API key available for init request");
   }
@@ -314,7 +331,7 @@ async function performInit(config, anonKey, sdkVersion) {
     return;
   }
   try {
-    const effectiveKey = config.apiKey ?? anonKey;
+    const effectiveKey = config.apiKey || anonKey;
     if (!effectiveKey) {
       console.warn("[glasstrace] No API key available for init request.");
       return;
@@ -410,8 +427,6 @@ var GlasstraceSpanProcessor = class {
 };
 
 // src/enriching-exporter.ts
-import { SpanKind } from "@opentelemetry/api";
-import { GLASSTRACE_ATTRIBUTE_NAMES } from "@glasstrace/protocol";
 var ATTR = GLASSTRACE_ATTRIBUTE_NAMES;
 var API_KEY_PENDING = "pending";
 var MAX_PENDING_SPANS = 1024;
@@ -761,253 +776,2746 @@ function createDiscoveryHandler(getAnonKey, getSessionId) {
   };
 }
 
-// src/otel-config.ts
-var _resolvedApiKey = API_KEY_PENDING;
-var _activeExporter = null;
-var _shutdownHandler = null;
-function setResolvedApiKey(key) {
-  _resolvedApiKey = key;
-}
-function getResolvedApiKey() {
-  return _resolvedApiKey;
-}
-function notifyApiKeyResolved() {
-  _activeExporter?.notifyKeyResolved();
-}
-async function tryImport(moduleId) {
-  try {
-    return await Function("id", "return import(id)")(moduleId);
-  } catch {
-    return null;
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js
+var OTLPExporterBase = class {
+  _delegate;
+  constructor(delegate) {
+    this._delegate = delegate;
   }
-}
-function registerShutdownHooks(provider) {
-  if (typeof process === "undefined" || typeof process.once !== "function") {
-    return;
+  /**
+   * Export items.
+   * @param items
+   * @param resultCallback
+   */
+  export(items, resultCallback) {
+    this._delegate.export(items, resultCallback);
   }
-  if (_shutdownHandler) {
-    process.removeListener("SIGTERM", _shutdownHandler);
-    process.removeListener("SIGINT", _shutdownHandler);
+  forceFlush() {
+    return this._delegate.forceFlush();
   }
-  let shutdownCalled = false;
-  const shutdown = (signal) => {
-    if (shutdownCalled) return;
-    shutdownCalled = true;
-    void provider.shutdown().catch((err) => {
-      console.warn(
-        `[glasstrace] Error during OTel shutdown: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }).finally(() => {
-      process.removeListener("SIGTERM", _shutdownHandler);
-      process.removeListener("SIGINT", _shutdownHandler);
-      process.kill(process.pid, signal);
-    });
+  shutdown() {
+    return this._delegate.shutdown();
+  }
+};
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/types.js
+var OTLPExporterError = class extends Error {
+  code;
+  name = "OTLPExporterError";
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.data = data;
+    this.code = code;
+  }
+};
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-configuration.js
+function validateTimeoutMillis(timeoutMillis) {
+  if (Number.isFinite(timeoutMillis) && timeoutMillis > 0) {
+    return timeoutMillis;
+  }
+  throw new Error(`Configuration: timeoutMillis is invalid, expected number greater than 0 (actual: '${timeoutMillis}')`);
+}
+function wrapStaticHeadersInFunction(headers) {
+  if (headers == null) {
+    return void 0;
+  }
+  return async () => headers;
+}
+function mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    timeoutMillis: validateTimeoutMillis(userProvidedConfiguration.timeoutMillis ?? fallbackConfiguration.timeoutMillis ?? defaultConfiguration.timeoutMillis),
+    concurrencyLimit: userProvidedConfiguration.concurrencyLimit ?? fallbackConfiguration.concurrencyLimit ?? defaultConfiguration.concurrencyLimit,
+    compression: userProvidedConfiguration.compression ?? fallbackConfiguration.compression ?? defaultConfiguration.compression
   };
-  const handler = (signal) => shutdown(signal);
-  _shutdownHandler = handler;
-  process.once("SIGTERM", handler);
-  process.once("SIGINT", handler);
 }
-async function configureOtel(config, sessionManager) {
-  const exporterUrl = `${config.endpoint}/v1/traces`;
-  let createOtlpExporter = null;
-  const otlpModule = await tryImport("@opentelemetry/exporter-trace-otlp-http");
-  if (otlpModule && typeof otlpModule.OTLPTraceExporter === "function") {
-    const OTLPTraceExporter = otlpModule.OTLPTraceExporter;
-    createOtlpExporter = (url, headers) => new OTLPTraceExporter({ url, headers });
+function getSharedConfigurationDefaults() {
+  return {
+    timeoutMillis: 1e4,
+    concurrencyLimit: 30,
+    compression: "none"
+  };
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/bounded-queue-export-promise-handler.js
+var BoundedQueueExportPromiseHandler = class {
+  _concurrencyLimit;
+  _sendingPromises = [];
+  /**
+   * @param concurrencyLimit maximum promises allowed in a queue at the same time.
+   */
+  constructor(concurrencyLimit) {
+    this._concurrencyLimit = concurrencyLimit;
   }
-  const glasstraceExporter = new GlasstraceExporter({
-    getApiKey: getResolvedApiKey,
-    sessionManager,
-    getConfig: () => getActiveConfig(),
-    environment: config.environment,
-    endpointUrl: exporterUrl,
-    createDelegate: createOtlpExporter
-  });
-  _activeExporter = glasstraceExporter;
-  const vercelOtel = await tryImport("@vercel/otel");
-  if (vercelOtel && typeof vercelOtel.registerOTel === "function") {
-    if (!createOtlpExporter) {
-      console.warn(
-        "[glasstrace] @opentelemetry/exporter-trace-otlp-http not found for @vercel/otel path. Trace export disabled."
-      );
+  pushPromise(promise) {
+    if (this.hasReachedLimit()) {
+      throw new Error("Concurrency Limit reached");
     }
-    const otelConfig = {
-      serviceName: "glasstrace-sdk",
-      traceExporter: glasstraceExporter
+    this._sendingPromises.push(promise);
+    const popPromise = () => {
+      const index = this._sendingPromises.indexOf(promise);
+      void this._sendingPromises.splice(index, 1);
     };
-    const prismaModule = await tryImport("@prisma/instrumentation");
-    if (prismaModule) {
-      const PrismaInstrumentation = prismaModule.PrismaInstrumentation;
-      if (PrismaInstrumentation) {
-        otelConfig.instrumentations = [new PrismaInstrumentation()];
-      }
-    }
-    vercelOtel.registerOTel(otelConfig);
-    return;
+    promise.then(popPromise, popPromise);
   }
-  try {
-    const otelSdk = await import("@opentelemetry/sdk-trace-base");
-    const otelApi3 = await import("@opentelemetry/api");
-    const existingProvider = otelApi3.trace.getTracerProvider();
-    const probeTracer = existingProvider.getTracer("glasstrace-probe");
-    if (probeTracer.constructor.name !== "ProxyTracer") {
-      console.warn(
-        "[glasstrace] An existing OpenTelemetry TracerProvider is already registered. Glasstrace will not overwrite it. To use Glasstrace alongside another tracing tool, add GlasstraceExporter as an additional span processor on your existing provider."
-      );
-      _activeExporter = null;
-      return;
-    }
-    if (!createOtlpExporter) {
-      const consoleExporter = new otelSdk.ConsoleSpanExporter();
-      const consoleGlasstraceExporter = new GlasstraceExporter({
-        getApiKey: getResolvedApiKey,
-        sessionManager,
-        getConfig: () => getActiveConfig(),
-        environment: config.environment,
-        endpointUrl: exporterUrl,
-        createDelegate: () => consoleExporter
-      });
-      _activeExporter = consoleGlasstraceExporter;
-      console.warn(
-        "[glasstrace] @opentelemetry/exporter-trace-otlp-http not found. Using ConsoleSpanExporter."
-      );
-      const processor2 = new otelSdk.SimpleSpanProcessor(consoleGlasstraceExporter);
-      const provider2 = new otelSdk.BasicTracerProvider({
-        spanProcessors: [processor2]
-      });
-      otelApi3.trace.setGlobalTracerProvider(provider2);
-      registerShutdownHooks(provider2);
-      return;
-    }
-    const processor = new otelSdk.BatchSpanProcessor(glasstraceExporter);
-    const provider = new otelSdk.BasicTracerProvider({
-      spanProcessors: [processor]
-    });
-    otelApi3.trace.setGlobalTracerProvider(provider);
-    registerShutdownHooks(provider);
-  } catch {
-    console.warn(
-      "[glasstrace] Neither @vercel/otel nor @opentelemetry/sdk-trace-base available. Tracing disabled."
-    );
+  hasReachedLimit() {
+    return this._sendingPromises.length >= this._concurrencyLimit;
   }
+  async awaitAll() {
+    await Promise.all(this._sendingPromises);
+  }
+};
+function createBoundedQueueExportPromiseHandler(options) {
+  return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);
 }
 
-// src/console-capture.ts
-var isGlasstraceLog = false;
-var originalError = null;
-var originalWarn = null;
-var installed = false;
-var otelApi = null;
-function formatArgs(args) {
-  return args.map((arg) => {
-    if (typeof arg === "string") return arg;
-    if (arg instanceof Error) return arg.stack ?? arg.message;
-    try {
-      return JSON.stringify(arg);
-    } catch {
-      return String(arg);
-    }
-  }).join(" ");
+// ../../node_modules/@opentelemetry/core/build/esm/trace/suppress-tracing.js
+var SUPPRESS_TRACING_KEY = createContextKey("OpenTelemetry SDK Context Key SUPPRESS_TRACING");
+function suppressTracing(context2) {
+  return context2.setValue(SUPPRESS_TRACING_KEY, true);
 }
-function isSdkMessage(args) {
-  return typeof args[0] === "string" && args[0].startsWith("[glasstrace]");
+function isTracingSuppressed(context2) {
+  return context2.getValue(SUPPRESS_TRACING_KEY) === true;
 }
-async function installConsoleCapture() {
-  if (installed) return;
+
+// ../../node_modules/@opentelemetry/core/build/esm/baggage/constants.js
+var BAGGAGE_KEY_PAIR_SEPARATOR = "=";
+var BAGGAGE_PROPERTIES_SEPARATOR = ";";
+var BAGGAGE_ITEMS_SEPARATOR = ",";
+
+// ../../node_modules/@opentelemetry/core/build/esm/baggage/utils.js
+function parsePairKeyValue(entry) {
+  if (!entry)
+    return;
+  const metadataSeparatorIndex = entry.indexOf(BAGGAGE_PROPERTIES_SEPARATOR);
+  const keyPairPart = metadataSeparatorIndex === -1 ? entry : entry.substring(0, metadataSeparatorIndex);
+  const separatorIndex = keyPairPart.indexOf(BAGGAGE_KEY_PAIR_SEPARATOR);
+  if (separatorIndex <= 0)
+    return;
+  const rawKey = keyPairPart.substring(0, separatorIndex).trim();
+  const rawValue = keyPairPart.substring(separatorIndex + 1).trim();
+  if (!rawKey || !rawValue)
+    return;
+  let key;
+  let value;
   try {
-    otelApi = await import("@opentelemetry/api");
+    key = decodeURIComponent(rawKey);
+    value = decodeURIComponent(rawValue);
   } catch {
-    otelApi = null;
+    return;
   }
-  originalError = console.error;
-  originalWarn = console.warn;
-  installed = true;
-  console.error = (...args) => {
-    originalError.apply(console, args);
-    if (isGlasstraceLog || isSdkMessage(args)) return;
-    if (otelApi) {
-      const span = otelApi.trace.getSpan(otelApi.context.active());
-      if (span) {
-        span.addEvent("console.error", {
-          "console.message": formatArgs(args)
-        });
+  let metadata;
+  if (metadataSeparatorIndex !== -1 && metadataSeparatorIndex < entry.length - 1) {
+    const metadataString = entry.substring(metadataSeparatorIndex + 1);
+    metadata = baggageEntryMetadataFromString(metadataString);
+  }
+  return { key, value, metadata };
+}
+function parseKeyPairsIntoRecord(value) {
+  const result = {};
+  if (typeof value === "string" && value.length > 0) {
+    value.split(BAGGAGE_ITEMS_SEPARATOR).forEach((entry) => {
+      const keyPair = parsePairKeyValue(entry);
+      if (keyPair !== void 0 && keyPair.value.length > 0) {
+        result[keyPair.key] = keyPair.value;
       }
+    });
+  }
+  return result;
+}
+
+// ../../node_modules/@opentelemetry/core/build/esm/common/attributes.js
+function sanitizeAttributes(attributes) {
+  const out = {};
+  if (typeof attributes !== "object" || attributes == null) {
+    return out;
+  }
+  for (const key in attributes) {
+    if (!Object.prototype.hasOwnProperty.call(attributes, key)) {
+      continue;
     }
-  };
-  console.warn = (...args) => {
-    originalWarn.apply(console, args);
-    if (isGlasstraceLog || isSdkMessage(args)) return;
-    if (otelApi) {
-      const span = otelApi.trace.getSpan(otelApi.context.active());
-      if (span) {
-        span.addEvent("console.warn", {
-          "console.message": formatArgs(args)
-        });
+    if (!isAttributeKey(key)) {
+      diag.warn(`Invalid attribute key: ${key}`);
+      continue;
+    }
+    const val = attributes[key];
+    if (!isAttributeValue(val)) {
+      diag.warn(`Invalid attribute value set for key: ${key}`);
+      continue;
+    }
+    if (Array.isArray(val)) {
+      out[key] = val.slice();
+    } else {
+      out[key] = val;
+    }
+  }
+  return out;
+}
+function isAttributeKey(key) {
+  return typeof key === "string" && key !== "";
+}
+function isAttributeValue(val) {
+  if (val == null) {
+    return true;
+  }
+  if (Array.isArray(val)) {
+    return isHomogeneousAttributeValueArray(val);
+  }
+  return isValidPrimitiveAttributeValueType(typeof val);
+}
+function isHomogeneousAttributeValueArray(arr) {
+  let type;
+  for (const element of arr) {
+    if (element == null)
+      continue;
+    const elementType = typeof element;
+    if (elementType === type) {
+      continue;
+    }
+    if (!type) {
+      if (isValidPrimitiveAttributeValueType(elementType)) {
+        type = elementType;
+        continue;
       }
+      return false;
     }
+    return false;
+  }
+  return true;
+}
+function isValidPrimitiveAttributeValueType(valType) {
+  switch (valType) {
+    case "number":
+    case "boolean":
+    case "string":
+      return true;
+  }
+  return false;
+}
+
+// ../../node_modules/@opentelemetry/core/build/esm/common/logging-error-handler.js
+function loggingErrorHandler() {
+  return (ex) => {
+    diag.error(stringifyException(ex));
   };
 }
+function stringifyException(ex) {
+  if (typeof ex === "string") {
+    return ex;
+  } else {
+    return JSON.stringify(flattenException(ex));
+  }
+}
+function flattenException(ex) {
+  const result = {};
+  let current = ex;
+  while (current !== null) {
+    Object.getOwnPropertyNames(current).forEach((propertyName) => {
+      if (result[propertyName])
+        return;
+      const value = current[propertyName];
+      if (value) {
+        result[propertyName] = String(value);
+      }
+    });
+    current = Object.getPrototypeOf(current);
+  }
+  return result;
+}
 
-// src/capture-error.ts
-var otelApi2 = null;
-var otelLoadAttempted = false;
-var otelLoadPromise = null;
-async function _preloadOtelApi() {
-  if (otelLoadAttempted) return;
-  otelLoadAttempted = true;
+// ../../node_modules/@opentelemetry/core/build/esm/common/global-error-handler.js
+var delegateHandler = loggingErrorHandler();
+function globalErrorHandler(ex) {
   try {
-    otelApi2 = await import("@opentelemetry/api");
+    delegateHandler(ex);
   } catch {
-    otelApi2 = null;
   }
 }
-function captureError(error) {
-  if (otelApi2) {
-    recordError(otelApi2, error);
-    return;
+
+// ../../node_modules/@opentelemetry/core/build/esm/platform/node/environment.js
+import { inspect } from "util";
+function getNumberFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  const value = Number(raw);
+  if (isNaN(value)) {
+    diag.warn(`Unknown value ${inspect(raw)} for ${key}, expected a number, using defaults`);
+    return void 0;
+  }
+  return value;
+}
+function getStringFromEnv(key) {
+  const raw = process.env[key];
+  if (raw == null || raw.trim() === "") {
+    return void 0;
+  }
+  return raw;
+}
+
+// ../../node_modules/@opentelemetry/core/build/esm/version.js
+var VERSION = "2.6.1";
+
+// ../../node_modules/@opentelemetry/semantic-conventions/build/esm/stable_attributes.js
+var ATTR_EXCEPTION_MESSAGE = "exception.message";
+var ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace";
+var ATTR_EXCEPTION_TYPE = "exception.type";
+var ATTR_SERVICE_NAME = "service.name";
+var ATTR_TELEMETRY_SDK_LANGUAGE = "telemetry.sdk.language";
+var TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS = "nodejs";
+var ATTR_TELEMETRY_SDK_NAME = "telemetry.sdk.name";
+var ATTR_TELEMETRY_SDK_VERSION = "telemetry.sdk.version";
+
+// ../../node_modules/@opentelemetry/core/build/esm/semconv.js
+var ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
+
+// ../../node_modules/@opentelemetry/core/build/esm/platform/node/sdk-info.js
+var SDK_INFO = {
+  [ATTR_TELEMETRY_SDK_NAME]: "opentelemetry",
+  [ATTR_PROCESS_RUNTIME_NAME]: "node",
+  [ATTR_TELEMETRY_SDK_LANGUAGE]: TELEMETRY_SDK_LANGUAGE_VALUE_NODEJS,
+  [ATTR_TELEMETRY_SDK_VERSION]: VERSION
+};
+
+// ../../node_modules/@opentelemetry/core/build/esm/platform/node/index.js
+var otperformance = performance;
+
+// ../../node_modules/@opentelemetry/core/build/esm/common/time.js
+var NANOSECOND_DIGITS = 9;
+var NANOSECOND_DIGITS_IN_MILLIS = 6;
+var MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
+var SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+function millisToHrTime(epochMillis) {
+  const epochSeconds = epochMillis / 1e3;
+  const seconds = Math.trunc(epochSeconds);
+  const nanos = Math.round(epochMillis % 1e3 * MILLISECONDS_TO_NANOSECONDS);
+  return [seconds, nanos];
+}
+function hrTime(performanceNow) {
+  const timeOrigin = millisToHrTime(otperformance.timeOrigin);
+  const now = millisToHrTime(typeof performanceNow === "number" ? performanceNow : otperformance.now());
+  return addHrTimes(timeOrigin, now);
+}
+function hrTimeDuration(startTime, endTime) {
+  let seconds = endTime[0] - startTime[0];
+  let nanos = endTime[1] - startTime[1];
+  if (nanos < 0) {
+    seconds -= 1;
+    nanos += SECOND_TO_NANOSECONDS;
+  }
+  return [seconds, nanos];
+}
+function hrTimeToNanoseconds(time) {
+  return time[0] * SECOND_TO_NANOSECONDS + time[1];
+}
+function isTimeInputHrTime(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number";
+}
+function isTimeInput(value) {
+  return isTimeInputHrTime(value) || typeof value === "number" || value instanceof Date;
+}
+function addHrTimes(time1, time2) {
+  const out = [time1[0] + time2[0], time1[1] + time2[1]];
+  if (out[1] >= SECOND_TO_NANOSECONDS) {
+    out[1] -= SECOND_TO_NANOSECONDS;
+    out[0] += 1;
+  }
+  return out;
+}
+
+// ../../node_modules/@opentelemetry/core/build/esm/ExportResult.js
+var ExportResultCode;
+(function(ExportResultCode2) {
+  ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+  ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+})(ExportResultCode || (ExportResultCode = {}));
+
+// ../../node_modules/@opentelemetry/core/build/esm/utils/lodash.merge.js
+var objectTag = "[object Object]";
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+var objectCtorString = funcToString.call(Object);
+var getPrototypeOf = Object.getPrototypeOf;
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+var nativeObjectToString = objectProto.toString;
+function isPlainObject(value) {
+  if (!isObjectLike(value) || baseGetTag(value) !== objectTag) {
+    return false;
   }
-  if (!otelLoadAttempted) {
-    otelLoadPromise ??= _preloadOtelApi();
+  const proto = getPrototypeOf(value);
+  if (proto === null) {
+    return true;
   }
-  if (otelLoadPromise) {
-    void otelLoadPromise.then(() => {
-      if (otelApi2) {
-        recordError(otelApi2, error);
-      }
-    });
+  const Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) === objectCtorString;
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
   }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
 }
-function recordError(api, error) {
+function getRawTag(value) {
+  const isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  let unmasked = false;
   try {
-    const span = api.trace.getSpan(api.context.active());
-    if (!span) return;
-    const attributes = {
-      "error.message": String(error)
-    };
-    if (error instanceof Error) {
-      attributes["error.type"] = error.constructor.name;
-    }
-    span.addEvent("glasstrace.error", attributes);
+    value[symToStringTag] = void 0;
+    unmasked = true;
   } catch {
   }
+  const result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+function objectToString(value) {
+  return nativeObjectToString.call(value);
 }
 
-// src/register.ts
-var consoleCaptureInstalled = false;
-var discoveryHandler = null;
-var isRegistered = false;
-var registrationGeneration = 0;
-function registerGlasstrace(options) {
-  try {
-    if (isRegistered) {
-      return;
-    }
-    const config = resolveConfig(options);
-    if (config.verbose) {
-      console.info("[glasstrace] Config resolved.");
+// ../../node_modules/@opentelemetry/core/build/esm/utils/merge.js
+var MAX_LEVEL = 20;
+function merge(...args) {
+  let result = args.shift();
+  const objects = /* @__PURE__ */ new WeakMap();
+  while (args.length > 0) {
+    result = mergeTwoObjects(result, args.shift(), 0, objects);
+  }
+  return result;
+}
+function takeValue(value) {
+  if (isArray(value)) {
+    return value.slice();
+  }
+  return value;
+}
+function mergeTwoObjects(one, two, level = 0, objects) {
+  let result;
+  if (level > MAX_LEVEL) {
+    return void 0;
+  }
+  level++;
+  if (isPrimitive(one) || isPrimitive(two) || isFunction(two)) {
+    result = takeValue(two);
+  } else if (isArray(one)) {
+    result = one.slice();
+    if (isArray(two)) {
+      for (let i = 0, j = two.length; i < j; i++) {
+        result.push(takeValue(two[i]));
+      }
+    } else if (isObject(two)) {
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length; i < j; i++) {
+        const key = keys[i];
+        result[key] = takeValue(two[key]);
+      }
     }
-    if (isProductionDisabled(config)) {
+  } else if (isObject(one)) {
+    if (isObject(two)) {
+      if (!shouldMerge(one, two)) {
+        return two;
+      }
+      result = Object.assign({}, one);
+      const keys = Object.keys(two);
+      for (let i = 0, j = keys.length; i < j; i++) {
+        const key = keys[i];
+        const twoValue = two[key];
+        if (isPrimitive(twoValue)) {
+          if (typeof twoValue === "undefined") {
+            delete result[key];
+          } else {
+            result[key] = twoValue;
+          }
+        } else {
+          const obj1 = result[key];
+          const obj2 = twoValue;
+          if (wasObjectReferenced(one, key, objects) || wasObjectReferenced(two, key, objects)) {
+            delete result[key];
+          } else {
+            if (isObject(obj1) && isObject(obj2)) {
+              const arr1 = objects.get(obj1) || [];
+              const arr2 = objects.get(obj2) || [];
+              arr1.push({ obj: one, key });
+              arr2.push({ obj: two, key });
+              objects.set(obj1, arr1);
+              objects.set(obj2, arr2);
+            }
+            result[key] = mergeTwoObjects(result[key], twoValue, level, objects);
+          }
+        }
+      }
+    } else {
+      result = two;
+    }
+  }
+  return result;
+}
+function wasObjectReferenced(obj, key, objects) {
+  const arr = objects.get(obj[key]) || [];
+  for (let i = 0, j = arr.length; i < j; i++) {
+    const info = arr[i];
+    if (info.key === key && info.obj === obj) {
+      return true;
+    }
+  }
+  return false;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return !isPrimitive(value) && !isArray(value) && !isFunction(value) && typeof value === "object";
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "undefined" || value instanceof Date || value instanceof RegExp || value === null;
+}
+function shouldMerge(one, two) {
+  if (!isPlainObject(one) || !isPlainObject(two)) {
+    return false;
+  }
+  return true;
+}
+
+// ../../node_modules/@opentelemetry/core/build/esm/utils/promise.js
+var Deferred = class {
+  _promise;
+  _resolve;
+  _reject;
+  constructor() {
+    this._promise = new Promise((resolve2, reject) => {
+      this._resolve = resolve2;
+      this._reject = reject;
+    });
+  }
+  get promise() {
+    return this._promise;
+  }
+  resolve(val) {
+    this._resolve(val);
+  }
+  reject(err) {
+    this._reject(err);
+  }
+};
+
+// ../../node_modules/@opentelemetry/core/build/esm/utils/callback.js
+var BindOnceFuture = class {
+  _isCalled = false;
+  _deferred = new Deferred();
+  _callback;
+  _that;
+  constructor(callback, that) {
+    this._callback = callback;
+    this._that = that;
+  }
+  get isCalled() {
+    return this._isCalled;
+  }
+  get promise() {
+    return this._deferred.promise;
+  }
+  call(...args) {
+    if (!this._isCalled) {
+      this._isCalled = true;
+      try {
+        Promise.resolve(this._callback.call(this._that, ...args)).then((val) => this._deferred.resolve(val), (err) => this._deferred.reject(err));
+      } catch (err) {
+        this._deferred.reject(err);
+      }
+    }
+    return this._deferred.promise;
+  }
+};
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js
+function isPartialSuccessResponse(response) {
+  return Object.prototype.hasOwnProperty.call(response, "partialSuccess");
+}
+function createLoggingPartialSuccessResponseHandler() {
+  return {
+    handleResponse(response) {
+      if (response == null || !isPartialSuccessResponse(response) || response.partialSuccess == null || Object.keys(response.partialSuccess).length === 0) {
+        return;
+      }
+      diag.warn("Received Partial Success response:", JSON.stringify(response.partialSuccess));
+    }
+  };
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js
+var OTLPExportDelegate = class {
+  _diagLogger;
+  _transport;
+  _serializer;
+  _responseHandler;
+  _promiseQueue;
+  _timeout;
+  constructor(transport, serializer, responseHandler, promiseQueue, timeout) {
+    this._transport = transport;
+    this._serializer = serializer;
+    this._responseHandler = responseHandler;
+    this._promiseQueue = promiseQueue;
+    this._timeout = timeout;
+    this._diagLogger = diag.createComponentLogger({
+      namespace: "OTLPExportDelegate"
+    });
+  }
+  export(internalRepresentation, resultCallback) {
+    this._diagLogger.debug("items to be sent", internalRepresentation);
+    if (this._promiseQueue.hasReachedLimit()) {
+      resultCallback({
+        code: ExportResultCode.FAILED,
+        error: new Error("Concurrent export limit reached")
+      });
+      return;
+    }
+    const serializedRequest = this._serializer.serializeRequest(internalRepresentation);
+    if (serializedRequest == null) {
+      resultCallback({
+        code: ExportResultCode.FAILED,
+        error: new Error("Nothing to send")
+      });
+      return;
+    }
+    this._promiseQueue.pushPromise(this._transport.send(serializedRequest, this._timeout).then((response) => {
+      if (response.status === "success") {
+        if (response.data != null) {
+          try {
+            this._responseHandler.handleResponse(this._serializer.deserializeResponse(response.data));
+          } catch (e) {
+            this._diagLogger.warn("Export succeeded but could not deserialize response - is the response specification compliant?", e, response.data);
+          }
+        }
+        resultCallback({
+          code: ExportResultCode.SUCCESS
+        });
+        return;
+      } else if (response.status === "failure" && response.error) {
+        resultCallback({
+          code: ExportResultCode.FAILED,
+          error: response.error
+        });
+        return;
+      } else if (response.status === "retryable") {
+        resultCallback({
+          code: ExportResultCode.FAILED,
+          error: response.error ?? new OTLPExporterError("Export failed with retryable status")
+        });
+      } else {
+        resultCallback({
+          code: ExportResultCode.FAILED,
+          error: new OTLPExporterError("Export failed with unknown error")
+        });
+      }
+    }, (reason) => resultCallback({
+      code: ExportResultCode.FAILED,
+      error: reason
+    })));
+  }
+  forceFlush() {
+    return this._promiseQueue.awaitAll();
+  }
+  async shutdown() {
+    this._diagLogger.debug("shutdown started");
+    await this.forceFlush();
+    this._transport.shutdown();
+  }
+};
+function createOtlpExportDelegate(components, settings) {
+  return new OTLPExportDelegate(components.transport, components.serializer, createLoggingPartialSuccessResponseHandler(), components.promiseHandler, settings.timeout);
+}
+
+// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/internal.js
+function createResource(resource, encoder) {
+  const result = {
+    attributes: toAttributes(resource.attributes, encoder),
+    droppedAttributesCount: 0
+  };
+  const schemaUrl = resource.schemaUrl;
+  if (schemaUrl && schemaUrl !== "")
+    result.schemaUrl = schemaUrl;
+  return result;
+}
+function createInstrumentationScope(scope) {
+  return {
+    name: scope.name,
+    version: scope.version
+  };
+}
+function toAttributes(attributes, encoder) {
+  return Object.keys(attributes).map((key) => toKeyValue(key, attributes[key], encoder));
+}
+function toKeyValue(key, value, encoder) {
+  return {
+    key,
+    value: toAnyValue(value, encoder)
+  };
+}
+function toAnyValue(value, encoder) {
+  const t = typeof value;
+  if (t === "string")
+    return { stringValue: value };
+  if (t === "number") {
+    if (!Number.isInteger(value))
+      return { doubleValue: value };
+    return { intValue: value };
+  }
+  if (t === "boolean")
+    return { boolValue: value };
+  if (value instanceof Uint8Array)
+    return { bytesValue: encoder.encodeUint8Array(value) };
+  if (Array.isArray(value)) {
+    const values = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      values[i] = toAnyValue(value[i], encoder);
+    }
+    return { arrayValue: { values } };
+  }
+  if (t === "object" && value != null) {
+    const keys = Object.keys(value);
+    const values = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+      values[i] = {
+        key: keys[i],
+        value: toAnyValue(value[keys[i]], encoder)
+      };
+    }
+    return { kvlistValue: { values } };
+  }
+  return {};
+}
+
+// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
+function hrTimeToNanos(hrTime2) {
+  const NANOSECONDS = BigInt(1e9);
+  return BigInt(Math.trunc(hrTime2[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime2[1]));
+}
+function encodeAsString(hrTime2) {
+  const nanos = hrTimeToNanos(hrTime2);
+  return nanos.toString();
+}
+var encodeTimestamp = typeof BigInt !== "undefined" ? encodeAsString : hrTimeToNanoseconds;
+function identity(value) {
+  return value;
+}
+var JSON_ENCODER = {
+  encodeHrTime: encodeTimestamp,
+  encodeSpanContext: identity,
+  encodeOptionalSpanContext: identity,
+  encodeUint8Array: (bytes) => {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(bytes).toString("base64");
+    }
+    const chars = new Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+      chars[i] = String.fromCharCode(bytes[i]);
+    }
+    return btoa(chars.join(""));
+  }
+};
+
+// ../../node_modules/@opentelemetry/resources/build/esm/default-service-name.js
+var serviceName;
+function defaultServiceName() {
+  if (serviceName === void 0) {
+    try {
+      const argv0 = globalThis.process.argv0;
+      serviceName = argv0 ? `unknown_service:${argv0}` : "unknown_service";
+    } catch {
+      serviceName = "unknown_service";
+    }
+  }
+  return serviceName;
+}
+
+// ../../node_modules/@opentelemetry/resources/build/esm/utils.js
+var isPromiseLike = (val) => {
+  return val !== null && typeof val === "object" && typeof val.then === "function";
+};
+
+// ../../node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js
+var ResourceImpl = class _ResourceImpl {
+  _rawAttributes;
+  _asyncAttributesPending = false;
+  _schemaUrl;
+  _memoizedAttributes;
+  static FromAttributeList(attributes, options) {
+    const res = new _ResourceImpl({}, options);
+    res._rawAttributes = guardedRawAttributes(attributes);
+    res._asyncAttributesPending = attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
+    return res;
+  }
+  constructor(resource, options) {
+    const attributes = resource.attributes ?? {};
+    this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
+      if (isPromiseLike(v)) {
+        this._asyncAttributesPending = true;
+      }
+      return [k, v];
+    });
+    this._rawAttributes = guardedRawAttributes(this._rawAttributes);
+    this._schemaUrl = validateSchemaUrl(options?.schemaUrl);
+  }
+  get asyncAttributesPending() {
+    return this._asyncAttributesPending;
+  }
+  async waitForAsyncAttributes() {
+    if (!this.asyncAttributesPending) {
+      return;
+    }
+    for (let i = 0; i < this._rawAttributes.length; i++) {
+      const [k, v] = this._rawAttributes[i];
+      this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
+    }
+    this._asyncAttributesPending = false;
+  }
+  get attributes() {
+    if (this.asyncAttributesPending) {
+      diag.error("Accessing resource attributes before async attributes settled");
+    }
+    if (this._memoizedAttributes) {
+      return this._memoizedAttributes;
+    }
+    const attrs = {};
+    for (const [k, v] of this._rawAttributes) {
+      if (isPromiseLike(v)) {
+        diag.debug(`Unsettled resource attribute ${k} skipped`);
+        continue;
+      }
+      if (v != null) {
+        attrs[k] ??= v;
+      }
+    }
+    if (!this._asyncAttributesPending) {
+      this._memoizedAttributes = attrs;
+    }
+    return attrs;
+  }
+  getRawAttributes() {
+    return this._rawAttributes;
+  }
+  get schemaUrl() {
+    return this._schemaUrl;
+  }
+  merge(resource) {
+    if (resource == null)
+      return this;
+    const mergedSchemaUrl = mergeSchemaUrl(this, resource);
+    const mergedOptions = mergedSchemaUrl ? { schemaUrl: mergedSchemaUrl } : void 0;
+    return _ResourceImpl.FromAttributeList([...resource.getRawAttributes(), ...this.getRawAttributes()], mergedOptions);
+  }
+};
+function resourceFromAttributes(attributes, options) {
+  return ResourceImpl.FromAttributeList(Object.entries(attributes), options);
+}
+function defaultResource() {
+  return resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: defaultServiceName(),
+    [ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE],
+    [ATTR_TELEMETRY_SDK_NAME]: SDK_INFO[ATTR_TELEMETRY_SDK_NAME],
+    [ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO[ATTR_TELEMETRY_SDK_VERSION]
+  });
+}
+function guardedRawAttributes(attributes) {
+  return attributes.map(([k, v]) => {
+    if (isPromiseLike(v)) {
+      return [
+        k,
+        v.catch((err) => {
+          diag.debug("promise rejection for resource attribute: %s - %s", k, err);
+          return void 0;
+        })
+      ];
+    }
+    return [k, v];
+  });
+}
+function validateSchemaUrl(schemaUrl) {
+  if (typeof schemaUrl === "string" || schemaUrl === void 0) {
+    return schemaUrl;
+  }
+  diag.warn("Schema URL must be string or undefined, got %s. Schema URL will be ignored.", schemaUrl);
+  return void 0;
+}
+function mergeSchemaUrl(old, updating) {
+  const oldSchemaUrl = old?.schemaUrl;
+  const updatingSchemaUrl = updating?.schemaUrl;
+  const isOldEmpty = oldSchemaUrl === void 0 || oldSchemaUrl === "";
+  const isUpdatingEmpty = updatingSchemaUrl === void 0 || updatingSchemaUrl === "";
+  if (isOldEmpty) {
+    return updatingSchemaUrl;
+  }
+  if (isUpdatingEmpty) {
+    return oldSchemaUrl;
+  }
+  if (oldSchemaUrl === updatingSchemaUrl) {
+    return oldSchemaUrl;
+  }
+  diag.warn('Schema URL merge conflict: old resource has "%s", updating resource has "%s". Resulting resource will have undefined Schema URL.', oldSchemaUrl, updatingSchemaUrl);
+  return void 0;
+}
+
+// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/internal.js
+var SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 256;
+var SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 512;
+function buildSpanFlagsFrom(traceFlags, isRemote) {
+  let flags = traceFlags & 255 | SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK;
+  if (isRemote) {
+    flags |= SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK;
+  }
+  return flags;
+}
+function sdkSpanToOtlpSpan(span, encoder) {
+  const ctx = span.spanContext();
+  const status = span.status;
+  const parentSpanId = span.parentSpanContext?.spanId ? encoder.encodeSpanContext(span.parentSpanContext?.spanId) : void 0;
+  return {
+    traceId: encoder.encodeSpanContext(ctx.traceId),
+    spanId: encoder.encodeSpanContext(ctx.spanId),
+    parentSpanId,
+    traceState: ctx.traceState?.serialize(),
+    name: span.name,
+    // Span kind is offset by 1 because the API does not define a value for unset
+    kind: span.kind == null ? 0 : span.kind + 1,
+    startTimeUnixNano: encoder.encodeHrTime(span.startTime),
+    endTimeUnixNano: encoder.encodeHrTime(span.endTime),
+    attributes: toAttributes(span.attributes, encoder),
+    droppedAttributesCount: span.droppedAttributesCount,
+    events: span.events.map((event) => toOtlpSpanEvent(event, encoder)),
+    droppedEventsCount: span.droppedEventsCount,
+    status: {
+      // API and proto enums share the same values
+      code: status.code,
+      message: status.message
+    },
+    links: span.links.map((link) => toOtlpLink(link, encoder)),
+    droppedLinksCount: span.droppedLinksCount,
+    flags: buildSpanFlagsFrom(ctx.traceFlags, span.parentSpanContext?.isRemote)
+  };
+}
+function toOtlpLink(link, encoder) {
+  return {
+    attributes: link.attributes ? toAttributes(link.attributes, encoder) : [],
+    spanId: encoder.encodeSpanContext(link.context.spanId),
+    traceId: encoder.encodeSpanContext(link.context.traceId),
+    traceState: link.context.traceState?.serialize(),
+    droppedAttributesCount: link.droppedAttributesCount || 0,
+    flags: buildSpanFlagsFrom(link.context.traceFlags, link.context.isRemote)
+  };
+}
+function toOtlpSpanEvent(timedEvent, encoder) {
+  return {
+    attributes: timedEvent.attributes ? toAttributes(timedEvent.attributes, encoder) : [],
+    name: timedEvent.name,
+    timeUnixNano: encoder.encodeHrTime(timedEvent.time),
+    droppedAttributesCount: timedEvent.droppedAttributesCount || 0
+  };
+}
+function createExportTraceServiceRequest(spans, encoder) {
+  return {
+    resourceSpans: spanRecordsToResourceSpans(spans, encoder)
+  };
+}
+function createResourceMap(readableSpans) {
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const record of readableSpans) {
+    let ilsMap = resourceMap.get(record.resource);
+    if (!ilsMap) {
+      ilsMap = /* @__PURE__ */ new Map();
+      resourceMap.set(record.resource, ilsMap);
+    }
+    const instrumentationScopeKey = `${record.instrumentationScope.name}@${record.instrumentationScope.version || ""}:${record.instrumentationScope.schemaUrl || ""}`;
+    let records = ilsMap.get(instrumentationScopeKey);
+    if (!records) {
+      records = [];
+      ilsMap.set(instrumentationScopeKey, records);
+    }
+    records.push(record);
+  }
+  return resourceMap;
+}
+function spanRecordsToResourceSpans(readableSpans, encoder) {
+  const resourceMap = createResourceMap(readableSpans);
+  const out = [];
+  const entryIterator = resourceMap.entries();
+  let entry = entryIterator.next();
+  while (!entry.done) {
+    const [resource, ilmMap] = entry.value;
+    const scopeResourceSpans = [];
+    const ilmIterator = ilmMap.values();
+    let ilmEntry = ilmIterator.next();
+    while (!ilmEntry.done) {
+      const scopeSpans = ilmEntry.value;
+      if (scopeSpans.length > 0) {
+        const spans = scopeSpans.map((readableSpan) => sdkSpanToOtlpSpan(readableSpan, encoder));
+        scopeResourceSpans.push({
+          scope: createInstrumentationScope(scopeSpans[0].instrumentationScope),
+          spans,
+          schemaUrl: scopeSpans[0].instrumentationScope.schemaUrl
+        });
+      }
+      ilmEntry = ilmIterator.next();
+    }
+    const processedResource = createResource(resource, encoder);
+    const transformedSpans = {
+      resource: processedResource,
+      scopeSpans: scopeResourceSpans,
+      schemaUrl: processedResource.schemaUrl
+    };
+    out.push(transformedSpans);
+    entry = entryIterator.next();
+  }
+  return out;
+}
+
+// ../../node_modules/@opentelemetry/otlp-transformer/build/esm/trace/json/trace.js
+var JsonTraceSerializer = {
+  serializeRequest: (arg) => {
+    const request = createExportTraceServiceRequest(arg, JSON_ENCODER);
+    const encoder = new TextEncoder();
+    return encoder.encode(JSON.stringify(request));
+  },
+  deserializeResponse: (arg) => {
+    if (arg.length === 0) {
+      return {};
+    }
+    const decoder = new TextDecoder();
+    return JSON.parse(decoder.decode(arg));
+  }
+};
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js
+function validateAndNormalizeHeaders(partialHeaders) {
+  const headers = {};
+  Object.entries(partialHeaders ?? {}).forEach(([key, value]) => {
+    if (typeof value !== "undefined") {
+      headers[key] = String(value);
+    } else {
+      diag.warn(`Header "${key}" has invalid value (${value}) and will be ignored`);
+    }
+  });
+  return headers;
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-http-configuration.js
+function mergeHeaders(userProvidedHeaders, fallbackHeaders, defaultHeaders) {
+  return async () => {
+    const requiredHeaders = {
+      ...await defaultHeaders()
+    };
+    const headers = {};
+    if (fallbackHeaders != null) {
+      Object.assign(headers, await fallbackHeaders());
+    }
+    if (userProvidedHeaders != null) {
+      Object.assign(headers, validateAndNormalizeHeaders(await userProvidedHeaders()));
+    }
+    return Object.assign(headers, requiredHeaders);
+  };
+}
+function validateUserProvidedUrl(url) {
+  if (url == null) {
+    return void 0;
+  }
+  try {
+    const base = globalThis.location?.href;
+    return new URL(url, base).href;
+  } catch {
+    throw new Error(`Configuration: Could not parse user-provided export URL: '${url}'`);
+  }
+}
+function mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    ...mergeOtlpSharedConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
+    headers: mergeHeaders(userProvidedConfiguration.headers, fallbackConfiguration.headers, defaultConfiguration.headers),
+    url: validateUserProvidedUrl(userProvidedConfiguration.url) ?? fallbackConfiguration.url ?? defaultConfiguration.url
+  };
+}
+function getHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
+  return {
+    ...getSharedConfigurationDefaults(),
+    headers: async () => requiredHeaders,
+    url: "http://localhost:4318/" + signalResourcePath
+  };
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-configuration.js
+function httpAgentFactoryFromOptions(options) {
+  return async (protocol) => {
+    const isInsecure = protocol === "http:";
+    const module = isInsecure ? import("http") : import("https");
+    const { Agent } = await module;
+    if (isInsecure) {
+      const { ca, cert, key, ...insecureOptions } = options;
+      return new Agent(insecureOptions);
+    }
+    return new Agent(options);
+  };
+}
+function mergeOtlpNodeHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+  return {
+    ...mergeOtlpHttpConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
+    agentFactory: userProvidedConfiguration.agentFactory ?? fallbackConfiguration.agentFactory ?? defaultConfiguration.agentFactory,
+    userAgent: userProvidedConfiguration.userAgent
+  };
+}
+function getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath) {
+  return {
+    ...getHttpConfigurationDefaults(requiredHeaders, signalResourcePath),
+    agentFactory: httpAgentFactoryFromOptions({ keepAlive: true })
+  };
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
+import * as zlib from "zlib";
+import { Readable } from "stream";
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/is-export-retryable.js
+function isExportHTTPErrorRetryable(statusCode) {
+  return statusCode === 429 || statusCode === 502 || statusCode === 503 || statusCode === 504;
+}
+function parseRetryAfterToMills(retryAfter) {
+  if (retryAfter == null) {
+    return void 0;
+  }
+  const seconds = Number.parseInt(retryAfter, 10);
+  if (Number.isInteger(seconds)) {
+    return seconds > 0 ? seconds * 1e3 : -1;
+  }
+  const delay = new Date(retryAfter).getTime() - Date.now();
+  if (delay >= 0) {
+    return delay;
+  }
+  return 0;
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/version.js
+var VERSION2 = "0.214.0";
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
+var DEFAULT_USER_AGENT = `OTel-OTLP-Exporter-JavaScript/${VERSION2}`;
+function sendWithHttp(request, url, headers, compression, userAgent, agent, data, timeoutMillis) {
+  return new Promise((resolve2) => {
+    const parsedUrl = new URL(url);
+    if (userAgent) {
+      headers["User-Agent"] = `${userAgent} ${DEFAULT_USER_AGENT}`;
+    } else {
+      headers["User-Agent"] = DEFAULT_USER_AGENT;
+    }
+    const options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port,
+      path: parsedUrl.pathname,
+      method: "POST",
+      headers,
+      agent
+    };
+    const req = request(options, (res) => {
+      const responseData = [];
+      res.on("data", (chunk) => responseData.push(chunk));
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode <= 299) {
+          resolve2({
+            status: "success",
+            data: Buffer.concat(responseData)
+          });
+        } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
+          resolve2({
+            status: "retryable",
+            retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
+          });
+        } else {
+          const error = new OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString());
+          resolve2({
+            status: "failure",
+            error
+          });
+        }
+      });
+      res.on("error", (error) => {
+        if (res.statusCode && res.statusCode <= 299) {
+          resolve2({
+            status: "success"
+          });
+        } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
+          resolve2({
+            status: "retryable",
+            error,
+            retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
+          });
+        } else {
+          resolve2({
+            status: "failure",
+            error
+          });
+        }
+      });
+    });
+    req.setTimeout(timeoutMillis, () => {
+      req.destroy();
+      resolve2({
+        status: "retryable",
+        error: new Error("Request timed out")
+      });
+    });
+    req.on("error", (error) => {
+      if (isHttpTransportNetworkErrorRetryable(error)) {
+        resolve2({
+          status: "retryable",
+          error
+        });
+      } else {
+        resolve2({
+          status: "failure",
+          error
+        });
+      }
+    });
+    compressAndSend(req, compression, data, (error) => {
+      resolve2({
+        status: "failure",
+        error
+      });
+    });
+  });
+}
+function compressAndSend(req, compression, data, onError) {
+  let dataStream = readableFromUint8Array(data);
+  if (compression === "gzip") {
+    req.setHeader("Content-Encoding", "gzip");
+    dataStream = dataStream.on("error", onError).pipe(zlib.createGzip()).on("error", onError);
+  }
+  dataStream.pipe(req).on("error", onError);
+}
+function readableFromUint8Array(buff) {
+  const readable = new Readable();
+  readable.push(buff);
+  readable.push(null);
+  return readable;
+}
+function isHttpTransportNetworkErrorRetryable(error) {
+  const RETRYABLE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "EPIPE",
+    "ETIMEDOUT",
+    "EAI_AGAIN",
+    "ENOTFOUND",
+    "ENETUNREACH",
+    "EHOSTUNREACH"
+  ]);
+  if ("code" in error && typeof error.code === "string") {
+    return RETRYABLE_NETWORK_ERROR_CODES.has(error.code);
+  }
+  return false;
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-exporter-transport.js
+var HttpExporterTransport = class {
+  _utils = null;
+  _parameters;
+  constructor(parameters) {
+    this._parameters = parameters;
+  }
+  async send(data, timeoutMillis) {
+    const { agent, request } = await this._loadUtils();
+    const headers = await this._parameters.headers();
+    return sendWithHttp(request, this._parameters.url, headers, this._parameters.compression, this._parameters.userAgent, agent, data, timeoutMillis);
+  }
+  shutdown() {
+  }
+  async _loadUtils() {
+    let utils = this._utils;
+    if (utils === null) {
+      const protocol = new URL(this._parameters.url).protocol;
+      const [agent, request] = await Promise.all([
+        this._parameters.agentFactory(protocol),
+        requestFunctionFactory(protocol)
+      ]);
+      utils = this._utils = { agent, request };
+    }
+    return utils;
+  }
+};
+async function requestFunctionFactory(protocol) {
+  const module = protocol === "http:" ? import("http") : import("https");
+  const { request } = await module;
+  return request;
+}
+function createHttpExporterTransport(parameters) {
+  return new HttpExporterTransport(parameters);
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js
+var MAX_ATTEMPTS = 5;
+var INITIAL_BACKOFF = 1e3;
+var MAX_BACKOFF = 5e3;
+var BACKOFF_MULTIPLIER = 1.5;
+var JITTER = 0.2;
+function getJitter() {
+  return Math.random() * (2 * JITTER) - JITTER;
+}
+var RetryingTransport = class {
+  _transport;
+  constructor(transport) {
+    this._transport = transport;
+  }
+  retry(data, timeoutMillis, inMillis) {
+    return new Promise((resolve2, reject) => {
+      setTimeout(() => {
+        this._transport.send(data, timeoutMillis).then(resolve2, reject);
+      }, inMillis);
+    });
+  }
+  async send(data, timeoutMillis) {
+    let attempts = MAX_ATTEMPTS;
+    let nextBackoff = INITIAL_BACKOFF;
+    const deadline = Date.now() + timeoutMillis;
+    let result = await this._transport.send(data, timeoutMillis);
+    while (result.status === "retryable" && attempts > 0) {
+      attempts--;
+      const backoff = Math.max(Math.min(nextBackoff * (1 + getJitter()), MAX_BACKOFF), 0);
+      nextBackoff = nextBackoff * BACKOFF_MULTIPLIER;
+      const retryInMillis = result.retryInMillis ?? backoff;
+      const remainingTimeoutMillis = deadline - Date.now();
+      if (retryInMillis > remainingTimeoutMillis) {
+        diag.info(`Export retry time ${Math.round(retryInMillis)}ms exceeds remaining timeout ${Math.round(remainingTimeoutMillis)}ms, not retrying further.`);
+        return result;
+      }
+      diag.verbose(`Scheduling export retry in ${Math.round(retryInMillis)}ms`);
+      result = await this.retry(data, remainingTimeoutMillis, retryInMillis);
+    }
+    if (result.status === "success") {
+      diag.verbose(`Export succeeded after ${MAX_ATTEMPTS - attempts} retry attempts.`);
+    } else if (result.status === "retryable") {
+      diag.info(`Export failed after maximum retry attempts (${MAX_ATTEMPTS}).`);
+    } else {
+      diag.info(`Export failed with non-retryable error: ${result.error}`);
+    }
+    return result;
+  }
+  shutdown() {
+    return this._transport.shutdown();
+  }
+};
+function createRetryingTransport(options) {
+  return new RetryingTransport(options.transport);
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-http-export-delegate.js
+function createOtlpHttpExportDelegate(options, serializer) {
+  return createOtlpExportDelegate({
+    transport: createRetryingTransport({
+      transport: createHttpExporterTransport(options)
+    }),
+    serializer,
+    promiseHandler: createBoundedQueueExportPromiseHandler(options)
+  }, { timeout: options.timeoutMillis });
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-env-configuration.js
+function parseAndValidateTimeoutFromEnv(timeoutEnvVar) {
+  const envTimeout = getNumberFromEnv(timeoutEnvVar);
+  if (envTimeout != null) {
+    if (Number.isFinite(envTimeout) && envTimeout > 0) {
+      return envTimeout;
+    }
+    diag.warn(`Configuration: ${timeoutEnvVar} is invalid, expected number greater than 0 (actual: ${envTimeout})`);
+  }
+  return void 0;
+}
+function getTimeoutFromEnv(signalIdentifier) {
+  const specificTimeout = parseAndValidateTimeoutFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_TIMEOUT`);
+  const nonSpecificTimeout = parseAndValidateTimeoutFromEnv("OTEL_EXPORTER_OTLP_TIMEOUT");
+  return specificTimeout ?? nonSpecificTimeout;
+}
+function parseAndValidateCompressionFromEnv(compressionEnvVar) {
+  const compression = getStringFromEnv(compressionEnvVar)?.trim();
+  if (compression == null || compression === "none" || compression === "gzip") {
+    return compression;
+  }
+  diag.warn(`Configuration: ${compressionEnvVar} is invalid, expected 'none' or 'gzip' (actual: '${compression}')`);
+  return void 0;
+}
+function getCompressionFromEnv(signalIdentifier) {
+  const specificCompression = parseAndValidateCompressionFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_COMPRESSION`);
+  const nonSpecificCompression = parseAndValidateCompressionFromEnv("OTEL_EXPORTER_OTLP_COMPRESSION");
+  return specificCompression ?? nonSpecificCompression;
+}
+function getSharedConfigurationFromEnvironment(signalIdentifier) {
+  return {
+    timeoutMillis: getTimeoutFromEnv(signalIdentifier),
+    compression: getCompressionFromEnv(signalIdentifier)
+  };
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.js
+import * as fs from "fs";
+import * as path from "path";
+function getStaticHeadersFromEnv(signalIdentifier) {
+  const signalSpecificRawHeaders = getStringFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_HEADERS`);
+  const nonSignalSpecificRawHeaders = getStringFromEnv("OTEL_EXPORTER_OTLP_HEADERS");
+  const signalSpecificHeaders = parseKeyPairsIntoRecord(signalSpecificRawHeaders);
+  const nonSignalSpecificHeaders = parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders);
+  if (Object.keys(signalSpecificHeaders).length === 0 && Object.keys(nonSignalSpecificHeaders).length === 0) {
+    return void 0;
+  }
+  return Object.assign({}, parseKeyPairsIntoRecord(nonSignalSpecificRawHeaders), parseKeyPairsIntoRecord(signalSpecificRawHeaders));
+}
+function appendRootPathToUrlIfNeeded(url) {
+  try {
+    const parsedUrl = new URL(url);
+    return parsedUrl.toString();
+  } catch {
+    diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
+    return void 0;
+  }
+}
+function appendResourcePathToUrl(url, path3) {
+  try {
+    new URL(url);
+  } catch {
+    diag.warn(`Configuration: Could not parse environment-provided export URL: '${url}', falling back to undefined`);
+    return void 0;
+  }
+  if (!url.endsWith("/")) {
+    url = url + "/";
+  }
+  url += path3;
+  try {
+    new URL(url);
+  } catch {
+    diag.warn(`Configuration: Provided URL appended with '${path3}' is not a valid URL, using 'undefined' instead of '${url}'`);
+    return void 0;
+  }
+  return url;
+}
+function getNonSpecificUrlFromEnv(signalResourcePath) {
+  const envUrl = getStringFromEnv("OTEL_EXPORTER_OTLP_ENDPOINT");
+  if (envUrl === void 0) {
+    return void 0;
+  }
+  return appendResourcePathToUrl(envUrl, signalResourcePath);
+}
+function getSpecificUrlFromEnv(signalIdentifier) {
+  const envUrl = getStringFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_ENDPOINT`);
+  if (envUrl === void 0) {
+    return void 0;
+  }
+  return appendRootPathToUrlIfNeeded(envUrl);
+}
+function readFileFromEnv(signalSpecificEnvVar, nonSignalSpecificEnvVar, warningMessage) {
+  const signalSpecificPath = getStringFromEnv(signalSpecificEnvVar);
+  const nonSignalSpecificPath = getStringFromEnv(nonSignalSpecificEnvVar);
+  const filePath = signalSpecificPath ?? nonSignalSpecificPath;
+  if (filePath != null) {
+    try {
+      return fs.readFileSync(path.resolve(process.cwd(), filePath));
+    } catch {
+      diag.warn(warningMessage);
+      return void 0;
+    }
+  } else {
+    return void 0;
+  }
+}
+function getClientCertificateFromEnv(signalIdentifier) {
+  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_CERTIFICATE`, "OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE", "Failed to read client certificate chain file");
+}
+function getClientKeyFromEnv(signalIdentifier) {
+  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_KEY`, "OTEL_EXPORTER_OTLP_CLIENT_KEY", "Failed to read client certificate private key file");
+}
+function getRootCertificateFromEnv(signalIdentifier) {
+  return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CERTIFICATE`, "OTEL_EXPORTER_OTLP_CERTIFICATE", "Failed to read root certificate file");
+}
+function getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath) {
+  return {
+    ...getSharedConfigurationFromEnvironment(signalIdentifier),
+    url: getSpecificUrlFromEnv(signalIdentifier) ?? getNonSpecificUrlFromEnv(signalResourcePath),
+    headers: wrapStaticHeadersInFunction(getStaticHeadersFromEnv(signalIdentifier)),
+    agentFactory: httpAgentFactoryFromOptions({
+      keepAlive: true,
+      ca: getRootCertificateFromEnv(signalIdentifier),
+      cert: getClientCertificateFromEnv(signalIdentifier),
+      key: getClientKeyFromEnv(signalIdentifier)
+    })
+  };
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-http-options.js
+function convertLegacyHeaders(config) {
+  if (typeof config.headers === "function") {
+    return config.headers;
+  }
+  return wrapStaticHeadersInFunction(config.headers);
+}
+
+// ../../node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js
+function convertLegacyAgentOptions(config) {
+  if (typeof config.httpAgentOptions === "function") {
+    return config.httpAgentOptions;
+  }
+  let legacy = config.httpAgentOptions;
+  if (config.keepAlive != null) {
+    legacy = { keepAlive: config.keepAlive, ...legacy };
+  }
+  if (legacy != null) {
+    return httpAgentFactoryFromOptions(legacy);
+  } else {
+    return void 0;
+  }
+}
+function convertLegacyHttpOptions(config, signalIdentifier, signalResourcePath, requiredHeaders) {
+  if (config.metadata) {
+    diag.warn("Metadata cannot be set when using http");
+  }
+  return mergeOtlpNodeHttpConfigurationWithDefaults({
+    url: config.url,
+    headers: convertLegacyHeaders(config),
+    concurrencyLimit: config.concurrencyLimit,
+    timeoutMillis: config.timeoutMillis,
+    compression: config.compression,
+    agentFactory: convertLegacyAgentOptions(config),
+    userAgent: config.userAgent
+  }, getNodeHttpConfigurationFromEnvironment(signalIdentifier, signalResourcePath), getNodeHttpConfigurationDefaults(requiredHeaders, signalResourcePath));
+}
+
+// ../../node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/OTLPTraceExporter.js
+var OTLPTraceExporter = class extends OTLPExporterBase {
+  constructor(config = {}) {
+    super(createOtlpHttpExportDelegate(convertLegacyHttpOptions(config, "TRACES", "v1/traces", {
+      "Content-Type": "application/json"
+    }), JsonTraceSerializer));
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/enums.js
+var ExceptionEventName = "exception";
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/Span.js
+var SpanImpl = class {
+  // Below properties are included to implement ReadableSpan for export
+  // purposes but are not intended to be written-to directly.
+  _spanContext;
+  kind;
+  parentSpanContext;
+  attributes = {};
+  links = [];
+  events = [];
+  startTime;
+  resource;
+  instrumentationScope;
+  _droppedAttributesCount = 0;
+  _droppedEventsCount = 0;
+  _droppedLinksCount = 0;
+  _attributesCount = 0;
+  name;
+  status = {
+    code: SpanStatusCode.UNSET
+  };
+  endTime = [0, 0];
+  _ended = false;
+  _duration = [-1, -1];
+  _spanProcessor;
+  _spanLimits;
+  _attributeValueLengthLimit;
+  _recordEndMetrics;
+  _performanceStartTime;
+  _performanceOffset;
+  _startTimeProvided;
+  /**
+   * Constructs a new SpanImpl instance.
+   */
+  constructor(opts) {
+    const now = Date.now();
+    this._spanContext = opts.spanContext;
+    this._performanceStartTime = otperformance.now();
+    this._performanceOffset = now - (this._performanceStartTime + otperformance.timeOrigin);
+    this._startTimeProvided = opts.startTime != null;
+    this._spanLimits = opts.spanLimits;
+    this._attributeValueLengthLimit = this._spanLimits.attributeValueLengthLimit ?? 0;
+    this._spanProcessor = opts.spanProcessor;
+    this.name = opts.name;
+    this.parentSpanContext = opts.parentSpanContext;
+    this.kind = opts.kind;
+    if (opts.links) {
+      for (const link of opts.links) {
+        this.addLink(link);
+      }
+    }
+    this.startTime = this._getTime(opts.startTime ?? now);
+    this.resource = opts.resource;
+    this.instrumentationScope = opts.scope;
+    this._recordEndMetrics = opts.recordEndMetrics;
+    if (opts.attributes != null) {
+      this.setAttributes(opts.attributes);
+    }
+    this._spanProcessor.onStart(this, opts.context);
+  }
+  spanContext() {
+    return this._spanContext;
+  }
+  setAttribute(key, value) {
+    if (value == null || this._isSpanEnded())
+      return this;
+    if (key.length === 0) {
+      diag.warn(`Invalid attribute key: ${key}`);
+      return this;
+    }
+    if (!isAttributeValue(value)) {
+      diag.warn(`Invalid attribute value set for key: ${key}`);
+      return this;
+    }
+    const { attributeCountLimit } = this._spanLimits;
+    const isNewKey = !Object.prototype.hasOwnProperty.call(this.attributes, key);
+    if (attributeCountLimit !== void 0 && this._attributesCount >= attributeCountLimit && isNewKey) {
+      this._droppedAttributesCount++;
+      return this;
+    }
+    this.attributes[key] = this._truncateToSize(value);
+    if (isNewKey) {
+      this._attributesCount++;
+    }
+    return this;
+  }
+  setAttributes(attributes) {
+    for (const key in attributes) {
+      if (Object.prototype.hasOwnProperty.call(attributes, key)) {
+        this.setAttribute(key, attributes[key]);
+      }
+    }
+    return this;
+  }
+  /**
+   *
+   * @param name Span Name
+   * @param [attributesOrStartTime] Span attributes or start time
+   *     if type is {@type TimeInput} and 3rd param is undefined
+   * @param [timeStamp] Specified time stamp for the event
+   */
+  addEvent(name, attributesOrStartTime, timeStamp) {
+    if (this._isSpanEnded())
+      return this;
+    const { eventCountLimit } = this._spanLimits;
+    if (eventCountLimit === 0) {
+      diag.warn("No events allowed.");
+      this._droppedEventsCount++;
+      return this;
+    }
+    if (eventCountLimit !== void 0 && this.events.length >= eventCountLimit) {
+      if (this._droppedEventsCount === 0) {
+        diag.debug("Dropping extra events.");
+      }
+      this.events.shift();
+      this._droppedEventsCount++;
+    }
+    if (isTimeInput(attributesOrStartTime)) {
+      if (!isTimeInput(timeStamp)) {
+        timeStamp = attributesOrStartTime;
+      }
+      attributesOrStartTime = void 0;
+    }
+    const sanitized = sanitizeAttributes(attributesOrStartTime);
+    const { attributePerEventCountLimit } = this._spanLimits;
+    const attributes = {};
+    let droppedAttributesCount = 0;
+    let eventAttributesCount = 0;
+    for (const attr in sanitized) {
+      if (!Object.prototype.hasOwnProperty.call(sanitized, attr)) {
+        continue;
+      }
+      const attrVal = sanitized[attr];
+      if (attributePerEventCountLimit !== void 0 && eventAttributesCount >= attributePerEventCountLimit) {
+        droppedAttributesCount++;
+        continue;
+      }
+      attributes[attr] = this._truncateToSize(attrVal);
+      eventAttributesCount++;
+    }
+    this.events.push({
+      name,
+      attributes,
+      time: this._getTime(timeStamp),
+      droppedAttributesCount
+    });
+    return this;
+  }
+  addLink(link) {
+    if (this._isSpanEnded())
+      return this;
+    const { linkCountLimit } = this._spanLimits;
+    if (linkCountLimit === 0) {
+      this._droppedLinksCount++;
+      return this;
+    }
+    if (linkCountLimit !== void 0 && this.links.length >= linkCountLimit) {
+      if (this._droppedLinksCount === 0) {
+        diag.debug("Dropping extra links.");
+      }
+      this.links.shift();
+      this._droppedLinksCount++;
+    }
+    const { attributePerLinkCountLimit } = this._spanLimits;
+    const sanitized = sanitizeAttributes(link.attributes);
+    const attributes = {};
+    let droppedAttributesCount = 0;
+    let linkAttributesCount = 0;
+    for (const attr in sanitized) {
+      if (!Object.prototype.hasOwnProperty.call(sanitized, attr)) {
+        continue;
+      }
+      const attrVal = sanitized[attr];
+      if (attributePerLinkCountLimit !== void 0 && linkAttributesCount >= attributePerLinkCountLimit) {
+        droppedAttributesCount++;
+        continue;
+      }
+      attributes[attr] = this._truncateToSize(attrVal);
+      linkAttributesCount++;
+    }
+    const processedLink = { context: link.context };
+    if (linkAttributesCount > 0) {
+      processedLink.attributes = attributes;
+    }
+    if (droppedAttributesCount > 0) {
+      processedLink.droppedAttributesCount = droppedAttributesCount;
+    }
+    this.links.push(processedLink);
+    return this;
+  }
+  addLinks(links) {
+    for (const link of links) {
+      this.addLink(link);
+    }
+    return this;
+  }
+  setStatus(status) {
+    if (this._isSpanEnded())
+      return this;
+    if (status.code === SpanStatusCode.UNSET)
+      return this;
+    if (this.status.code === SpanStatusCode.OK)
+      return this;
+    const newStatus = { code: status.code };
+    if (status.code === SpanStatusCode.ERROR) {
+      if (typeof status.message === "string") {
+        newStatus.message = status.message;
+      } else if (status.message != null) {
+        diag.warn(`Dropping invalid status.message of type '${typeof status.message}', expected 'string'`);
+      }
+    }
+    this.status = newStatus;
+    return this;
+  }
+  updateName(name) {
+    if (this._isSpanEnded())
+      return this;
+    this.name = name;
+    return this;
+  }
+  end(endTime) {
+    if (this._isSpanEnded()) {
+      diag.error(`${this.name} ${this._spanContext.traceId}-${this._spanContext.spanId} - You can only call end() on a span once.`);
+      return;
+    }
+    this.endTime = this._getTime(endTime);
+    this._duration = hrTimeDuration(this.startTime, this.endTime);
+    if (this._duration[0] < 0) {
+      diag.warn("Inconsistent start and end time, startTime > endTime. Setting span duration to 0ms.", this.startTime, this.endTime);
+      this.endTime = this.startTime.slice();
+      this._duration = [0, 0];
+    }
+    if (this._droppedEventsCount > 0) {
+      diag.warn(`Dropped ${this._droppedEventsCount} events because eventCountLimit reached`);
+    }
+    if (this._droppedLinksCount > 0) {
+      diag.warn(`Dropped ${this._droppedLinksCount} links because linkCountLimit reached`);
+    }
+    if (this._spanProcessor.onEnding) {
+      this._spanProcessor.onEnding(this);
+    }
+    this._recordEndMetrics?.();
+    this._ended = true;
+    this._spanProcessor.onEnd(this);
+  }
+  _getTime(inp) {
+    if (typeof inp === "number" && inp <= otperformance.now()) {
+      return hrTime(inp + this._performanceOffset);
+    }
+    if (typeof inp === "number") {
+      return millisToHrTime(inp);
+    }
+    if (inp instanceof Date) {
+      return millisToHrTime(inp.getTime());
+    }
+    if (isTimeInputHrTime(inp)) {
+      return inp;
+    }
+    if (this._startTimeProvided) {
+      return millisToHrTime(Date.now());
+    }
+    const msDuration = otperformance.now() - this._performanceStartTime;
+    return addHrTimes(this.startTime, millisToHrTime(msDuration));
+  }
+  isRecording() {
+    return this._ended === false;
+  }
+  recordException(exception, time) {
+    const attributes = {};
+    if (typeof exception === "string") {
+      attributes[ATTR_EXCEPTION_MESSAGE] = exception;
+    } else if (exception) {
+      if (exception.code) {
+        attributes[ATTR_EXCEPTION_TYPE] = exception.code.toString();
+      } else if (exception.name) {
+        attributes[ATTR_EXCEPTION_TYPE] = exception.name;
+      }
+      if (exception.message) {
+        attributes[ATTR_EXCEPTION_MESSAGE] = exception.message;
+      }
+      if (exception.stack) {
+        attributes[ATTR_EXCEPTION_STACKTRACE] = exception.stack;
+      }
+    }
+    if (attributes[ATTR_EXCEPTION_TYPE] || attributes[ATTR_EXCEPTION_MESSAGE]) {
+      this.addEvent(ExceptionEventName, attributes, time);
+    } else {
+      diag.warn(`Failed to record an exception ${exception}`);
+    }
+  }
+  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;
+  }
+  _isSpanEnded() {
+    if (this._ended) {
+      const error = new Error(`Operation attempted on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`);
+      diag.warn(`Cannot execute the operation on ended Span {traceId: ${this._spanContext.traceId}, spanId: ${this._spanContext.spanId}}`, error);
+    }
+    return this._ended;
+  }
+  // Utility function to truncate given value within size
+  // for value type of string, will truncate to given limit
+  // for type of non-string, will return same value
+  _truncateToLimitUtil(value, limit) {
+    if (value.length <= limit) {
+      return value;
+    }
+    return value.substring(0, limit);
+  }
+  /**
+   * If the given attribute value is of type string and has more characters than given {@code attributeValueLengthLimit} then
+   * return string with truncated to {@code attributeValueLengthLimit} characters
+   *
+   * If the given attribute value is array of strings then
+   * return new array of strings with each element truncated to {@code attributeValueLengthLimit} characters
+   *
+   * Otherwise return same Attribute {@code value}
+   *
+   * @param value Attribute value
+   * @returns truncated attribute value if required, otherwise same value
+   */
+  _truncateToSize(value) {
+    const limit = this._attributeValueLengthLimit;
+    if (limit <= 0) {
+      diag.warn(`Attribute value limit must be positive, got ${limit}`);
+      return value;
+    }
+    if (typeof value === "string") {
+      return this._truncateToLimitUtil(value, limit);
+    }
+    if (Array.isArray(value)) {
+      return value.map((val) => typeof val === "string" ? this._truncateToLimitUtil(val, limit) : val);
+    }
+    return value;
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/Sampler.js
+var SamplingDecision2;
+(function(SamplingDecision3) {
+  SamplingDecision3[SamplingDecision3["NOT_RECORD"] = 0] = "NOT_RECORD";
+  SamplingDecision3[SamplingDecision3["RECORD"] = 1] = "RECORD";
+  SamplingDecision3[SamplingDecision3["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
+})(SamplingDecision2 || (SamplingDecision2 = {}));
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOffSampler.js
+var AlwaysOffSampler = class {
+  shouldSample() {
+    return {
+      decision: SamplingDecision2.NOT_RECORD
+    };
+  }
+  toString() {
+    return "AlwaysOffSampler";
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/AlwaysOnSampler.js
+var AlwaysOnSampler = class {
+  shouldSample() {
+    return {
+      decision: SamplingDecision2.RECORD_AND_SAMPLED
+    };
+  }
+  toString() {
+    return "AlwaysOnSampler";
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/ParentBasedSampler.js
+var ParentBasedSampler = class {
+  _root;
+  _remoteParentSampled;
+  _remoteParentNotSampled;
+  _localParentSampled;
+  _localParentNotSampled;
+  constructor(config) {
+    this._root = config.root;
+    if (!this._root) {
+      globalErrorHandler(new Error("ParentBasedSampler must have a root sampler configured"));
+      this._root = new AlwaysOnSampler();
+    }
+    this._remoteParentSampled = config.remoteParentSampled ?? new AlwaysOnSampler();
+    this._remoteParentNotSampled = config.remoteParentNotSampled ?? new AlwaysOffSampler();
+    this._localParentSampled = config.localParentSampled ?? new AlwaysOnSampler();
+    this._localParentNotSampled = config.localParentNotSampled ?? new AlwaysOffSampler();
+  }
+  shouldSample(context2, traceId, spanName, spanKind, attributes, links) {
+    const parentContext = trace.getSpanContext(context2);
+    if (!parentContext || !isSpanContextValid(parentContext)) {
+      return this._root.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+    }
+    if (parentContext.isRemote) {
+      if (parentContext.traceFlags & TraceFlags.SAMPLED) {
+        return this._remoteParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+      }
+      return this._remoteParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+    }
+    if (parentContext.traceFlags & TraceFlags.SAMPLED) {
+      return this._localParentSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+    }
+    return this._localParentNotSampled.shouldSample(context2, traceId, spanName, spanKind, attributes, links);
+  }
+  toString() {
+    return `ParentBased{root=${this._root.toString()}, remoteParentSampled=${this._remoteParentSampled.toString()}, remoteParentNotSampled=${this._remoteParentNotSampled.toString()}, localParentSampled=${this._localParentSampled.toString()}, localParentNotSampled=${this._localParentNotSampled.toString()}}`;
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/sampler/TraceIdRatioBasedSampler.js
+var TraceIdRatioBasedSampler = class {
+  _ratio;
+  _upperBound;
+  constructor(ratio = 0) {
+    this._ratio = this._normalize(ratio);
+    this._upperBound = Math.floor(this._ratio * 4294967295);
+  }
+  shouldSample(context2, traceId) {
+    return {
+      decision: isValidTraceId(traceId) && this._accumulate(traceId) < this._upperBound ? SamplingDecision2.RECORD_AND_SAMPLED : SamplingDecision2.NOT_RECORD
+    };
+  }
+  toString() {
+    return `TraceIdRatioBased{${this._ratio}}`;
+  }
+  _normalize(ratio) {
+    if (typeof ratio !== "number" || isNaN(ratio))
+      return 0;
+    return ratio >= 1 ? 1 : ratio <= 0 ? 0 : ratio;
+  }
+  _accumulate(traceId) {
+    let accumulation = 0;
+    for (let i = 0; i < traceId.length / 8; i++) {
+      const pos = i * 8;
+      const part = parseInt(traceId.slice(pos, pos + 8), 16);
+      accumulation = (accumulation ^ part) >>> 0;
+    }
+    return accumulation;
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/config.js
+var TracesSamplerValues;
+(function(TracesSamplerValues2) {
+  TracesSamplerValues2["AlwaysOff"] = "always_off";
+  TracesSamplerValues2["AlwaysOn"] = "always_on";
+  TracesSamplerValues2["ParentBasedAlwaysOff"] = "parentbased_always_off";
+  TracesSamplerValues2["ParentBasedAlwaysOn"] = "parentbased_always_on";
+  TracesSamplerValues2["ParentBasedTraceIdRatio"] = "parentbased_traceidratio";
+  TracesSamplerValues2["TraceIdRatio"] = "traceidratio";
+})(TracesSamplerValues || (TracesSamplerValues = {}));
+var DEFAULT_RATIO = 1;
+function loadDefaultConfig() {
+  return {
+    sampler: buildSamplerFromEnv(),
+    forceFlushTimeoutMillis: 3e4,
+    generalLimits: {
+      attributeValueLengthLimit: getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity,
+      attributeCountLimit: getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? 128
+    },
+    spanLimits: {
+      attributeValueLengthLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? Infinity,
+      attributeCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? 128,
+      linkCountLimit: getNumberFromEnv("OTEL_SPAN_LINK_COUNT_LIMIT") ?? 128,
+      eventCountLimit: getNumberFromEnv("OTEL_SPAN_EVENT_COUNT_LIMIT") ?? 128,
+      attributePerEventCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_EVENT_COUNT_LIMIT") ?? 128,
+      attributePerLinkCountLimit: getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_PER_LINK_COUNT_LIMIT") ?? 128
+    }
+  };
+}
+function buildSamplerFromEnv() {
+  const sampler = getStringFromEnv("OTEL_TRACES_SAMPLER") ?? TracesSamplerValues.ParentBasedAlwaysOn;
+  switch (sampler) {
+    case TracesSamplerValues.AlwaysOn:
+      return new AlwaysOnSampler();
+    case TracesSamplerValues.AlwaysOff:
+      return new AlwaysOffSampler();
+    case TracesSamplerValues.ParentBasedAlwaysOn:
+      return new ParentBasedSampler({
+        root: new AlwaysOnSampler()
+      });
+    case TracesSamplerValues.ParentBasedAlwaysOff:
+      return new ParentBasedSampler({
+        root: new AlwaysOffSampler()
+      });
+    case TracesSamplerValues.TraceIdRatio:
+      return new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv());
+    case TracesSamplerValues.ParentBasedTraceIdRatio:
+      return new ParentBasedSampler({
+        root: new TraceIdRatioBasedSampler(getSamplerProbabilityFromEnv())
+      });
+    default:
+      diag.error(`OTEL_TRACES_SAMPLER value "${sampler}" invalid, defaulting to "${TracesSamplerValues.ParentBasedAlwaysOn}".`);
+      return new ParentBasedSampler({
+        root: new AlwaysOnSampler()
+      });
+  }
+}
+function getSamplerProbabilityFromEnv() {
+  const probability = getNumberFromEnv("OTEL_TRACES_SAMPLER_ARG");
+  if (probability == null) {
+    diag.error(`OTEL_TRACES_SAMPLER_ARG is blank, defaulting to ${DEFAULT_RATIO}.`);
+    return DEFAULT_RATIO;
+  }
+  if (probability < 0 || probability > 1) {
+    diag.error(`OTEL_TRACES_SAMPLER_ARG=${probability} was given, but it is out of range ([0..1]), defaulting to ${DEFAULT_RATIO}.`);
+    return DEFAULT_RATIO;
+  }
+  return probability;
+}
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/utility.js
+var DEFAULT_ATTRIBUTE_COUNT_LIMIT = 128;
+var DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT = Infinity;
+function mergeConfig(userConfig) {
+  const perInstanceDefaults = {
+    sampler: buildSamplerFromEnv()
+  };
+  const DEFAULT_CONFIG = loadDefaultConfig();
+  const target = Object.assign({}, DEFAULT_CONFIG, perInstanceDefaults, userConfig);
+  target.generalLimits = Object.assign({}, DEFAULT_CONFIG.generalLimits, userConfig.generalLimits || {});
+  target.spanLimits = Object.assign({}, DEFAULT_CONFIG.spanLimits, userConfig.spanLimits || {});
+  return target;
+}
+function reconfigureLimits(userConfig) {
+  const spanLimits = Object.assign({}, userConfig.spanLimits);
+  spanLimits.attributeCountLimit = userConfig.spanLimits?.attributeCountLimit ?? userConfig.generalLimits?.attributeCountLimit ?? getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT") ?? getNumberFromEnv("OTEL_ATTRIBUTE_COUNT_LIMIT") ?? DEFAULT_ATTRIBUTE_COUNT_LIMIT;
+  spanLimits.attributeValueLengthLimit = userConfig.spanLimits?.attributeValueLengthLimit ?? userConfig.generalLimits?.attributeValueLengthLimit ?? getNumberFromEnv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? getNumberFromEnv("OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT") ?? DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+  return Object.assign({}, userConfig, { spanLimits });
+}
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/export/BatchSpanProcessorBase.js
+var BatchSpanProcessorBase = class {
+  _maxExportBatchSize;
+  _maxQueueSize;
+  _scheduledDelayMillis;
+  _exportTimeoutMillis;
+  _exporter;
+  _isExporting = false;
+  _finishedSpans = [];
+  _timer;
+  _shutdownOnce;
+  _droppedSpansCount = 0;
+  constructor(exporter, config) {
+    this._exporter = exporter;
+    this._maxExportBatchSize = typeof config?.maxExportBatchSize === "number" ? config.maxExportBatchSize : getNumberFromEnv("OTEL_BSP_MAX_EXPORT_BATCH_SIZE") ?? 512;
+    this._maxQueueSize = typeof config?.maxQueueSize === "number" ? config.maxQueueSize : getNumberFromEnv("OTEL_BSP_MAX_QUEUE_SIZE") ?? 2048;
+    this._scheduledDelayMillis = typeof config?.scheduledDelayMillis === "number" ? config.scheduledDelayMillis : getNumberFromEnv("OTEL_BSP_SCHEDULE_DELAY") ?? 5e3;
+    this._exportTimeoutMillis = typeof config?.exportTimeoutMillis === "number" ? config.exportTimeoutMillis : getNumberFromEnv("OTEL_BSP_EXPORT_TIMEOUT") ?? 3e4;
+    this._shutdownOnce = new BindOnceFuture(this._shutdown, this);
+    if (this._maxExportBatchSize > this._maxQueueSize) {
+      diag.warn("BatchSpanProcessor: maxExportBatchSize must be smaller or equal to maxQueueSize, setting maxExportBatchSize to match maxQueueSize");
+      this._maxExportBatchSize = this._maxQueueSize;
+    }
+  }
+  forceFlush() {
+    if (this._shutdownOnce.isCalled) {
+      return this._shutdownOnce.promise;
+    }
+    return this._flushAll();
+  }
+  // does nothing.
+  onStart(_span, _parentContext) {
+  }
+  onEnd(span) {
+    if (this._shutdownOnce.isCalled) {
+      return;
+    }
+    if ((span.spanContext().traceFlags & TraceFlags.SAMPLED) === 0) {
+      return;
+    }
+    this._addToBuffer(span);
+  }
+  shutdown() {
+    return this._shutdownOnce.call();
+  }
+  _shutdown() {
+    return Promise.resolve().then(() => {
+      return this.onShutdown();
+    }).then(() => {
+      return this._flushAll();
+    }).then(() => {
+      return this._exporter.shutdown();
+    });
+  }
+  /** Add a span in the buffer. */
+  _addToBuffer(span) {
+    if (this._finishedSpans.length >= this._maxQueueSize) {
+      if (this._droppedSpansCount === 0) {
+        diag.debug("maxQueueSize reached, dropping spans");
+      }
+      this._droppedSpansCount++;
+      return;
+    }
+    if (this._droppedSpansCount > 0) {
+      diag.warn(`Dropped ${this._droppedSpansCount} spans because maxQueueSize reached`);
+      this._droppedSpansCount = 0;
+    }
+    this._finishedSpans.push(span);
+    this._maybeStartTimer();
+  }
+  /**
+   * Send all spans to the exporter respecting the batch size limit
+   * This function is used only on forceFlush or shutdown,
+   * for all other cases _flush should be used
+   * */
+  _flushAll() {
+    return new Promise((resolve2, reject) => {
+      const promises = [];
+      const count = Math.ceil(this._finishedSpans.length / this._maxExportBatchSize);
+      for (let i = 0, j = count; i < j; i++) {
+        promises.push(this._flushOneBatch());
+      }
+      Promise.all(promises).then(() => {
+        resolve2();
+      }).catch(reject);
+    });
+  }
+  _flushOneBatch() {
+    this._clearTimer();
+    if (this._finishedSpans.length === 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error("Timeout"));
+      }, this._exportTimeoutMillis);
+      context.with(suppressTracing(context.active()), () => {
+        let spans;
+        if (this._finishedSpans.length <= this._maxExportBatchSize) {
+          spans = this._finishedSpans;
+          this._finishedSpans = [];
+        } else {
+          spans = this._finishedSpans.splice(0, this._maxExportBatchSize);
+        }
+        const doExport = () => this._exporter.export(spans, (result) => {
+          clearTimeout(timer);
+          if (result.code === ExportResultCode.SUCCESS) {
+            resolve2();
+          } else {
+            reject(result.error ?? new Error("BatchSpanProcessor: span export failed"));
+          }
+        });
+        let pendingResources = null;
+        for (let i = 0, len = spans.length; i < len; i++) {
+          const span = spans[i];
+          if (span.resource.asyncAttributesPending && span.resource.waitForAsyncAttributes) {
+            pendingResources ??= [];
+            pendingResources.push(span.resource.waitForAsyncAttributes());
+          }
+        }
+        if (pendingResources === null) {
+          doExport();
+        } else {
+          Promise.all(pendingResources).then(doExport, (err) => {
+            globalErrorHandler(err);
+            reject(err);
+          });
+        }
+      });
+    });
+  }
+  _maybeStartTimer() {
+    if (this._isExporting)
+      return;
+    const flush = () => {
+      this._isExporting = true;
+      this._flushOneBatch().finally(() => {
+        this._isExporting = false;
+        if (this._finishedSpans.length > 0) {
+          this._clearTimer();
+          this._maybeStartTimer();
+        }
+      }).catch((e) => {
+        this._isExporting = false;
+        globalErrorHandler(e);
+      });
+    };
+    if (this._finishedSpans.length >= this._maxExportBatchSize) {
+      return flush();
+    }
+    if (this._timer !== void 0)
+      return;
+    this._timer = setTimeout(() => flush(), this._scheduledDelayMillis);
+    if (typeof this._timer !== "number") {
+      this._timer.unref();
+    }
+  }
+  _clearTimer() {
+    if (this._timer !== void 0) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/export/BatchSpanProcessor.js
+var BatchSpanProcessor = class extends BatchSpanProcessorBase {
+  onShutdown() {
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/platform/node/RandomIdGenerator.js
+var SPAN_ID_BYTES = 8;
+var TRACE_ID_BYTES = 16;
+var RandomIdGenerator = class {
+  /**
+   * Returns a random 16-byte trace ID formatted/encoded as a 32 lowercase hex
+   * characters corresponding to 128 bits.
+   */
+  generateTraceId = getIdGenerator(TRACE_ID_BYTES);
+  /**
+   * Returns a random 8-byte span ID formatted/encoded as a 16 lowercase hex
+   * characters corresponding to 64 bits.
+   */
+  generateSpanId = getIdGenerator(SPAN_ID_BYTES);
+};
+var SHARED_BUFFER = Buffer.allocUnsafe(TRACE_ID_BYTES);
+function getIdGenerator(bytes) {
+  return function generateId() {
+    for (let i = 0; i < bytes / 4; i++) {
+      SHARED_BUFFER.writeUInt32BE(Math.random() * 2 ** 32 >>> 0, i * 4);
+    }
+    for (let i = 0; i < bytes; i++) {
+      if (SHARED_BUFFER[i] > 0) {
+        break;
+      } else if (i === bytes - 1) {
+        SHARED_BUFFER[bytes - 1] = 1;
+      }
+    }
+    return SHARED_BUFFER.toString("hex", 0, bytes);
+  };
+}
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/semconv.js
+var ATTR_OTEL_SPAN_PARENT_ORIGIN = "otel.span.parent.origin";
+var ATTR_OTEL_SPAN_SAMPLING_RESULT = "otel.span.sampling_result";
+var METRIC_OTEL_SDK_SPAN_LIVE = "otel.sdk.span.live";
+var METRIC_OTEL_SDK_SPAN_STARTED = "otel.sdk.span.started";
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/TracerMetrics.js
+var TracerMetrics = class {
+  startedSpans;
+  liveSpans;
+  constructor(meter) {
+    this.startedSpans = meter.createCounter(METRIC_OTEL_SDK_SPAN_STARTED, {
+      unit: "{span}",
+      description: "The number of created spans."
+    });
+    this.liveSpans = meter.createUpDownCounter(METRIC_OTEL_SDK_SPAN_LIVE, {
+      unit: "{span}",
+      description: "The number of currently live spans."
+    });
+  }
+  startSpan(parentSpanCtx, samplingDecision) {
+    const samplingDecisionStr = samplingDecisionToString(samplingDecision);
+    this.startedSpans.add(1, {
+      [ATTR_OTEL_SPAN_PARENT_ORIGIN]: parentOrigin(parentSpanCtx),
+      [ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr
+    });
+    if (samplingDecision === SamplingDecision2.NOT_RECORD) {
+      return () => {
+      };
+    }
+    const liveSpanAttributes = {
+      [ATTR_OTEL_SPAN_SAMPLING_RESULT]: samplingDecisionStr
+    };
+    this.liveSpans.add(1, liveSpanAttributes);
+    return () => {
+      this.liveSpans.add(-1, liveSpanAttributes);
+    };
+  }
+};
+function parentOrigin(parentSpanContext) {
+  if (!parentSpanContext) {
+    return "none";
+  }
+  if (parentSpanContext.isRemote) {
+    return "remote";
+  }
+  return "local";
+}
+function samplingDecisionToString(decision) {
+  switch (decision) {
+    case SamplingDecision2.RECORD_AND_SAMPLED:
+      return "RECORD_AND_SAMPLE";
+    case SamplingDecision2.RECORD:
+      return "RECORD_ONLY";
+    case SamplingDecision2.NOT_RECORD:
+      return "DROP";
+  }
+}
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/version.js
+var VERSION3 = "2.6.1";
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/Tracer.js
+var Tracer = class {
+  _sampler;
+  _generalLimits;
+  _spanLimits;
+  _idGenerator;
+  instrumentationScope;
+  _resource;
+  _spanProcessor;
+  _tracerMetrics;
+  /**
+   * Constructs a new Tracer instance.
+   */
+  constructor(instrumentationScope, config, resource, spanProcessor) {
+    const localConfig = mergeConfig(config);
+    this._sampler = localConfig.sampler;
+    this._generalLimits = localConfig.generalLimits;
+    this._spanLimits = localConfig.spanLimits;
+    this._idGenerator = config.idGenerator || new RandomIdGenerator();
+    this._resource = resource;
+    this._spanProcessor = spanProcessor;
+    this.instrumentationScope = instrumentationScope;
+    const meter = localConfig.meterProvider ? localConfig.meterProvider.getMeter("@opentelemetry/sdk-trace", VERSION3) : createNoopMeter();
+    this._tracerMetrics = new TracerMetrics(meter);
+  }
+  /**
+   * Starts a new Span or returns the default NoopSpan based on the sampling
+   * decision.
+   */
+  startSpan(name, options = {}, context2 = context.active()) {
+    if (options.root) {
+      context2 = trace.deleteSpan(context2);
+    }
+    const parentSpan = trace.getSpan(context2);
+    if (isTracingSuppressed(context2)) {
+      diag.debug("Instrumentation suppressed, returning Noop Span");
+      const nonRecordingSpan = trace.wrapSpanContext(INVALID_SPAN_CONTEXT);
+      return nonRecordingSpan;
+    }
+    const parentSpanContext = parentSpan?.spanContext();
+    const spanId = this._idGenerator.generateSpanId();
+    let validParentSpanContext;
+    let traceId;
+    let traceState;
+    if (!parentSpanContext || !trace.isSpanContextValid(parentSpanContext)) {
+      traceId = this._idGenerator.generateTraceId();
+    } else {
+      traceId = parentSpanContext.traceId;
+      traceState = parentSpanContext.traceState;
+      validParentSpanContext = parentSpanContext;
+    }
+    const spanKind = options.kind ?? SpanKind.INTERNAL;
+    const links = (options.links ?? []).map((link) => {
+      return {
+        context: link.context,
+        attributes: sanitizeAttributes(link.attributes)
+      };
+    });
+    const attributes = sanitizeAttributes(options.attributes);
+    const samplingResult = this._sampler.shouldSample(context2, traceId, name, spanKind, attributes, links);
+    const recordEndMetrics = this._tracerMetrics.startSpan(parentSpanContext, samplingResult.decision);
+    traceState = samplingResult.traceState ?? traceState;
+    const traceFlags = samplingResult.decision === SamplingDecision.RECORD_AND_SAMPLED ? TraceFlags.SAMPLED : TraceFlags.NONE;
+    const spanContext = { traceId, spanId, traceFlags, traceState };
+    if (samplingResult.decision === SamplingDecision.NOT_RECORD) {
+      diag.debug("Recording is off, propagating context in a non-recording span");
+      const nonRecordingSpan = trace.wrapSpanContext(spanContext);
+      return nonRecordingSpan;
+    }
+    const initAttributes = sanitizeAttributes(Object.assign(attributes, samplingResult.attributes));
+    const span = new SpanImpl({
+      resource: this._resource,
+      scope: this.instrumentationScope,
+      context: context2,
+      spanContext,
+      name,
+      kind: spanKind,
+      links,
+      parentSpanContext: validParentSpanContext,
+      attributes: initAttributes,
+      startTime: options.startTime,
+      spanProcessor: this._spanProcessor,
+      spanLimits: this._spanLimits,
+      recordEndMetrics
+    });
+    return span;
+  }
+  startActiveSpan(name, arg2, arg3, arg4) {
+    let opts;
+    let ctx;
+    let fn;
+    if (arguments.length < 2) {
+      return;
+    } else if (arguments.length === 2) {
+      fn = arg2;
+    } else if (arguments.length === 3) {
+      opts = arg2;
+      fn = arg3;
+    } else {
+      opts = arg2;
+      ctx = arg3;
+      fn = arg4;
+    }
+    const parentContext = ctx ?? context.active();
+    const span = this.startSpan(name, opts, parentContext);
+    const contextWithSpanSet = trace.setSpan(parentContext, span);
+    return context.with(contextWithSpanSet, fn, void 0, span);
+  }
+  /** Returns the active {@link GeneralLimits}. */
+  getGeneralLimits() {
+    return this._generalLimits;
+  }
+  /** Returns the active {@link SpanLimits}. */
+  getSpanLimits() {
+    return this._spanLimits;
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/MultiSpanProcessor.js
+var MultiSpanProcessor = class {
+  _spanProcessors;
+  constructor(spanProcessors) {
+    this._spanProcessors = spanProcessors;
+  }
+  forceFlush() {
+    const promises = [];
+    for (const spanProcessor of this._spanProcessors) {
+      promises.push(spanProcessor.forceFlush());
+    }
+    return new Promise((resolve2) => {
+      Promise.all(promises).then(() => {
+        resolve2();
+      }).catch((error) => {
+        globalErrorHandler(error || new Error("MultiSpanProcessor: forceFlush failed"));
+        resolve2();
+      });
+    });
+  }
+  onStart(span, context2) {
+    for (const spanProcessor of this._spanProcessors) {
+      spanProcessor.onStart(span, context2);
+    }
+  }
+  onEnding(span) {
+    for (const spanProcessor of this._spanProcessors) {
+      if (spanProcessor.onEnding) {
+        spanProcessor.onEnding(span);
+      }
+    }
+  }
+  onEnd(span) {
+    for (const spanProcessor of this._spanProcessors) {
+      spanProcessor.onEnd(span);
+    }
+  }
+  shutdown() {
+    const promises = [];
+    for (const spanProcessor of this._spanProcessors) {
+      promises.push(spanProcessor.shutdown());
+    }
+    return new Promise((resolve2, reject) => {
+      Promise.all(promises).then(() => {
+        resolve2();
+      }, reject);
+    });
+  }
+};
+
+// ../../node_modules/@opentelemetry/sdk-trace-base/build/esm/BasicTracerProvider.js
+var ForceFlushState;
+(function(ForceFlushState2) {
+  ForceFlushState2[ForceFlushState2["resolved"] = 0] = "resolved";
+  ForceFlushState2[ForceFlushState2["timeout"] = 1] = "timeout";
+  ForceFlushState2[ForceFlushState2["error"] = 2] = "error";
+  ForceFlushState2[ForceFlushState2["unresolved"] = 3] = "unresolved";
+})(ForceFlushState || (ForceFlushState = {}));
+var BasicTracerProvider = class {
+  _config;
+  _tracers = /* @__PURE__ */ new Map();
+  _resource;
+  _activeSpanProcessor;
+  constructor(config = {}) {
+    const mergedConfig = merge({}, loadDefaultConfig(), reconfigureLimits(config));
+    this._resource = mergedConfig.resource ?? defaultResource();
+    this._config = Object.assign({}, mergedConfig, {
+      resource: this._resource
+    });
+    const spanProcessors = [];
+    if (config.spanProcessors?.length) {
+      spanProcessors.push(...config.spanProcessors);
+    }
+    this._activeSpanProcessor = new MultiSpanProcessor(spanProcessors);
+  }
+  getTracer(name, version, options) {
+    const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
+    if (!this._tracers.has(key)) {
+      this._tracers.set(key, new Tracer({ name, version, schemaUrl: options?.schemaUrl }, this._config, this._resource, this._activeSpanProcessor));
+    }
+    return this._tracers.get(key);
+  }
+  forceFlush() {
+    const timeout = this._config.forceFlushTimeoutMillis;
+    const promises = this._activeSpanProcessor["_spanProcessors"].map((spanProcessor) => {
+      return new Promise((resolve2) => {
+        let state;
+        const timeoutInterval = setTimeout(() => {
+          resolve2(new Error(`Span processor did not completed within timeout period of ${timeout} ms`));
+          state = ForceFlushState.timeout;
+        }, timeout);
+        spanProcessor.forceFlush().then(() => {
+          clearTimeout(timeoutInterval);
+          if (state !== ForceFlushState.timeout) {
+            state = ForceFlushState.resolved;
+            resolve2(state);
+          }
+        }).catch((error) => {
+          clearTimeout(timeoutInterval);
+          state = ForceFlushState.error;
+          resolve2(error);
+        });
+      });
+    });
+    return new Promise((resolve2, reject) => {
+      Promise.all(promises).then((results) => {
+        const errors = results.filter((result) => result !== ForceFlushState.resolved);
+        if (errors.length > 0) {
+          reject(errors);
+        } else {
+          resolve2();
+        }
+      }).catch((error) => reject([error]));
+    });
+  }
+  shutdown() {
+    return this._activeSpanProcessor.shutdown();
+  }
+};
+
+// src/otel-config.ts
+var _resolvedApiKey = API_KEY_PENDING;
+var _activeExporter = null;
+var _shutdownHandler = null;
+function setResolvedApiKey(key) {
+  _resolvedApiKey = key;
+}
+function getResolvedApiKey() {
+  return _resolvedApiKey;
+}
+function notifyApiKeyResolved() {
+  _activeExporter?.notifyKeyResolved();
+}
+async function tryImport(moduleId) {
+  try {
+    return await Function("id", "return import(id)")(moduleId);
+  } catch {
+    return null;
+  }
+}
+function registerShutdownHooks(provider) {
+  if (typeof process === "undefined" || typeof process.once !== "function") {
+    return;
+  }
+  if (_shutdownHandler) {
+    process.removeListener("SIGTERM", _shutdownHandler);
+    process.removeListener("SIGINT", _shutdownHandler);
+  }
+  let shutdownCalled = false;
+  const shutdown = (signal) => {
+    if (shutdownCalled) return;
+    shutdownCalled = true;
+    void provider.shutdown().catch((err) => {
+      console.warn(
+        `[glasstrace] Error during OTel shutdown: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }).finally(() => {
+      process.removeListener("SIGTERM", _shutdownHandler);
+      process.removeListener("SIGINT", _shutdownHandler);
+      process.kill(process.pid, signal);
+    });
+  };
+  const handler = (signal) => shutdown(signal);
+  _shutdownHandler = handler;
+  process.once("SIGTERM", handler);
+  process.once("SIGINT", handler);
+}
+async function configureOtel(config, sessionManager) {
+  const exporterUrl = `${config.endpoint}/v1/traces`;
+  const createOtlpExporter = (url, headers) => new OTLPTraceExporter({ url, headers });
+  const glasstraceExporter = new GlasstraceExporter({
+    getApiKey: getResolvedApiKey,
+    sessionManager,
+    getConfig: () => getActiveConfig(),
+    environment: config.environment,
+    endpointUrl: exporterUrl,
+    createDelegate: createOtlpExporter
+  });
+  _activeExporter = glasstraceExporter;
+  const vercelOtel = await tryImport("@vercel/otel");
+  if (vercelOtel && typeof vercelOtel.registerOTel === "function") {
+    const otelConfig = {
+      serviceName: "glasstrace-sdk",
+      traceExporter: glasstraceExporter
+    };
+    const prismaModule = await tryImport("@prisma/instrumentation");
+    if (prismaModule) {
+      const PrismaInstrumentation = prismaModule.PrismaInstrumentation;
+      if (PrismaInstrumentation) {
+        otelConfig.instrumentations = [new PrismaInstrumentation()];
+      }
+    }
+    vercelOtel.registerOTel(otelConfig);
+    return;
+  }
+  const existingProvider = trace.getTracerProvider();
+  const probeTracer = existingProvider.getTracer("glasstrace-probe");
+  if (probeTracer.constructor.name !== "ProxyTracer") {
+    console.warn(
+      "[glasstrace] An existing OpenTelemetry TracerProvider is already registered. Glasstrace will not overwrite it. To use Glasstrace alongside another tracing tool, add GlasstraceExporter as an additional span processor on your existing provider."
+    );
+    _activeExporter = null;
+    return;
+  }
+  const processor = new BatchSpanProcessor(glasstraceExporter);
+  const provider = new BasicTracerProvider({
+    spanProcessors: [processor]
+  });
+  trace.setGlobalTracerProvider(provider);
+  registerShutdownHooks(provider);
+}
+
+// src/console-capture.ts
+var isGlasstraceLog = false;
+var originalError = null;
+var originalWarn = null;
+var installed = false;
+var otelApi = null;
+function formatArgs(args) {
+  return args.map((arg) => {
+    if (typeof arg === "string") return arg;
+    if (arg instanceof Error) return arg.stack ?? arg.message;
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
+}
+function isSdkMessage(args) {
+  return typeof args[0] === "string" && args[0].startsWith("[glasstrace]");
+}
+async function installConsoleCapture() {
+  if (installed) return;
+  try {
+    otelApi = await import("./esm-POMEQPKL.js");
+  } catch {
+    otelApi = null;
+  }
+  originalError = console.error;
+  originalWarn = console.warn;
+  installed = true;
+  console.error = (...args) => {
+    originalError.apply(console, args);
+    if (isGlasstraceLog || isSdkMessage(args)) return;
+    if (otelApi) {
+      const span = otelApi.trace.getSpan(otelApi.context.active());
+      if (span) {
+        span.addEvent("console.error", {
+          "console.message": formatArgs(args)
+        });
+      }
+    }
+  };
+  console.warn = (...args) => {
+    originalWarn.apply(console, args);
+    if (isGlasstraceLog || isSdkMessage(args)) return;
+    if (otelApi) {
+      const span = otelApi.trace.getSpan(otelApi.context.active());
+      if (span) {
+        span.addEvent("console.warn", {
+          "console.message": formatArgs(args)
+        });
+      }
+    }
+  };
+}
+
+// src/register.ts
+var consoleCaptureInstalled = false;
+var discoveryHandler = null;
+var isRegistered = false;
+var registrationGeneration = 0;
+function registerGlasstrace(options) {
+  try {
+    if (isRegistered) {
+      return;
+    }
+    const config = resolveConfig(options);
+    if (config.verbose) {
+      console.info("[glasstrace] Config resolved.");
+    }
+    if (isProductionDisabled(config)) {
       console.warn(
         "[glasstrace] Disabled in production. Set GLASSTRACE_FORCE_ENABLE=true to override."
       );
@@ -1043,7 +3551,6 @@ function registerGlasstrace(options) {
     const currentGeneration = registrationGeneration;
     void configureOtel(config, sessionManager).then(
       () => {
-        void _preloadOtelApi();
         maybeInstallConsoleCapture();
         if (config.verbose) {
           console.info("[glasstrace] OTel configured.");
@@ -1082,7 +3589,7 @@ function registerGlasstrace(options) {
             if (config.verbose) {
               console.info("[glasstrace] Background init firing.");
             }
-            await performInit(config, anonKey, "0.2.0");
+            await performInit(config, anonKey, "0.2.3");
             maybeInstallConsoleCapture();
           } catch (err) {
             console.warn(
@@ -1102,7 +3609,7 @@ function registerGlasstrace(options) {
             if (config.verbose) {
               console.info("[glasstrace] Background init firing.");
             }
-            await performInit(config, anonKey, "0.2.0");
+            await performInit(config, anonKey, "0.2.3");
             maybeInstallConsoleCapture();
           } catch (err) {
             console.warn(
@@ -1124,7 +3631,7 @@ function registerGlasstrace(options) {
           if (config.verbose) {
             console.info("[glasstrace] Background init firing.");
           }
-          await performInit(config, anonKeyForInit, "0.2.0");
+          await performInit(config, anonKeyForInit, "0.2.3");
           maybeInstallConsoleCapture();
         } catch (err) {
           console.warn(
@@ -1162,13 +3669,10 @@ function isDiscoveryEnabled(config) {
 }
 
 // src/source-map-uploader.ts
-import * as fs from "fs/promises";
-import * as path from "path";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
 import * as crypto from "crypto";
 import { execSync } from "child_process";
-import {
-  SourceMapUploadResponseSchema
-} from "@glasstrace/protocol";
 async function collectSourceMaps(buildDir) {
   const results = [];
   try {
@@ -1181,18 +3685,18 @@ async function collectSourceMaps(buildDir) {
 async function walkDir(baseDir, currentDir, results) {
   let entries;
   try {
-    entries = await fs.readdir(currentDir, { withFileTypes: true });
+    entries = await fs2.readdir(currentDir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path.join(currentDir, entry.name);
+    const fullPath = path2.join(currentDir, entry.name);
     if (entry.isDirectory()) {
       await walkDir(baseDir, fullPath, results);
     } else if (entry.isFile() && entry.name.endsWith(".map")) {
       try {
-        const content = await fs.readFile(fullPath, "utf-8");
-        const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const content = await fs2.readFile(fullPath, "utf-8");
+        const relativePath = path2.relative(baseDir, fullPath).replace(/\\/g, "/");
         const compiledPath = relativePath.replace(/\.map$/, "");
         results.push({ filePath: compiledPath, content });
       } catch {
@@ -1255,12 +3759,12 @@ function withGlasstraceConfig(nextConfig) {
   config.experimental = { ...existingExperimental, serverSourceMaps: true };
   const distDir = typeof config.distDir === "string" ? config.distDir : ".next";
   const existingWebpack = config.webpack;
-  config.webpack = (webpackConfig, context) => {
+  config.webpack = (webpackConfig, context2) => {
     let result = webpackConfig;
     if (typeof existingWebpack === "function") {
-      result = existingWebpack(webpackConfig, context);
+      result = existingWebpack(webpackConfig, context2);
     }
-    const webpackContext = context;
+    const webpackContext = context2;
     if (!webpackContext.isServer && webpackContext.dev === false) {
       const plugins = result.plugins ?? [];
       plugins.push({
@@ -1309,6 +3813,22 @@ async function handleSourceMapUpload(distDir) {
     );
   }
 }
+
+// src/capture-error.ts
+function captureError(error) {
+  try {
+    const span = trace.getSpan(context.active());
+    if (!span) return;
+    const attributes = {
+      "error.message": String(error)
+    };
+    if (error instanceof Error) {
+      attributes["error.type"] = error.constructor.name;
+    }
+    span.addEvent("glasstrace.error", attributes);
+  } catch {
+  }
+}
 export {
   GlasstraceExporter,
   GlasstraceSpanProcessor,