bitfab 0.34.2 → 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.2";
+    __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,9 +655,6 @@ function spanToOtlp(span) {
   }
   return result;
 }
-function byteLength(value) {
-  return textEncoder ? textEncoder.encode(value).length : value.length;
-}
 function encodeSpan(span) {
   const json = JSON.stringify(spanToOtlp(span));
   return { json, size: byteLength(json) };
@@ -507,7 +730,7 @@ function endSpan(span, 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;
     }
@@ -518,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;
@@ -528,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;
   }
@@ -572,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, 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, textEncoder, SPAN_SEPARATOR_BYTES, OtlpPayloadTooLargeError, OtlpPartialSuccessError, BitfabSpanExporter, 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";
@@ -582,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();
@@ -607,7 +831,6 @@ var init_otel = __esm({
     traceSubmissionSpanIds = /* @__PURE__ */ new Map();
     replayTraceSubmissions = /* @__PURE__ */ new Set();
     submissionCounter = 0;
-    textEncoder = typeof TextEncoder === "undefined" ? void 0 : new TextEncoder();
     SPAN_SEPARATOR_BYTES = 1;
     OtlpPayloadTooLargeError = class extends Error {
     };
@@ -717,7 +940,7 @@ var init_otel = __esm({
               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(
@@ -955,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();
@@ -1111,14 +1335,20 @@ var init_http = __esm({
         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) {
@@ -1567,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;
   }
 });