@bitfab/sdk 0.36.5 → 0.36.7

package/dist/index.cjs

@@ -42,7 +42,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.36.5";
+    __version__ = "0.36.7";
   }
 });
 
@@ -76,33 +76,58 @@ 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
+    })
   );
 }
 var DISABLE_COMPRESSION_ENV, MIN_COMPRESSED_BYTES, gzipNode, _nodeGzipReady;
@@ -247,15 +272,15 @@ function carrierBytesOf(encoded, body) {
   }
   return encoded.length + extra;
 }
-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;
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
@@ -299,7 +324,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) {
@@ -315,30 +340,31 @@ 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(", ")}`
     }
   ];
 }
-var MAX_SPAN_CARRIER_BYTES, textEncoder, MAX_BYTES_PER_UNIT, STRUCTURAL_SPAN_KEYS;
+var MAX_SPAN_CARRIER_BYTES, MAX_COMPRESSIBLE_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;
+    MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES = 78e5;
     textEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder() : null;
     MAX_BYTES_PER_UNIT = 3;
     STRUCTURAL_SPAN_KEYS = /* @__PURE__ */ new Set([
@@ -370,30 +396,31 @@ var init_warnOnce = __esm({
 });
 
 // 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
@@ -650,6 +677,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({
@@ -786,7 +838,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, 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_DECOMPRESSED_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";
@@ -794,6 +846,7 @@ var init_otel = __esm({
     import_core = require("@opentelemetry/core");
     import_resources = require("@opentelemetry/resources");
     import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+    init_compress();
     init_constants();
     init_errors();
     init_payloadBudget();
@@ -805,6 +858,7 @@ var init_otel = __esm({
     PAYLOAD_ATTRIBUTE = "bitfab.payload";
     OTLP_TRACES_ENDPOINT = "/api/sdk/otel/v1/traces";
     MAX_EXPORT_REQUEST_BYTES = 3e6;
+    MAX_DECOMPRESSED_REQUEST_BYTES = 8e6;
     MAX_REQUEST_BYTES_ENV = "BITFAB_OTEL_MAX_REQUEST_BYTES";
     EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
     MAX_QUEUE_SIZE = 8192;
@@ -887,15 +941,43 @@ var init_otel = __esm({
         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(
@@ -923,12 +1005,12 @@ var init_otel = __esm({
        * 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);
@@ -1045,7 +1127,10 @@ var init_otel = __esm({
           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",
@@ -1234,7 +1319,7 @@ var init_http = __esm({
         }
         if (!this.traceTransport) {
           this.traceTransport = createTraceTransport({
-            directSender: (endpoint, body, timeoutMs) => this.sendEncoded(endpoint, body, {
+            directSender: (endpoint, request, timeoutMs) => this.sendPrepared(endpoint, request, {
               timeout: timeoutMs
             })
           });
@@ -1321,13 +1406,16 @@ var init_http = __esm({
        * 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() ?? ""}`
@@ -1801,8 +1889,8 @@ var init_serialize = __esm({
     import_superjson = __toESM(require("superjson"), 1);
     init_payloadBudget();
     init_warnOnce();
-    MAX_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
-    MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_SPAN_CARRIER_BYTES;
+    MAX_SERIALIZED_BYTES = MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
+    MAX_FRAMEWORK_SERIALIZED_BYTES = MAX_COMPRESSIBLE_SPAN_CARRIER_BYTES;
     MAX_SAFE_DEPTH = 6;
   }
 });
@@ -2384,12 +2472,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);
@@ -2476,13 +2565,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;
@@ -2490,18 +2581,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,
@@ -2522,6 +2612,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(
@@ -2584,17 +2698,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;
 }