@bitfab/sdk 0.36.8 → 0.36.10

package/dist/index.d.cts

@@ -353,6 +353,12 @@ interface DeliveryReport {
     closed: boolean;
     /** Every carrier submitted under this trace came back accepted. */
     delivered: boolean;
+    /**
+     * The server's assigned `traces.id`, read back from the OTLP ingest response.
+     * Absent when talking to a server that predates this field, or before any
+     * carrier for the trace has been acked.
+     */
+    serverTraceId?: string;
 }
 declare class HttpClient {
     private readonly apiKey;
@@ -390,6 +396,12 @@ declare class HttpClient {
      * that was never tracked, so ordinary tracing costs no bookkeeping at all.
      */
     trackTraceDeliveries(traceIds: string[]): void;
+    /**
+     * 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: string): string | undefined;
     /** Whether any tracked trace has had its closing carrier submitted. */
     hasClosedDeliveries(traceIds: string[]): boolean;
     /**
@@ -410,6 +422,12 @@ declare class HttpClient {
      * 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.
+     */
+    private recordServerTraceIds;
     private recordDeliveredCarriers;
     /**
      * Track deferred span work so this client's own lifecycle waits for it, and
@@ -2557,7 +2575,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.36.8";
+declare const __version__ = "0.36.10";
 
 /**
  * Constants for the Bitfab SDK.

package/dist/index.d.ts

@@ -353,6 +353,12 @@ interface DeliveryReport {
     closed: boolean;
     /** Every carrier submitted under this trace came back accepted. */
     delivered: boolean;
+    /**
+     * The server's assigned `traces.id`, read back from the OTLP ingest response.
+     * Absent when talking to a server that predates this field, or before any
+     * carrier for the trace has been acked.
+     */
+    serverTraceId?: string;
 }
 declare class HttpClient {
     private readonly apiKey;
@@ -390,6 +396,12 @@ declare class HttpClient {
      * that was never tracked, so ordinary tracing costs no bookkeeping at all.
      */
     trackTraceDeliveries(traceIds: string[]): void;
+    /**
+     * 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: string): string | undefined;
     /** Whether any tracked trace has had its closing carrier submitted. */
     hasClosedDeliveries(traceIds: string[]): boolean;
     /**
@@ -410,6 +422,12 @@ declare class HttpClient {
      * 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.
+     */
+    private recordServerTraceIds;
     private recordDeliveredCarriers;
     /**
      * Track deferred span work so this client's own lifecycle waits for it, and
@@ -2557,7 +2575,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.36.8";
+declare const __version__ = "0.36.10";
 
 /**
  * Constants for the Bitfab SDK.

package/dist/index.js

@@ -11,7 +11,7 @@ import {
   getCurrentReplayBranch,
   getCurrentSpan,
   getCurrentTrace
-} from "./chunk-B4HK3BPE.js";
+} from "./chunk-RSM2TLKG.js";
 import {
   BITFAB_PROGRESS_PREFIX,
   BitfabError,
@@ -23,7 +23,7 @@ import {
   flushTraces,
   reportReplayProgress,
   serializeReplayResult
-} from "./chunk-QUX6N7ON.js";
+} from "./chunk-AAMRJGZJ.js";
 export {
   BITFAB_PROGRESS_PREFIX,
   Bitfab,

package/dist/node.cjs

@@ -88,7 +88,7 @@ var __version__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.36.8";
+    __version__ = "0.36.10";
   }
 });
 
@@ -1442,6 +1442,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) {
@@ -1466,6 +1470,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);
@@ -1492,7 +1504,8 @@ var init_http = __esm({
             closed: delivery.closed,
             delivered: delivery.closingAcked && [...delivery.submittedSpanIds].every(
               (spanId) => delivery.ackedSpanIds.has(spanId)
-            )
+            ),
+            serverTraceId: delivery.serverTraceId
           };
         }
         return reports;
@@ -1521,6 +1534,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);
@@ -2362,6 +2392,7 @@ __export(replay_exports, {
   replay: () => replay,
   reportReplayProgress: () => reportReplayProgress,
   serializeReplayResult: () => serializeReplayResult,
+  sleepForReplayPersistence: () => sleepForReplayPersistence,
   waitForReplayPersistence: () => waitForReplayPersistence
 });
 function dbBranchEnabled(dbBranch) {
@@ -2657,13 +2688,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;
     }
@@ -2671,7 +2706,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;
@@ -2685,22 +2720,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) {
@@ -2712,7 +2748,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(
@@ -2802,10 +2838,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;
@@ -2820,11 +2882,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.
@@ -2870,12 +2933,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,
@@ -2891,7 +2961,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) {
@@ -2979,7 +3049,6 @@ var init_replay = __esm({
     init_randomUuid();
     init_replayContext();
     init_serialize();
-    init_unrefTimer();
     REPLAY_PERSISTENCE_TIMEOUT_MS = 3e4;
     BITFAB_PROGRESS_PREFIX = "@@bitfab:progress ";
     ReplayError = class extends BitfabError {