bitfab 0.34.1 → 0.36.0

package/dist/index.cjs

@@ -51,7 +51,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.34.1";
+    __version__ = "0.36.0";
   }
 });
 
@@ -65,6 +65,87 @@ var init_constants = __esm({
   }
 });
 
+// src/readEnv.ts
+function readEnv(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  return void 0;
+}
+var init_readEnv = __esm({
+  "src/readEnv.ts"() {
+    "use strict";
+  }
+});
+
+// src/compress.ts
+function toArrayBuffer(view) {
+  return view.buffer.slice(
+    view.byteOffset,
+    view.byteOffset + view.byteLength
+  );
+}
+async function gzipViaStream(bytes) {
+  const stream = new Blob([bytes]).stream().pipeThrough(new CompressionStream("gzip"));
+  return await new Response(stream).arrayBuffer();
+}
+function encodeRequestBody(body) {
+  if (readEnv(DISABLE_COMPRESSION_ENV)) {
+    return { body };
+  }
+  const bytes = new TextEncoder().encode(body);
+  if (bytes.byteLength < MIN_COMPRESSED_BYTES) {
+    return { body };
+  }
+  if (gzipNode) {
+    return gzipNode(bytes).then(
+      (compressed) => ({
+        body: toArrayBuffer(compressed),
+        contentEncoding: "gzip"
+      }),
+      () => ({ body })
+    );
+  }
+  if (typeof CompressionStream === "undefined") {
+    return { body };
+  }
+  return gzipViaStream(bytes).then(
+    (compressed) => ({ body: compressed, contentEncoding: "gzip" }),
+    () => ({ body })
+  );
+}
+var DISABLE_COMPRESSION_ENV, MIN_COMPRESSED_BYTES, gzipNode, _nodeGzipReady;
+var init_compress = __esm({
+  "src/compress.ts"() {
+    "use strict";
+    init_readEnv();
+    DISABLE_COMPRESSION_ENV = "BITFAB_DISABLE_COMPRESSION";
+    MIN_COMPRESSED_BYTES = 8192;
+    _nodeGzipReady = (typeof process !== "undefined" && process.versions?.node ? (
+      // The join trick hides "node:zlib" from static analysis so bundlers that
+      // ban Node.js built-ins don't fail at build time. webpackIgnore tells
+      // webpack/turbopack to emit a native import() so Node.js can resolve the
+      // module at runtime. Same pattern as `asyncStorage.ts`.
+      import(
+        /* webpackIgnore: true */
+        ["node", "zlib"].join(":")
+      ).then(({ gzip }) => {
+        gzipNode = (data) => new Promise((resolve, reject) => {
+          gzip(data, (error, result) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve(result);
+            }
+          });
+        });
+      }).catch(() => {
+      })
+    ) : Promise.resolve()).then(() => {
+    });
+  }
+});
+
 // src/errors.ts
 var BitfabError;
 var init_errors = __esm({
@@ -153,6 +234,131 @@ var init_replayContext = __esm({
   }
 });
 
+// src/payloadBudget.ts
+function byteLength(value) {
+  return textEncoder ? textEncoder.encode(value).length : value.length;
+}
+function carrierByteLength(body) {
+  return carrierBytesOf(textEncoder ? textEncoder.encode(body) : null, body);
+}
+function carrierBytesOf(encoded, body) {
+  if (!encoded) {
+    return body.length + 2;
+  }
+  let extra = 2;
+  for (let i = 0; i < encoded.length; i++) {
+    const byte = encoded[i];
+    if (byte === 34 || byte === 92) {
+      extra += 1;
+    } else if (byte < 32) {
+      extra += byte === 8 || byte === 9 || byte === 10 || byte === 12 || byte === 13 ? 1 : 5;
+    }
+  }
+  return encoded.length + extra;
+}
+function fitsCarrierBudget(body) {
+  const units = body.length;
+  if (units * MAX_BYTES_PER_UNIT + 2 <= MAX_SPAN_CARRIER_BYTES) {
+    return true;
+  }
+  if (units + 2 > MAX_SPAN_CARRIER_BYTES) {
+    return false;
+  }
+  return carrierByteLength(body) <= MAX_SPAN_CARRIER_BYTES;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function cloneTrimmable(payload) {
+  const copy = { ...payload };
+  const containers = [];
+  const spanData = asRecord(copy.span_data);
+  if (spanData) {
+    const clone = { ...spanData };
+    copy.span_data = clone;
+    containers.push(clone);
+  }
+  const rawSpan = asRecord(copy.rawSpan);
+  const rawSpanData = rawSpan && asRecord(rawSpan.span_data);
+  if (rawSpan && rawSpanData) {
+    const clone = { ...rawSpanData };
+    copy.rawSpan = { ...rawSpan, span_data: clone };
+    containers.push(clone);
+  }
+  if (containers.length === 0) {
+    containers.push(copy);
+  }
+  return { copy, containers };
+}
+function collectCandidates(containers) {
+  const candidates = [];
+  for (const container of containers) {
+    for (const [key, value] of Object.entries(container)) {
+      if (STRUCTURAL_SPAN_KEYS.has(key) || value == null) {
+        continue;
+      }
+      let size;
+      try {
+        size = byteLength(JSON.stringify(value) ?? "");
+      } catch {
+        continue;
+      }
+      candidates.push({ container, key, size });
+    }
+  }
+  return candidates.sort((a, b) => b.size - a.size);
+}
+function trimPayloadToBudget(payload, encode) {
+  const { copy, containers } = cloneTrimmable(payload);
+  const candidates = collectCandidates(containers);
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  const trimmed = [];
+  for (const candidate of candidates) {
+    candidate.container[candidate.key] = `<unserializable: too_large_${candidate.size}_bytes>`;
+    trimmed.push(candidate.key);
+    let body;
+    try {
+      body = encode(copy);
+    } catch {
+      return void 0;
+    }
+    if (fitsCarrierBudget(body)) {
+      return { value: copy, trimmed };
+    }
+  }
+  return void 0;
+}
+function markPayloadTrimmed(value, trimmed) {
+  const existing = Array.isArray(value.errors) ? value.errors : [];
+  value.errors = [
+    ...existing,
+    {
+      source: "sdk",
+      step: "payload_budget",
+      error: `trimmed oversized field(s) to fit the ${MAX_SPAN_CARRIER_BYTES}-byte span carrier budget: ${[
+        ...new Set(trimmed)
+      ].join(", ")}`
+    }
+  ];
+}
+var MAX_SPAN_CARRIER_BYTES, textEncoder, MAX_BYTES_PER_UNIT, STRUCTURAL_SPAN_KEYS;
+var init_payloadBudget = __esm({
+  "src/payloadBudget.ts"() {
+    "use strict";
+    MAX_SPAN_CARRIER_BYTES = 28e5;
+    textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+    MAX_BYTES_PER_UNIT = 3;
+    STRUCTURAL_SPAN_KEYS = /* @__PURE__ */ new Set([
+      "name",
+      "type",
+      "function_name",
+      "error_source"
+    ]);
+  }
+});
+
 // src/warnOnce.ts
 function warnOnce(key, message) {
   if (warned.has(key)) {
@@ -174,8 +380,37 @@ var init_warnOnce = __esm({
 
 // src/serializePayload.ts
 function serializePayloadBody(payload) {
+  const encoded = encodePayloadBody(payload);
+  if (fitsCarrierBudget(encoded.body)) {
+    return { body: encoded.body, dropped: encoded.dropped };
+  }
+  return applyPayloadBudget(encoded);
+}
+function applyPayloadBudget(encoded) {
+  const result = encoded.value ? trimPayloadToBudget(
+    encoded.value,
+    (value) => encodePayloadBody(value).body
+  ) : void 0;
+  if (!result) {
+    return { body: encoded.body, dropped: encoded.dropped };
+  }
+  warnOnce(
+    "payload:over-budget",
+    `a span payload exceeded the ${MAX_SPAN_CARRIER_BYTES}-byte carrier budget; its largest field(s) (${[
+      ...new Set(result.trimmed)
+    ].join(
+      ", "
+    )}) were replaced with placeholders so the span still ships. The span is incomplete and may not be replayable.`
+  );
+  markPayloadTrimmed(result.value, result.trimmed);
+  return {
+    body: encodePayloadBody(result.value).body,
+    dropped: encoded.dropped
+  };
+}
+function encodePayloadBody(payload) {
   try {
-    return { body: JSON.stringify(payload), dropped: [] };
+    return { body: JSON.stringify(payload), dropped: [], value: payload };
   } catch {
     const dropped = [];
     const sanitize = (value, seen) => {
@@ -240,12 +475,11 @@ function serializePayloadBody(payload) {
       sanitized = sanitize(payload, /* @__PURE__ */ new WeakSet());
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      return {
-        body: JSON.stringify({ error: `payload_serialize_failed: ${message}` }),
-        dropped
-      };
+      const marker = { error: `payload_serialize_failed: ${message}` };
+      return { body: JSON.stringify(marker), dropped, value: marker };
     }
-    if (dropped.length > 0 && typeof sanitized === "object" && sanitized !== null && !Array.isArray(sanitized)) {
+    const isRecord = typeof sanitized === "object" && sanitized !== null && !Array.isArray(sanitized);
+    if (dropped.length > 0 && isRecord) {
       const obj = sanitized;
       const existing = Array.isArray(obj.errors) ? obj.errors : [];
       obj.errors = [
@@ -259,29 +493,21 @@ function serializePayloadBody(payload) {
         }
       ];
     }
-    return { body: JSON.stringify(sanitized), dropped };
+    return {
+      body: JSON.stringify(sanitized),
+      dropped,
+      value: isRecord ? sanitized : void 0
+    };
   }
 }
 var init_serializePayload = __esm({
   "src/serializePayload.ts"() {
     "use strict";
+    init_payloadBudget();
     init_warnOnce();
   }
 });
 
-// src/readEnv.ts
-function readEnv(name) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[name];
-  }
-  return void 0;
-}
-var init_readEnv = __esm({
-  "src/readEnv.ts"() {
-    "use strict";
-  }
-});
-
 // src/unrefTimer.ts
 function unrefTimer(timer) {
   const handle = timer;
@@ -327,7 +553,7 @@ function recordTraceSubmission(operation, payload) {
     return;
   }
   if (operation === "external_span") {
-    const rawSpan = asRecord(payload.rawSpan);
+    const rawSpan = asRecord2(payload.rawSpan);
     if (typeof rawSpan?.id !== "string") {
       submissionCounter += 1;
     }
@@ -364,14 +590,14 @@ function takeReplaySpanCounts(traceIds) {
   }
   return counts;
 }
-function asRecord(value) {
+function asRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function resolveSourceTraceId(payload) {
   if (typeof payload.sourceTraceId === "string") {
     return payload.sourceTraceId;
   }
-  const rawTrace = asRecord(payload.externalTrace) ?? asRecord(payload.rawTrace);
+  const rawTrace = asRecord2(payload.externalTrace) ?? asRecord2(payload.rawTrace);
   return typeof rawTrace?.id === "string" ? rawTrace.id : void 0;
 }
 function otlpValue(value) {
@@ -429,32 +655,27 @@ function spanToOtlp(span) {
   }
   return result;
 }
-function buildOtlpRequest(first, spans) {
+function encodeSpan(span) {
+  const json = JSON.stringify(spanToOtlp(span));
+  return { json, size: byteLength(json) };
+}
+function requestEnvelope(first) {
   const scope = first.instrumentationScope;
-  return {
-    resourceSpans: [
-      {
-        resource: {
-          attributes: otlpAttributes(
-            first.resource.attributes
-          )
-        },
-        scopeSpans: [
-          {
-            scope: { name: scope.name, version: scope.version ?? "" },
-            spans
-          }
-        ]
-      }
-    ]
-  };
+  const resource = JSON.stringify({
+    attributes: otlpAttributes(
+      first.resource.attributes
+    )
+  });
+  const scopeJson = JSON.stringify({
+    name: scope.name,
+    version: scope.version ?? ""
+  });
+  const head = `{"resourceSpans":[{"resource":${resource},"scopeSpans":[{"scope":${scopeJson},"spans":[`;
+  const tail = "]}]}]}";
+  return { head, tail, size: byteLength(head) + byteLength(tail) };
 }
-function encodedSize(value) {
-  const json = JSON.stringify(value);
-  if (typeof TextEncoder !== "undefined") {
-    return new TextEncoder().encode(json).length;
-  }
-  return json.length;
+function encodeRequest(envelope, spans) {
+  return envelope.head + spans.map((span) => span.json).join(",") + envelope.tail;
 }
 function delay(ms) {
   return new Promise((resolve) => {
@@ -504,16 +725,12 @@ function isRetryable(error) {
   }
   return RETRYABLE_STATUSES.has(status) || status >= 500;
 }
-function normalizeCollectorEndpoint(endpoint) {
-  const trimmed = endpoint.replace(/\/+$/, "");
-  return trimmed.endsWith("/v1/traces") ? trimmed : `${trimmed}/v1/traces`;
-}
 function endSpan(span, endTime) {
   span.end(endTime);
 }
 function spanName(operation, payload) {
   if (operation === "external_span") {
-    const spanData = asRecord(asRecord(payload.rawSpan)?.span_data);
+    const spanData = asRecord2(asRecord2(payload.rawSpan)?.span_data);
     if (typeof spanData?.name === "string") {
       return spanData.name;
     }
@@ -524,8 +741,8 @@ function spanName(operation, payload) {
   return `bitfab.${operation}`;
 }
 function payloadTimestamp(payload, field) {
-  const rawSpan = asRecord(payload.rawSpan);
-  const rawTrace = asRecord(payload.externalTrace) ?? asRecord(payload.rawTrace);
+  const rawSpan = asRecord2(payload.rawSpan);
+  const rawTrace = asRecord2(payload.externalTrace) ?? asRecord2(payload.rawTrace);
   const raw = rawSpan?.[field] ?? rawTrace?.[field];
   if (typeof raw !== "string") {
     return void 0;
@@ -534,7 +751,7 @@ function payloadTimestamp(payload, field) {
   return Number.isNaN(parsed) ? void 0 : parsed;
 }
 function hasError(payload) {
-  const spanData = asRecord(asRecord(payload.rawSpan)?.span_data);
+  const spanData = asRecord2(asRecord2(payload.rawSpan)?.span_data);
   if (spanData?.error != null) {
     return true;
   }
@@ -544,7 +761,6 @@ function hasError(payload) {
 function createOtelTransport(options) {
   return new OtelBatchTransport({
     ...options,
-    collectorEndpoint: readEnv(COLLECTOR_ENDPOINT_ENV) || void 0,
     exportConcurrency: readBoundedIntEnv(
       EXPORT_CONCURRENCY_ENV,
       MAX_EXPORT_CONCURRENCY,
@@ -579,7 +795,7 @@ function shutdownOtelTransports(timeoutMs = DEFAULT_LIFECYCLE_TIMEOUT_MS) {
     (transport, remaining) => transport.shutdown(remaining)
   );
 }
-var import_api, import_core, import_resources, import_sdk_trace_base, OPERATION_ATTRIBUTE, PAYLOAD_ATTRIBUTE, OTLP_TRACES_ENDPOINT, MAX_EXPORT_REQUEST_BYTES, MAX_REQUEST_BYTES_ENV, EXPORT_CONCURRENCY_ENV, COLLECTOR_ENDPOINT_ENV, MAX_QUEUE_SIZE, DIRECT_MAX_EXPORT_BATCH_SIZE, COLLECTOR_MAX_EXPORT_BATCH_SIZE, DIRECT_MAX_REQUEST_BATCH_SIZE, DEFAULT_EXPORT_CONCURRENCY, MAX_EXPORT_CONCURRENCY, SCHEDULE_DELAY_MILLIS, EXPORT_TIMEOUT_MILLIS, RETRY_DELAY_MILLIS, MAX_SEND_ATTEMPTS, DEFAULT_LIFECYCLE_TIMEOUT_MS, RETRYABLE_STATUSES, liveTransports, traceSubmissionSpanIds, replayTraceSubmissions, submissionCounter, OtlpPayloadTooLargeError, OtlpPartialSuccessError, BitfabSpanExporter, CollectorSpanExporter, DeliveryTrackingExporter, OtelBatchTransport;
+var import_api, import_core, import_resources, import_sdk_trace_base, OPERATION_ATTRIBUTE, PAYLOAD_ATTRIBUTE, OTLP_TRACES_ENDPOINT, MAX_EXPORT_REQUEST_BYTES, MAX_REQUEST_BYTES_ENV, EXPORT_CONCURRENCY_ENV, MAX_QUEUE_SIZE, DIRECT_MAX_EXPORT_BATCH_SIZE, DIRECT_MAX_REQUEST_BATCH_SIZE, DEFAULT_EXPORT_CONCURRENCY, MAX_EXPORT_CONCURRENCY, SCHEDULE_DELAY_MILLIS, EXPORT_TIMEOUT_MILLIS, RETRY_DELAY_MILLIS, MAX_SEND_ATTEMPTS, DEFAULT_LIFECYCLE_TIMEOUT_MS, RETRYABLE_STATUSES, liveTransports, traceSubmissionSpanIds, replayTraceSubmissions, submissionCounter, SPAN_SEPARATOR_BYTES, OtlpPayloadTooLargeError, OtlpPartialSuccessError, BitfabSpanExporter, DeliveryTrackingExporter, OtelBatchTransport;
 var init_otel = __esm({
   "src/otel.ts"() {
     "use strict";
@@ -589,6 +805,7 @@ var init_otel = __esm({
     import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
     init_constants();
     init_errors();
+    init_payloadBudget();
     init_readEnv();
     init_serializePayload();
     init_unrefTimer();
@@ -599,10 +816,8 @@ var init_otel = __esm({
     MAX_EXPORT_REQUEST_BYTES = 3e6;
     MAX_REQUEST_BYTES_ENV = "BITFAB_OTEL_MAX_REQUEST_BYTES";
     EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
-    COLLECTOR_ENDPOINT_ENV = "BITFAB_OTEL_EXPORTER_ENDPOINT";
     MAX_QUEUE_SIZE = 8192;
     DIRECT_MAX_EXPORT_BATCH_SIZE = 512;
-    COLLECTOR_MAX_EXPORT_BATCH_SIZE = 32;
     DIRECT_MAX_REQUEST_BATCH_SIZE = 8;
     DEFAULT_EXPORT_CONCURRENCY = 32;
     MAX_EXPORT_CONCURRENCY = 64;
@@ -616,6 +831,7 @@ var init_otel = __esm({
     traceSubmissionSpanIds = /* @__PURE__ */ new Map();
     replayTraceSubmissions = /* @__PURE__ */ new Set();
     submissionCounter = 0;
+    SPAN_SEPARATOR_BYTES = 1;
     OtlpPayloadTooLargeError = class extends Error {
     };
     OtlpPartialSuccessError = class extends Error {
@@ -644,57 +860,55 @@ var init_otel = __esm({
           return true;
         }
         let encoded;
+        let envelope;
         try {
-          encoded = spans.map(spanToOtlp);
+          encoded = spans.map(encodeSpan);
+          envelope = requestEnvelope(spans[0]);
         } catch (error) {
           logError("failed to encode an OpenTelemetry span batch", error);
           return false;
         }
-        const first = spans[0];
-        const batches = this.buildRequestBatches(first, encoded);
+        const batches = this.buildRequestBatches(envelope, encoded);
         const results = await mapWithConcurrency(
           batches,
           this.exportConcurrency,
-          (batch) => this.send(first, batch)
+          (batch) => this.send(envelope, batch)
         );
         return results.every(Boolean);
       }
-      buildRequestBatches(first, spans) {
+      buildRequestBatches(envelope, spans) {
         const batches = [];
         let current = [];
+        let size = envelope.size;
         for (const span of spans) {
-          if (current.length >= this.maxRequestBatchSize) {
-            batches.push(current);
+          const addition = span.size + (current.length > 0 ? SPAN_SEPARATOR_BYTES : 0);
+          if (current.length > 0 && (current.length >= this.maxRequestBatchSize || size + addition > this.maxRequestBytes)) {
+            batches.push({ spans: current, size });
             current = [];
+            size = envelope.size;
           }
-          const candidate = [...current, span];
-          if (current.length > 0 && encodedSize(buildOtlpRequest(first, candidate)) > this.maxRequestBytes) {
-            batches.push(current);
-            current = [span];
-          } else {
-            current = candidate;
-          }
+          current.push(span);
+          size += span.size + (current.length > 1 ? SPAN_SEPARATOR_BYTES : 0);
         }
         if (current.length > 0) {
-          batches.push(current);
+          batches.push({ spans: current, size });
         }
         return batches;
       }
-      async send(first, spans) {
-        const payload = buildOtlpRequest(first, spans);
-        if (encodedSize(payload) > this.maxRequestBytes) {
+      async send(envelope, batch) {
+        if (batch.size > this.maxRequestBytes) {
           logError(
             "a single OpenTelemetry span exceeded the configured request-size target and could not be exported"
           );
           return false;
         }
         try {
-          await this.sendWithRetries(payload);
+          await this.sendWithRetries(encodeRequest(envelope, batch.spans));
           return true;
         } catch (error) {
           if (error instanceof OtlpPayloadTooLargeError) {
             logError(
-              spans.length === 1 ? "a single OpenTelemetry span exceeded the ingestion request limit and could not be exported" : "an OpenTelemetry span batch exceeded the ingestion request limit and could not be exported"
+              batch.spans.length === 1 ? "a single OpenTelemetry span exceeded the ingestion request limit and could not be exported" : "an OpenTelemetry span batch exceeded the ingestion request limit and could not be exported"
             );
             return false;
           }
@@ -718,15 +932,15 @@ var init_otel = __esm({
        * the server does not yet understand. The fix is a client-supplied
        * idempotency key that ingestion dedupes on.
        */
-      async sendWithRetries(payload) {
+      async sendWithRetries(body) {
         for (let attempt = 0; attempt < MAX_SEND_ATTEMPTS; attempt += 1) {
           try {
             const response = await this.directSender(
               OTLP_TRACES_ENDPOINT,
-              payload,
+              body,
               EXPORT_TIMEOUT_MILLIS
             );
-            const partialSuccess = asRecord(response?.partialSuccess);
+            const partialSuccess = asRecord2(response?.partialSuccess);
             const rejected = partialSuccess?.rejectedSpans;
             if (rejected !== void 0 && rejected !== "0" && rejected !== 0) {
               logError(
@@ -754,115 +968,6 @@ var init_otel = __esm({
       async forceFlush() {
       }
     };
-    CollectorSpanExporter = class {
-      constructor(endpoint, apiKey, maxRequestBytes) {
-        this.endpoint = endpoint;
-        this.apiKey = apiKey;
-        this.maxRequestBytes = maxRequestBytes;
-      }
-      /**
-       * Loaded through a dynamic import rather than a top-level one so bundlers
-       * code-split it: Collector delivery is opt-in, and a consumer who never sets
-       * an endpoint should not pay for the exporter in their initial bundle. It is
-       * a hard dependency, so this cannot fail for want of the package.
-       */
-      loadExporterModule() {
-        if (!this.pendingModule) {
-          this.pendingModule = import("@opentelemetry/exporter-trace-otlp-proto");
-        }
-        return this.pendingModule;
-      }
-      export(spans, resultCallback) {
-        void this.exportAsync(spans).then(
-          (succeeded) => {
-            resultCallback({
-              code: succeeded ? import_core.ExportResultCode.SUCCESS : import_core.ExportResultCode.FAILED
-            });
-          },
-          (error) => {
-            resultCallback({ code: import_core.ExportResultCode.FAILED, error });
-          }
-        );
-      }
-      async exportAsync(spans) {
-        if (spans.length === 0) {
-          return true;
-        }
-        let delegate;
-        try {
-          delegate = await this.resolveDelegate();
-        } catch (error) {
-          logError("failed to build the OTLP Collector exporter", error);
-          return false;
-        }
-        const results = await Promise.all(
-          this.partition(spans).map(
-            (batch) => new Promise((resolve) => {
-              try {
-                delegate.export(batch, (result) => {
-                  resolve(result.code === import_core.ExportResultCode.SUCCESS);
-                });
-              } catch (error) {
-                logError("Collector export threw", error);
-                resolve(false);
-              }
-            })
-          )
-        );
-        return results.every(Boolean);
-      }
-      /**
-       * Partition by the encoded JSON size of each carrier rather than its encoded
-       * protobuf size. Protobuf is strictly smaller than the equivalent JSON for
-       * these payloads, so the JSON figure is a conservative bound that keeps every
-       * request under the target without pulling `@opentelemetry/otlp-transformer`
-       * into the dependency set purely to measure bytes.
-       */
-      partition(spans) {
-        const batches = [];
-        let current = [];
-        let currentSize = 0;
-        for (const span of spans) {
-          const size = encodedSize(spanToOtlp(span));
-          if (current.length > 0 && currentSize + size > this.maxRequestBytes) {
-            batches.push(current);
-            current = [];
-            currentSize = 0;
-          }
-          current.push(span);
-          currentSize += size;
-        }
-        if (current.length > 0) {
-          batches.push(current);
-        }
-        return batches;
-      }
-      async resolveDelegate() {
-        const apiKey = this.apiKey() ?? "";
-        if (this.delegate && this.delegateApiKey === apiKey) {
-          return this.delegate;
-        }
-        const { OTLPTraceExporter } = await this.loadExporterModule();
-        const previous = this.delegate;
-        this.delegate = new OTLPTraceExporter({
-          url: this.endpoint,
-          headers: { Authorization: `Bearer ${apiKey}` },
-          timeoutMillis: EXPORT_TIMEOUT_MILLIS
-        });
-        this.delegateApiKey = apiKey;
-        if (previous) {
-          void previous.shutdown().catch(() => {
-          });
-        }
-        return this.delegate;
-      }
-      async shutdown() {
-        await this.delegate?.shutdown();
-      }
-      async forceFlush() {
-        await this.delegate?.forceFlush?.();
-      }
-    };
     DeliveryTrackingExporter = class {
       constructor(exporter) {
         this.exporter = exporter;
@@ -905,27 +1010,22 @@ var init_otel = __esm({
     OtelBatchTransport = class {
       constructor(options) {
         this.closed = false;
-        const collectorEndpoint = options.collectorEndpoint;
         const maxRequestBytes = options.maxRequestBytes ?? MAX_EXPORT_REQUEST_BYTES;
         const maxRequestBatchSize = options.maxRequestBatchSize ?? DIRECT_MAX_REQUEST_BATCH_SIZE;
         if (maxRequestBatchSize <= 0) {
           throw new BitfabError("maxRequestBatchSize must be a positive integer");
         }
         this.deliveryTracker = new DeliveryTrackingExporter(
-          collectorEndpoint === void 0 ? new BitfabSpanExporter(
+          new BitfabSpanExporter(
             options.directSender,
             maxRequestBytes,
             maxRequestBatchSize,
             options.exportConcurrency ?? DEFAULT_EXPORT_CONCURRENCY
-          ) : new CollectorSpanExporter(
-            normalizeCollectorEndpoint(collectorEndpoint),
-            options.apiKey,
-            maxRequestBytes
           )
         );
         this.processor = new import_sdk_trace_base.BatchSpanProcessor(this.deliveryTracker, {
           maxQueueSize: options.maxQueueSize ?? MAX_QUEUE_SIZE,
-          maxExportBatchSize: options.maxExportBatchSize ?? (collectorEndpoint === void 0 ? DIRECT_MAX_EXPORT_BATCH_SIZE : COLLECTOR_MAX_EXPORT_BATCH_SIZE),
+          maxExportBatchSize: options.maxExportBatchSize ?? DIRECT_MAX_EXPORT_BATCH_SIZE,
           scheduledDelayMillis: SCHEDULE_DELAY_MILLIS,
           exportTimeoutMillis: options.exportTimeoutMillis ?? EXPORT_TIMEOUT_MILLIS
         });
@@ -1078,6 +1178,7 @@ var REPLAY_DB_BRANCH_REQUEST_TIMEOUT_MS, EXIT_FLUSH_TIMEOUT_MS, DEFAULT_LIFECYCL
 var init_http = __esm({
   "src/http.ts"() {
     "use strict";
+    init_compress();
     init_constants();
     init_errors();
     init_replayContext();
@@ -1142,8 +1243,7 @@ var init_http = __esm({
         }
         if (!this.traceTransport) {
           this.traceTransport = createTraceTransport({
-            apiKey: () => this.resolveApiKey(),
-            directSender: (endpoint, payload, timeoutMs) => this.request(endpoint, payload, {
+            directSender: (endpoint, body, timeoutMs) => this.sendEncoded(endpoint, body, {
               timeout: timeoutMs
             })
           });
@@ -1213,11 +1313,6 @@ var init_http = __esm({
        * @throws {BitfabError} If the request fails
        */
       async request(endpoint, payload, options) {
-        const url = `${this.serviceUrl}${endpoint}`;
-        const timeout = options?.timeout ?? this.timeout;
-        const method = options?.method ?? "POST";
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
         const { body, dropped } = serializePayloadBody(payload);
         if (dropped.length > 0) {
           try {
@@ -1227,14 +1322,33 @@ var init_http = __esm({
           } catch {
           }
         }
+        return this.sendEncoded(endpoint, body, options);
+      }
+      /**
+       * POST an already-encoded body. The span transport encodes its own batches,
+       * so routing them back through {@link HttpClient.request} would encode the
+       * same data twice.
+       */
+      async sendEncoded(endpoint, body, options) {
+        const url = `${this.serviceUrl}${endpoint}`;
+        const timeout = options?.timeout ?? this.timeout;
+        const method = options?.method ?? "POST";
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        const prepared = encodeRequestBody(body);
+        const encoded = prepared instanceof Promise ? await prepared : prepared;
+        const headers = {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.resolveApiKey() ?? ""}`
+        };
+        if (encoded.contentEncoding) {
+          headers["Content-Encoding"] = encoded.contentEncoding;
+        }
         try {
           const response = await fetch(url, {
             method,
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${this.resolveApiKey() ?? ""}`
-            },
-            body,
+            headers,
+            body: encoded.body,
             signal: controller.signal
           });
           if (!response.ok) {
@@ -1683,9 +1797,10 @@ var init_serialize = __esm({
   "src/serialize.ts"() {
     "use strict";
     import_superjson = __toESM(require("superjson"), 1);
+    init_payloadBudget();
     init_warnOnce();
-    MAX_SERIALIZED_BYTES = 512e3;
-    MAX_FRAMEWORK_SERIALIZED_BYTES = 2e6;
+    MAX_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
+    MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
     MAX_SAFE_DEPTH = 6;
   }
 });