@bitfab/sdk 0.34.2 → 0.36.1

package/dist/{chunk-SBQQOFA5.js → chunk-6ZBZBR5K.js}

@@ -207,8 +207,78 @@ var BitfabError = class extends Error {
   }
 };
 
+// src/readEnv.ts
+function readEnv(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  return void 0;
+}
+
+// src/compress.ts
+var DISABLE_COMPRESSION_ENV = "BITFAB_DISABLE_COMPRESSION";
+var MIN_COMPRESSED_BYTES = 8192;
+var gzipNode;
+var _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(() => {
+});
+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 })
+  );
+}
+
 // src/version.generated.ts
-var __version__ = "0.34.2";
+var __version__ = "0.36.1";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -279,6 +349,125 @@ function runWithReplayContext(ctx, fn) {
   return fn();
 }
 
+// src/payloadBudget.ts
+var MAX_SPAN_CARRIER_BYTES = 28e5;
+var textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
+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;
+}
+var MAX_BYTES_PER_UNIT = 3;
+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;
+}
+var STRUCTURAL_SPAN_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "type",
+  "function_name",
+  "error_source"
+]);
+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(", ")}`
+    }
+  ];
+}
+
 // src/warnOnce.ts
 var warned = /* @__PURE__ */ new Set();
 function warnOnce(key, message) {
@@ -294,8 +483,37 @@ function warnOnce(key, message) {
 
 // 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) => {
@@ -360,12 +578,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 = [
@@ -379,7 +596,11 @@ function serializePayloadBody(payload) {
         }
       ];
     }
-    return { body: JSON.stringify(sanitized), dropped };
+    return {
+      body: JSON.stringify(sanitized),
+      dropped,
+      value: isRecord ? sanitized : void 0
+    };
   }
 }
 
@@ -395,14 +616,6 @@ import {
   BatchSpanProcessor
 } from "@opentelemetry/sdk-trace-base";
 
-// src/readEnv.ts
-function readEnv(name) {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env[name];
-  }
-  return void 0;
-}
-
 // src/unrefTimer.ts
 function unrefTimer(timer) {
   const handle = timer;
@@ -464,7 +677,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;
     }
@@ -501,14 +714,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) {
@@ -566,10 +779,6 @@ function spanToOtlp(span) {
   }
   return result;
 }
-var textEncoder = typeof TextEncoder === "undefined" ? void 0 : new TextEncoder();
-function byteLength(value) {
-  return textEncoder ? textEncoder.encode(value).length : value.length;
-}
 var SPAN_SEPARATOR_BYTES = 1;
 function encodeSpan(span) {
   const json = JSON.stringify(spanToOtlp(span));
@@ -749,7 +958,7 @@ var BitfabSpanExporter = class {
           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(
@@ -924,7 +1133,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;
     }
@@ -935,8 +1144,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;
@@ -945,7 +1154,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;
   }
@@ -1194,14 +1403,20 @@ var HttpClient = class {
     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) {
@@ -1541,8 +1756,8 @@ function fallbackUuidV4() {
 
 // src/serialize.ts
 import superjson from "superjson";
-var MAX_SERIALIZED_BYTES = 512e3;
-var MAX_FRAMEWORK_SERIALIZED_BYTES = 2e6;
+var MAX_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
+var MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
 function describeValue(value) {
   try {
     const ctorName = value?.constructor?.name;
@@ -2180,4 +2395,4 @@ export {
   reportReplayProgress,
   replay
 };
-//# sourceMappingURL=chunk-SBQQOFA5.js.map
+//# sourceMappingURL=chunk-6ZBZBR5K.js.map