@bitfab/sdk 0.36.8 → 0.36.10

package/dist/{chunk-QUX6N7ON.js → chunk-AAMRJGZJ.js}

@@ -304,7 +304,7 @@ function encodeRequestBody(body) {
 }
 
 // src/version.generated.ts
-var __version__ = "0.36.8";
+var __version__ = "0.36.10";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
@@ -1503,6 +1503,10 @@ var HttpClient = class {
         ...error instanceof BitfabError && error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {}
       });
     }
+    const serverTraceIds = asPayloadRecord(response?.traceIds);
+    if (serverTraceIds !== void 0) {
+      this.recordServerTraceIds(serverTraceIds);
+    }
     const partialSuccess = asPayloadRecord(response?.partialSuccess);
     const rejected = partialSuccess?.rejectedSpans;
     if (rejected !== void 0 && rejected !== "0" && rejected !== 0) {
@@ -1527,6 +1531,14 @@ var HttpClient = class {
       }
     }
   }
+  /**
+   * The server's assigned `traces.id` for a tracked trace if it has already
+   * been read back off an ingest response, without stopping tracking. Lets a
+   * replay surface the id mid-run for items whose spans already landed.
+   */
+  peekServerTraceId(traceId) {
+    return this.traceDeliveries.get(traceId)?.serverTraceId;
+  }
   /** Whether any tracked trace has had its closing carrier submitted. */
   hasClosedDeliveries(traceIds) {
     return traceIds.some((traceId) => this.traceDeliveries.get(traceId)?.closed);
@@ -1553,7 +1565,8 @@ var HttpClient = class {
         closed: delivery.closed,
         delivered: delivery.closingAcked && [...delivery.submittedSpanIds].every(
           (spanId) => delivery.ackedSpanIds.has(spanId)
-        )
+        ),
+        serverTraceId: delivery.serverTraceId
       };
     }
     return reports;
@@ -1582,6 +1595,23 @@ var HttpClient = class {
    * delivered ref is proof its row exists: the same fact the replay status
    * endpoint would report, already in hand.
    */
+  /**
+   * Record the server's assigned `traces.id` for each tracked source trace,
+   * read back from the OTLP ingest response. Keyed by source trace id, the same
+   * key the delivery ledger uses. Untracked ids are ignored.
+   */
+  recordServerTraceIds(map) {
+    for (const [sourceTraceId, serverTraceId] of Object.entries(map)) {
+      if (typeof serverTraceId !== "string") {
+        continue;
+      }
+      const delivery = this.traceDeliveries.get(sourceTraceId);
+      if (delivery === void 0) {
+        continue;
+      }
+      delivery.serverTraceId = serverTraceId;
+    }
+  }
   recordDeliveredCarriers(refs) {
     for (const ref of refs) {
       const delivery = this.traceDeliveries.get(ref.traceId);
@@ -2511,13 +2541,17 @@ async function waitForReplayPersistence(httpClient, testRunId, replayedTraceIds)
   }
   if (!httpClient.hasClosedDeliveries(replayedTraceIds)) {
     httpClient.takeTraceDeliveries(replayedTraceIds);
-    return;
+    return {};
   }
   const flushed = await flushTraces(REPLAY_PERSISTENCE_TIMEOUT_MS);
   const deliveries = httpClient.takeTraceDeliveries(replayedTraceIds);
   const expectedSpanCounts = {};
+  const readBackTraceIds = {};
   let allDelivered = true;
   for (const [traceId, delivery] of Object.entries(deliveries)) {
+    if (delivery.serverTraceId !== void 0) {
+      readBackTraceIds[traceId] = delivery.serverTraceId;
+    }
     if (!delivery.closed) {
       continue;
     }
@@ -2525,7 +2559,7 @@ async function waitForReplayPersistence(httpClient, testRunId, replayedTraceIds)
     allDelivered = allDelivered && delivery.delivered;
   }
   if (allDelivered) {
-    return;
+    return readBackTraceIds;
   }
   const deadline = Date.now() + REPLAY_PERSISTENCE_TIMEOUT_MS;
   let missing = Object.keys(expectedSpanCounts).length;
@@ -2539,22 +2573,23 @@ async function waitForReplayPersistence(httpClient, testRunId, replayedTraceIds)
       (traceId) => ready[traceId] === void 0
     ).length;
     if (missing === 0) {
-      return;
+      return readBackTraceIds;
     }
     if (Date.now() >= deadline) {
       break;
     }
-    await sleep(Math.min(100, Math.max(0, deadline - Date.now())));
+    await sleepForReplayPersistence(
+      Math.min(100, Math.max(0, deadline - Date.now()))
+    );
   }
   const cause = flushed ? "" : " Delivery was also not confirmed before the flush deadline, so the spans likely never reached the server.";
   throw new BitfabError(
     `Replay traces were not fully persisted before the delivery deadline (testRunId ${testRunId}, missing ${missing} of ${Object.keys(expectedSpanCounts).length} trace(s)).${cause}`
   );
 }
