@bitfab/sdk 0.36.5 → 0.36.7

package/dist/{chunk-FLP6CNRE.js → chunk-CFECTUDU.js}

@@ -247,38 +247,63 @@ function toArrayBuffer(view) {
     view.byteOffset + view.byteLength
   );
 }
+function compressedRequest(body, rawBytes, compressed) {
+  if (compressed.byteLength >= rawBytes) {
+    return { body, rawBytes, wireBytes: rawBytes };
+  }
+  return {
+    body: compressed instanceof Uint8Array ? toArrayBuffer(compressed) : compressed,
+    contentEncoding: "gzip",
+    rawBytes,
+    wireBytes: compressed.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 rawBytes = new TextEncoder().encode(body).byteLength;
+    return { body, rawBytes, wireBytes: rawBytes };
   }
   const bytes = new TextEncoder().encode(body);
   if (bytes.byteLength < MIN_COMPRESSED_BYTES) {
-    return { body };
+    return {
+      body,
+      rawBytes: bytes.byteLength,
+      wireBytes: bytes.byteLength
+    };
   }
   if (gzipNode) {
     return gzipNode(bytes).then(
-      (compressed) => ({
-        body: toArrayBuffer(compressed),
-        contentEncoding: "gzip"
-      }),
-      () => ({ body })
+      (compressed) => compressedRequest(body, bytes.byteLength, compressed),
+      () => ({
+        body,
+        rawBytes: bytes.byteLength,
+        wireBytes: bytes.byteLength
+      })
     );
   }
   if (typeof CompressionStream === "undefined") {
-    return { body };
+    return {
+      body,
+      rawBytes: bytes.byteLength,
+      wireBytes: bytes.byteLength
+    };
   }
   return gzipViaStream(bytes).then(
-    (compressed) => ({ body: compressed, contentEncoding: "gzip" }),
-    () => ({ body })
+    (compressed) => compressedRequest(body, bytes.byteLength, compressed),
+    () => ({
+      body,
+      rawBytes: bytes.byteLength,
+      wireBytes: bytes.byteLength
+    })
   );
 }
 
 // src/version.generated.ts
