retrace-sdk 0.16.6 → 0.16.7

package/dist/enforcement.js

@@ -16,7 +16,7 @@ function shortHash(input) {
         h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
         h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
         const n = 4294967296 * (2097151 & h2) + (h1 >>> 0);
-        return n.toString(16).padStart(14, "0");
+        return n.toString(16).padStart(16, "0");
     };
     return (pass(0) + pass(0x9e3779b9)).slice(0, 32);
 }

package/dist/transport.d.ts

@@ -71,8 +71,19 @@ export declare class WSTransport implements Transport {
 export declare class HTTPTransport implements Transport {
     private traceData;
     private spans;
+    private backlog;
+    private readonly backlogCap;
+    private dropped;
     send(eventType: string, data: Record<string, unknown>): void;
     flush(): Promise<void>;
+    /** POST one complete trace payload. Returns "ok" | "reject" (non-retryable 4xx) | "retry"
+     *  (429 / 5xx / network after retries exhausted — caller should retain the payload). */
+    private upload;
+    /** Retain a failed trace for a later retry; bounded — drop + count the oldest on overflow. */
+    private enqueueBacklog;
+    /** Retry previously-failed traces oldest-first; stop at the first still-failing one so a server
+     *  that is still down isn't hammered. */
+    private drainBacklog;
     private buildSpans;
     close(): void;
     /** HTTP is already the one-shot channel — just drain. */

package/dist/transport.js

@@ -349,6 +349,12 @@ export class WSTransport {
 export class HTTPTransport {
     traceData = null;
     spans = [];
+    // Bounded offline backlog (parity with WSTransport's queue + the Python HTTPTransport): a trace
+    // that fails to upload after exhausting transient retries is RETAINED here and retried on a later
+    // flush instead of being silently dropped. Bounded so a long outage can't grow memory unbounded.
+    backlog = [];
+    backlogCap = 1000;
+    dropped = 0;
     send(eventType, data) {
         if (eventType === "trace_started") {
             this.traceData = data;
@@ -363,15 +369,26 @@ export class HTTPTransport {
         }
     }
     async flush() {
+        // Opportunistically retry anything stranded by a previous outage first.
+        if (this.backlog.length)
+            await this.drainBacklog();
         if (!this.traceData)
             return;
-        const cfg = getConfig();
-        const url = `${cfg.baseUrl}/api/v1/traces`;
         const body = { ...this.traceData, spans: this.buildSpans() };
         const payload = JSON.stringify(body);
         // Clear first so a concurrent flush (e.g. trace_ended then shutdown drain) can't double-send.
         this.traceData = null;
         this.spans = [];
+        // On a transient failure, RETAIN the trace in the bounded backlog instead of dropping it — the
+        // previous code cleared the buffer unconditionally, losing the trace under sustained 429/5xx.
+        if ((await this.upload(payload)) === "retry")
+            this.enqueueBacklog(payload);
+    }
+    /** POST one complete trace payload. Returns "ok" | "reject" (non-retryable 4xx) | "retry"
+     *  (429 / 5xx / network after retries exhausted — caller should retain the payload). */
+    async upload(payload) {
+        const cfg = getConfig();
+        const url = `${cfg.baseUrl}/api/v1/traces`;
         // Retry up to 3 times with exponential backoff; awaited so shutdown can drain it.
         for (let n = 1; n <= 3; n++) {
             try {
@@ -381,13 +398,13 @@ export class HTTPTransport {
                     body: payload,
                 });
                 if (res.ok)
-                    return;
+                    return "ok";
                 const txt = await res.text().catch(() => "");
                 // 4xx (except 429) is a client/payload error that won't succeed on retry — surface
                 // it loudly and stop, rather than silently dropping the trace.
                 if (res.status < 500 && res.status !== 429) {
                     console.error(`[retrace] trace upload rejected (HTTP ${res.status}): ${txt.slice(0, 300)}`);
-                    return;
+                    return "reject";
                 }
                 // 5xx / 429 — transient; retry.
                 if (n === 3)
@@ -400,6 +417,26 @@ export class HTTPTransport {
             if (n < 3)
                 await new Promise((r) => setTimeout(r, 1000 * n));
         }
+        return "retry";
+    }
+    /** Retain a failed trace for a later retry; bounded — drop + count the oldest on overflow. */
+    enqueueBacklog(payload) {
+        this.backlog.push(payload);
+        while (this.backlog.length > this.backlogCap) {
+            this.backlog.shift();
+            this.dropped++;
+            console.error(`[retrace] offline buffer full (cap ${this.backlogCap}) — dropped oldest trace (total dropped: ${this.dropped})`);
+        }
+    }
+    /** Retry previously-failed traces oldest-first; stop at the first still-failing one so a server
+     *  that is still down isn't hammered. */
+    async drainBacklog() {
+        while (this.backlog.length) {
+            const r = await this.upload(this.backlog[0]);
+            if (r === "retry")
+                break; // still failing — keep the rest for next time
+            this.backlog.shift(); // "ok" (delivered) or "reject" (unrecoverable) → remove
+        }
     }
     buildSpans() {
         const merged = new Map();
@@ -423,7 +460,7 @@ export class HTTPTransport {
         await this.flush();
     }
     hasPendingData() {
-        return this.traceData !== null || this.spans.length > 0;
+        return this.traceData !== null || this.spans.length > 0 || this.backlog.length > 0;
     }
 }
 export function createTransport(mode = "auto") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "retrace-sdk",
-  "version": "0.16.6",
+  "version": "0.16.7",
   "description": "The execution replay engine for AI agents. Record, replay, fork, and share agent executions.",
   "type": "module",
   "main": "dist/index.js",