agentv 3.1.0 → 3.2.1

package/dist/esm-QNEMCJPL.js

@@ -0,0 +1,933 @@
+import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
+import {
+  ExportResultCode,
+  getNumberFromEnv,
+  getStringFromEnv,
+  hrTimeToNanoseconds,
+  init_esm as init_esm2,
+  parseKeyPairsIntoRecord
+} from "./chunk-SR4I5KET.js";
+import "./chunk-VQ2ZO7XJ.js";
+import {
+  diag,
+  init_esm
+} from "./chunk-LRULMAAA.js";
+import "./chunk-5H446C7X.js";
+
+// ../../node_modules/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/OTLPExporterBase.js
+var OTLPExporterBase = class {
+  _delegate;
+  constructor(delegate) {
+    this._delegate = delegate;
+  }
+  /**
+   * Export items.
+   * @param items
+   * @param resultCallback
+   */
+  export(items, resultCallback) {
+    this._delegate.export(items, resultCallback);
+  }
+  forceFlush() {
+    return this._delegate.forceFlush();
+  }
+  shutdown() {
+    return this._delegate.shutdown();
+  }
+};
+
+// ../../node_modules/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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
+  };
+}
+function getSharedConfigurationDefaults() {
+  return {
+    timeoutMillis: 1e4,
+    concurrencyLimit: 30,
+    compression: "none"
+  };
+}
+
+// ../../node_modules/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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;
+  }
+  pushPromise(promise) {
+    if (this.hasReachedLimit()) {
+      throw new Error("Concurrency Limit reached");
+    }
+    this._sendingPromises.push(promise);
+    const popPromise = () => {
+      const index = this._sendingPromises.indexOf(promise);
+      void this._sendingPromises.splice(index, 1);
+    };
+    promise.then(popPromise, popPromise);
+  }
+  hasReachedLimit() {
+    return this._sendingPromises.length >= this._concurrencyLimit;
+  }
+  async awaitAll() {
+    await Promise.all(this._sendingPromises);
+  }
+};
+function createBoundedQueueExportPromiseHandler(options) {
+  return new BoundedQueueExportPromiseHandler(options.concurrencyLimit);
+}
+
+// ../../node_modules/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js
+init_esm2();
+
+// ../../node_modules/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/logging-response-handler.js
+init_esm();
+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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/otlp-export-delegate.js
+init_esm();
+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/.bun/@opentelemetry+otlp-transformer@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-transformer@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-transformer/build/esm/common/utils.js
+init_esm2();
+function hrTimeToNanos(hrTime) {
+  const NANOSECONDS = BigInt(1e9);
+  return BigInt(Math.trunc(hrTime[0])) * NANOSECONDS + BigInt(Math.trunc(hrTime[1]));
+}
+function encodeAsString(hrTime) {
+  const nanos = hrTimeToNanos(hrTime);
+  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/.bun/@opentelemetry+otlp-transformer@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-transformer@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/util.js
+init_esm();
+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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
+import * as zlib from "zlib";
+import { Readable } from "stream";
+
+// ../../node_modules/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/version.js
+var VERSION = "0.212.0";
+
+// ../../node_modules/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/transport/http-transport-utils.js
+var DEFAULT_USER_AGENT = `OTel-OTLP-Exporter-JavaScript/${VERSION}`;
+function sendWithHttp(request, url, headers, compression, userAgent, agent, data, onDone, timeoutMillis) {
+  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) {
+        onDone({
+          status: "success",
+          data: Buffer.concat(responseData)
+        });
+      } else if (res.statusCode && isExportHTTPErrorRetryable(res.statusCode)) {
+        onDone({
+          status: "retryable",
+          retryInMillis: parseRetryAfterToMills(res.headers["retry-after"])
+        });
+      } else {
+        const error = new OTLPExporterError(res.statusMessage, res.statusCode, Buffer.concat(responseData).toString());
+        onDone({
+          status: "failure",
+          error
+        });
+      }
+    });
+  });
+  req.setTimeout(timeoutMillis, () => {
+    req.destroy();
+    onDone({
+      status: "retryable",
+      error: new Error("Request timed out")
+    });
+  });
+  req.on("error", (error) => {
+    if (isHttpTransportNetworkErrorRetryable(error)) {
+      onDone({
+        status: "retryable",
+        error
+      });
+    } else {
+      onDone({
+        status: "failure",
+        error
+      });
+    }
+  });
+  compressAndSend(req, compression, data, (error) => {
+    onDone({
+      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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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 new Promise((resolve2) => {
+      sendWithHttp(request, this._parameters.url, headers, this._parameters.compression, this._parameters.userAgent, agent, data, (result) => {
+        resolve2(result);
+      }, 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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/retrying-transport.js
+init_esm();
+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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/shared-env-configuration.js
+init_esm2();
+init_esm();
+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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/convert-legacy-node-http-options.js
+init_esm();
+
+// ../../node_modules/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/node_modules/@opentelemetry/otlp-exporter-base/build/esm/configuration/otlp-node-http-env-configuration.js
+init_esm2();
+init_esm();
+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, path2) {
+  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 += path2;
+  try {
+    new URL(url);
+  } catch {
+    diag.warn(`Configuration: Provided URL appended with '${path2}' 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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+otlp-exporter-base@0.212.0+460773ef8ff1e07c/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/.bun/@opentelemetry+exporter-trace-otlp-http@0.212.0+460773ef8ff1e07c/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));
+  }
+};
+export {
+  OTLPTraceExporter
+};
+//# sourceMappingURL=esm-QNEMCJPL.js.map