-var __version__ = "0.36.5";
+var __version__ = "0.36.7";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -351,6 +376,7 @@ function runWithReplayContext(ctx, fn) {
 
 // src/payloadBudget.ts
 var MAX_SPAN_CARRIER_BYTES = 28e5;
+var MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES = 78e5;
 var textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
 function byteLength(value) {
   return textEncoder ? textEncoder.encode(value).length : value.length;
@@ -374,15 +400,15 @@ function carrierBytesOf(encoded, body) {
   return encoded.length + extra;
 }
 var MAX_BYTES_PER_UNIT = 3;
-function fitsCarrierBudget(body) {
+function fitsCarrierBudget(body, maxBytes = MAX_SPAN_CARRIER_BYTES) {
   const units = body.length;
-  if (units * MAX_BYTES_PER_UNIT + 2 <= MAX_SPAN_CARRIER_BYTES) {
+  if (units * MAX_BYTES_PER_UNIT + 2 <= maxBytes) {
     return true;
   }
-  if (units + 2 > MAX_SPAN_CARRIER_BYTES) {
+  if (units + 2 > maxBytes) {
     return false;
   }
-  return carrierByteLength(body) <= MAX_SPAN_CARRIER_BYTES;
+  return carrierByteLength(body) <= maxBytes;
 }
 var STRUCTURAL_SPAN_KEYS = /* @__PURE__ */ new Set([
   "name",
@@ -432,7 +458,7 @@ function collectCandidates(containers) {
   }
   return candidates.sort((a, b) => b.size - a.size);
 }
-function trimPayloadToBudget(payload, encode) {
+function trimPayloadToBudget(payload, encode, maxBytes = MAX_SPAN_CARRIER_BYTES) {
   const { copy, containers } = cloneTrimmable(payload);
   const candidates = collectCandidates(containers);
   if (candidates.length === 0) {
@@ -448,20 +474,20 @@ function trimPayloadToBudget(payload, encode) {
     } catch {
       return void 0;
     }
-    if (fitsCarrierBudget(body)) {
+    if (fitsCarrierBudget(body, maxBytes)) {
       return { value: copy, trimmed };
     }
   }
   return void 0;
 }
-function markPayloadTrimmed(value, trimmed) {
+function markPayloadTrimmed(value, trimmed, maxBytes = MAX_SPAN_CARRIER_BYTES) {
   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: ${[
+      error: `trimmed oversized field(s) to fit the ${maxBytes}-byte span carrier budget: ${[
         ...new Set(trimmed)
       ].join(", ")}`
     }
@@ -482,30 +508,31 @@ function warnOnce(key, message) {
 }
 
 // src/serializePayload.ts
-function serializePayloadBody(payload) {
+function serializePayloadBody(payload, maxCarrierBytes = MAX_SPAN_CARRIER_BYTES) {
   const encoded = encodePayloadBody(payload);
-  if (fitsCarrierBudget(encoded.body)) {
+  if (fitsCarrierBudget(encoded.body, maxCarrierBytes)) {
     return { body: encoded.body, dropped: encoded.dropped };
   }
-  return applyPayloadBudget(encoded);
+  return applyPayloadBudget(encoded, maxCarrierBytes);
 }
-function applyPayloadBudget(encoded) {
+function applyPayloadBudget(encoded, maxCarrierBytes) {
   const result = encoded.value ? trimPayloadToBudget(
     encoded.value,
-    (value) => encodePayloadBody(value).body
+    (value) => encodePayloadBody(value).body,
+    maxCarrierBytes
   ) : 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) (${[
+    `a span payload exceeded the ${maxCarrierBytes}-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);
+  markPayloadTrimmed(result.value, result.trimmed, maxCarrierBytes);
   return {
     body: encodePayloadBody(result.value).body,
     dropped: encoded.dropped
@@ -629,6 +656,7 @@ var OPERATION_ATTRIBUTE = "bitfab.operation";
 var PAYLOAD_ATTRIBUTE = "bitfab.payload";
 var OTLP_TRACES_ENDPOINT = "/api/sdk/otel/v1/traces";
 var MAX_EXPORT_REQUEST_BYTES = 3e6;
+var MAX_DECOMPRESSED_REQUEST_BYTES = 8e6;
 var MAX_REQUEST_BYTES_ENV = "BITFAB_OTEL_MAX_REQUEST_BYTES";
 var EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
 var MAX_QUEUE_SIZE = 8192;
@@ -784,6 +812,31 @@ function encodeSpan(span) {
   const json = JSON.stringify(spanToOtlp(span));
   return { json, size: byteLength(json) };
 }
+function trimEncodedSpan(span) {
+  try {
+    const carrier = JSON.parse(span.json);
+    const attribute = carrier.attributes?.find(
+      (entry) => entry.key === PAYLOAD_ATTRIBUTE
+    );
+    const payloadBody = attribute?.value?.stringValue;
+    if (!attribute?.value || payloadBody === void 0) {
+      return void 0;
+    }
+    const payload = JSON.parse(payloadBody);
+    attribute.value.stringValue = serializePayloadBody(
+      payload,
+      MAX_SPAN_CARRIER_BYTES
+    ).body;
+    const json = JSON.stringify(carrier);
+    return { json, size: byteLength(json) };
+  } catch {
+    return void 0;
+  }
+}
+async function prepareRequest(body) {
+  const prepared = encodeRequestBody(body);
+  return prepared instanceof Promise ? await prepared : prepared;
+}
 function requestEnvelope(first) {
   const scope = first.instrumentationScope;
   const resource = JSON.stringify({
@@ -914,15 +967,43 @@ var BitfabSpanExporter = class {
     return batches;
   }
   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(encodeRequest(envelope, batch.spans));
-      return true;
+      let requestSpans = batch.spans;
+      let requestRawBytes = batch.size;
+      let alreadyTrimmed = false;
+      while (true) {
+        if (requestRawBytes <= MAX_DECOMPRESSED_REQUEST_BYTES) {
+          const prepared = await prepareRequest(
+            encodeRequest(envelope, requestSpans)
+          );
+          if (prepared.wireBytes <= this.maxRequestBytes) {
+            await this.sendWithRetries(prepared);
+            return true;
+          }
+        }
+        if (batch.spans.length !== 1) {
+          logError(
+            "an OpenTelemetry span batch exceeded the configured request-size target and could not be exported"
+          );
+          return false;
+        }
+        if (alreadyTrimmed) {
+          logError(
+            "a single OpenTelemetry span exceeded the configured request-size target after trimming"
+          );
+          return false;
+        }
+        const trimmed = trimEncodedSpan(batch.spans[0]);
+        if (!trimmed) {
+          logError(
+            "a single OpenTelemetry span exceeded the configured request-size target and could not be trimmed"
+          );
+          return false;
+        }
+        requestSpans = [trimmed];
+        requestRawBytes = envelope.size + trimmed.size;
+        alreadyTrimmed = true;
+      }
     } catch (error) {
       if (error instanceof OtlpPayloadTooLargeError) {
         logError(
@@ -950,12 +1031,12 @@ var BitfabSpanExporter = class {
    * the server does not yet understand. The fix is a client-supplied
    * idempotency key that ingestion dedupes on.
    */
-  async sendWithRetries(body) {
+  async sendWithRetries(request) {
     for (let attempt = 0; attempt < MAX_SEND_ATTEMPTS; attempt += 1) {
       try {
         const response = await this.directSender(
           OTLP_TRACES_ENDPOINT,
-          body,
+          request,
           EXPORT_TIMEOUT_MILLIS
         );
         const partialSuccess = asRecord2(response?.partialSuccess);
@@ -1072,7 +1153,10 @@ var OtelBatchTransport = class {
       return;
     }
     try {
-      const { body, dropped } = serializePayloadBody(payload);
+      const { body, dropped } = serializePayloadBody(
+        payload,
+        MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES
+      );
       if (dropped.length > 0) {
         warnOnce(
           "otel-carrier-payload-stubbed",
@@ -1311,7 +1395,7 @@ var HttpClient = class {
     }
     if (!this.traceTransport) {
       this.traceTransport = createTraceTransport({
-        directSender: (endpoint, body, timeoutMs) => this.sendEncoded(endpoint, body, {
+        directSender: (endpoint, request, timeoutMs) => this.sendPrepared(endpoint, request, {
           timeout: timeoutMs
         })
       });
@@ -1398,13 +1482,16 @@ var HttpClient = class {
    * same data twice.
    */
   async sendEncoded(endpoint, body, options) {
+    const prepared = encodeRequestBody(body);
+    const encoded = prepared instanceof Promise ? await prepared : prepared;
+    return this.sendPrepared(endpoint, encoded, options);
+  }
+  async sendPrepared(endpoint, encoded, 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() ?? ""}`
@@ -1767,8 +1854,8 @@ function fallbackUuidV4() {
 
 // src/serialize.ts
 import superjson from "superjson";
-var MAX_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
-var MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
+var MAX_SERIALIZED_BYTES = MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
+var MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
 function describeValue(value) {
   try {
     const ctorName = value?.constructor?.name;
@@ -2255,12 +2342,13 @@ function sleep(ms) {
     unrefTimer(timer);
   });
 }
-async function mapWithConcurrency2(tasks, maxConcurrency, onSettled) {
+async function mapWithConcurrency2(tasks, maxConcurrency, onSettled, onStarted) {
   const results = new Array(tasks.length);
   let nextIndex = 0;
   async function worker() {
     while (nextIndex < tasks.length) {
       const index = nextIndex++;
+      onStarted?.(index);
       const result = await tasks[index]();
       results[index] = result;
       onSettled?.(result, index);
@@ -2347,13 +2435,15 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
     )
   );
   const total = tasks.length;
+  const onItemFinish = options?.onItemFinish ?? options?.onProgress;
   let completed = 0;
+  let started = 0;
   let succeeded = 0;
   let errored = 0;
   const resultItems = await mapWithConcurrency2(
     tasks,
     maxConcurrency,
-    options?.onProgress ? (item) => {
+    (item) => {
       completed += 1;
       if (item.error === null) {
         succeeded += 1;
@@ -2361,18 +2451,17 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
         errored += 1;
       }
       try {
-        options?.onProgress?.({
+        onItemFinish?.({
           testRunId,
           completed,
           total,
           succeeded,
           errored,
           item: {
-            // The server replay trace id isn't known until completeReplay
-            // runs (below), so it can't be reported mid-run and we never
-            // emit the client-side placeholder. originalTraceId (the
-            // historical trace) is known now and is what a UI keys on to
-            // identify what just settled.
+            // The server replay trace id isn't known until completeReplay runs
+            // (below), so it can't be reported mid-run and we never emit the
+            // client-side placeholder. originalTraceId (the historical trace)
+            // is known now and is what a UI keys on to identify what settled.
             traceId: null,
             originalTraceId: item.originalTraceId ?? null,
             originalSpanId: item.originalSpanId ?? null,
@@ -2393,6 +2482,30 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
         });
       } catch {
       }
+    },
+    options?.onItemStart ? (index) => {
+      started += 1;
+      const serverItem = serverItems[index];
+      const originalTraceId = serverItem.originalTraceId ?? serverItem.sourceTraceId;
+      const originalSpanId = serverItem.originalSpanId ?? serverItem.sourceSpanId;
+      try {
+        options.onItemStart?.({
+          type: "started",
+          testRunId,
+          started,
+          completed,
+          total,
+          succeeded,
+          errored,
+          item: {
+            originalTraceId,
+            originalSpanId,
+            sourceTraceId: originalTraceId,
+            sourceSpanId: originalSpanId
+          }
+        });
+      } catch {
+      }
     } : void 0
   );
   await preserveReplayFailure(
@@ -2455,17 +2568,19 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
     testRunUrl: fullTestRunUrl
   };
   await writeReplayResultFile(result);
-  try {
-    options?.onProgress?.({
-      type: "complete",
-      testRunId,
-      completed: total,
-      total,
-      succeeded,
-      errored,
-      result
-    });
-  } catch {
+  if (!options?.onItemFinish) {
+    try {
+      options?.onProgress?.({
+        type: "complete",
+        testRunId,
+        completed: total,
+        total,
+        succeeded,
+        errored,
+        result
+      });
+    } catch {
+    }
   }
   return result;
 }
@@ -2521,4 +2636,4 @@ export {
   serializeReplayResult,
   replay
 };
-//# sourceMappingURL=chunk-FLP6CNRE.js.map
+//# sourceMappingURL=chunk-CFECTUDU.js.map