-function sleep(ms) {
+function sleepForReplayPersistence(ms) {
   return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    unrefTimer(timer);
+    setTimeout(resolve, ms);
   });
 }
 async function mapWithConcurrency2(tasks, maxConcurrency, onSettled, onStarted) {
@@ -2566,7 +2601,7 @@ async function mapWithConcurrency2(tasks, maxConcurrency, onSettled, onStarted)
       onStarted?.(index);
       const result = await tasks[index]();
       results[index] = result;
-      onSettled?.(result, index);
+      await onSettled?.(result, index);
     }
   }
   const workers = Array.from(
@@ -2656,10 +2691,36 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
   let started = 0;
   let succeeded = 0;
   let errored = 0;
+  let flushInFlight = null;
+  let flushPending = false;
+  const flushFinishedItemTrace = () => {
+    flushPending = true;
+    if (!flushInFlight) {
+      flushInFlight = (async () => {
+        try {
+          while (flushPending) {
+            flushPending = false;
+            await httpClient.settleDeferredWork(REPLAY_PERSISTENCE_TIMEOUT_MS);
+            await flushTraces(REPLAY_PERSISTENCE_TIMEOUT_MS);
+          }
+        } finally {
+          flushInFlight = null;
+        }
+      })();
+    }
+    return flushInFlight;
+  };
   const resultItems = await mapWithConcurrency2(
     tasks,
     maxConcurrency,
-    (item) => {
+    async (item, index) => {
+      let serverTraceId = null;
+      try {
+        await flushFinishedItemTrace();
+        serverTraceId = httpClient.peekServerTraceId(replayedTraceIds[index]) ?? null;
+      } catch {
+      }
+      item.traceId = serverTraceId;
       completed += 1;
       if (item.error === null) {
         succeeded += 1;
@@ -2674,11 +2735,12 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
           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 settled.
-            traceId: null,
+            // The server's assigned traces.id, read back off the ingest
+            // response and surfaced as this item finishes. Null only if the
+            // per-item flush could not confirm delivery in time; the end-of-run
+            // barrier then fills the returned ReplayItem. The client-side
+            // placeholder is never surfaced.
+            traceId: serverTraceId,
             originalTraceId: item.originalTraceId ?? null,
             originalSpanId: item.originalSpanId ?? null,
             // Deprecated aliases for originalTraceId/originalSpanId.
@@ -2724,12 +2786,19 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       }
     } : void 0
   );
-  await preserveReplayFailure(
+  const deliveredTraceIds = await preserveReplayFailure(
     () => waitForReplayPersistence(httpClient, testRunId, replayedTraceIds),
     resultItems,
     testRunId,
     fullTestRunUrl
   );
+  for (let index = 0; index < resultItems.length; index += 1) {
+    const localId = replayedTraceIds[index];
+    const readBack = localId ? deliveredTraceIds[localId] : void 0;
+    if (readBack !== void 0) {
+      resultItems[index].traceId = readBack;
+    }
+  }
   const completeResult = await preserveReplayFailure(
     () => httpClient.completeReplay(testRunId),
     resultItems,
@@ -2745,7 +2814,7 @@ async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options, reg
       const item = resultItems[index];
       const localId = replayedTraceIds[index];
       const mapped = localId ? serverTraceIds[localId] : void 0;
-      item.traceId = mapped ?? null;
+      item.traceId = item.traceId ?? mapped ?? null;
       if (item.error === null) {
         completedCount += 1;
         if (mapped === void 0) {
@@ -2851,6 +2920,7 @@ export {
   DbBranchReplayError,
   serializeReplayResult,
   waitForReplayPersistence,
+  sleepForReplayPersistence,
   replay
 };
-//# sourceMappingURL=chunk-QUX6N7ON.js.map
+//# sourceMappingURL=chunk-AAMRJGZJ.js.map