bitfab 0.36.9 → 0.36.10

package/dist/{chunk-TJAFKZ4X.js → chunk-RSM2TLKG.js}

@@ -16,7 +16,7 @@ import {
   toJsonSafe,
   toJsonSafeReport,
   warnOnce
-} from "./chunk-MBKY42QC.js";
+} from "./chunk-AAMRJGZJ.js";
 
 // src/processorPayload.ts
 var SERIALIZATION_DEGRADED_STEP = "serialization_degraded";
@@ -3371,7 +3371,7 @@ var Bitfab = class {
         `Function is wrapped with trace function key '${wrappedKey}' but replay was called with '${traceFunctionKey}'. Pass matching keys, or pass the unwrapped function to replay it under the explicit key.`
       );
     }
-    const { replay: doReplay } = await import("./replay-MH5QFXET.js");
+    const { replay: doReplay } = await import("./replay-WKWBBIGE.js");
     return doReplay(
       this.httpClient,
       this.serviceUrl,
@@ -3609,4 +3609,4 @@ export {
   BitfabFunction,
   finalizers
 };
-//# sourceMappingURL=chunk-TJAFKZ4X.js.map
+//# sourceMappingURL=chunk-RSM2TLKG.js.map

package/dist/index.cjs

@@ -51,7 +51,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.36.9";
+    __version__ = "0.36.10";
   }
 });
 
@@ -1444,6 +1444,10 @@ var init_http = __esm({
             ...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) {
@@ -1468,6 +1472,14 @@ var init_http = __esm({
           }
         }
       }
+      /**
+       * 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);
@@ -1494,7 +1506,8 @@ var init_http = __esm({
             closed: delivery.closed,
             delivered: delivery.closingAcked && [...delivery.submittedSpanIds].every(
               (spanId) => delivery.ackedSpanIds.has(spanId)
-            )
+            ),
+            serverTraceId: delivery.serverTraceId
           };
         }
         return reports;
@@ -1523,6 +1536,23 @@ var init_http = __esm({
        * 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);
@@ -2660,13 +2690,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;
     }
@@ -2674,7 +2708,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;
@@ -2688,7 +2722,7 @@ async function waitForReplayPersistence(httpClient, testRunId, replayedTraceIds)
       (traceId) => ready[traceId] === void 0
     ).length;
     if (missing === 0) {
-      return;
+      return readBackTraceIds;
     }
     if (Date.now() >= deadline) {
       break;
@@ -2716,7 +2750,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(
@@ -2806,10 +2840,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;
@@ -2824,11 +2884,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.
@@ -2874,12 +2935,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,
@@ -2895,7 +2963,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) {