@thru/replay 0.2.4 → 0.2.6

package/dist/index.mjs

@@ -418,12 +418,26 @@ var ReplayStream = class {
     this.logger.info(
       `replay entering BACKFILLING state (startSlot=${startSlot}, safetyMargin=${safetyMargin})`
     );
+    let emptyPageRetries = 0;
+    const MAX_EMPTY_PAGE_RETRIES = 10;
     while (!backfillDone) {
-      const page = await fetchBackfill({ startSlot, cursor });
+      const page = await currentFetchBackfill({ startSlot, cursor });
       if (!page.items.length && !page.cursor && !page.done) {
-        this.logger.warn("empty backfill page without cursor; retrying");
+        emptyPageRetries++;
+        if (emptyPageRetries > MAX_EMPTY_PAGE_RETRIES) {
+          this.logger.error(
+            `backfill returned ${MAX_EMPTY_PAGE_RETRIES} consecutive empty pages; treating as done`
+          );
+          break;
+        }
+        const backoffMs = calculateBackoff(emptyPageRetries - 1, DEFAULT_RETRY_CONFIG);
+        this.logger.warn(
+          `empty backfill page without cursor; retrying in ${backoffMs}ms (${emptyPageRetries}/${MAX_EMPTY_PAGE_RETRIES})`
+        );
+        await delay(backoffMs);
         continue;
       }
+      emptyPageRetries = 0;
       const sorted = [...page.items].sort(
         (a, b) => compareBigint(extractSlot(a), extractSlot(b))
       );
@@ -549,19 +563,20 @@ var ReplayStream = class {
   async *miniBackfill(fromSlot, fetchBackfill, extractSlot, keyOf, seenItem, recordEmission) {
     this.logger.info(`mini-backfill starting from slot ${fromSlot}`);
     const MINI_BACKFILL_TIMEOUT = 3e4;
-    const startTime = Date.now();
+    let lastProgressTime = Date.now();
     let cursor;
     let itemsYielded = 0;
     try {
       while (true) {
-        if (Date.now() - startTime > MINI_BACKFILL_TIMEOUT) {
-          this.logger.warn(`mini-backfill timed out after ${MINI_BACKFILL_TIMEOUT}ms`);
+        if (Date.now() - lastProgressTime > MINI_BACKFILL_TIMEOUT) {
+          this.logger.warn(`mini-backfill timed out after ${MINI_BACKFILL_TIMEOUT}ms with no progress`);
           break;
         }
         const page = await fetchBackfill({ startSlot: fromSlot, cursor });
         const sorted = [...page.items].sort(
           (a, b) => compareBigint(extractSlot(a), extractSlot(b))
         );
+        let pageYielded = 0;
         for (const item of sorted) {
           const slot = extractSlot(item);
           const key = keyOf(item);
@@ -571,9 +586,11 @@ var ReplayStream = class {
           }
           recordEmission(slot, key);
           itemsYielded++;
+          pageYielded++;
           this.metrics.emittedReconnect += 1;
           yield item;
         }
+        if (pageYielded > 0) lastProgressTime = Date.now();
         cursor = page.cursor;
         if (page.done || cursor === void 0) break;
       }
@@ -587,7 +604,12 @@ var ReplayStream = class {
 };
 async function safeClose(pump) {
   try {
-    await pump.close();
+    const result = await Promise.race([
+      pump.close().then(() => "closed"),
+      new Promise((resolve) => setTimeout(() => resolve("timeout"), 5e3))
+    ]);
+    if (result === "timeout") {
+    }
   } catch {
   }
 }
@@ -1074,6 +1096,7 @@ async function* createAccountsByOwnerReplay(options) {
   const streamBuffer = [];
   let streamDone = false;
   let streamError = null;
+  let lastActivityTime = Date.now();
   try {
     cleanupTimer = setInterval(() => {
       assembler.cleanup();
@@ -1083,6 +1106,7 @@ async function* createAccountsByOwnerReplay(options) {
     const streamProcessor = (async () => {
       try {
         for await (const response of stream) {
+          lastActivityTime = Date.now();
           const event = processResponseMulti(response, assembler);
           if (event) {
             if (event.type === "account") {
@@ -1172,6 +1196,7 @@ async function* createAccountsByOwnerReplay(options) {
     let retryAttempt = 0;
     let currentStream = stream;
     let currentStreamProcessor = streamProcessor;
+    lastActivityTime = Date.now();
     const createStreamProcessor = () => {
       if (clientFactory) {
         try {
@@ -1187,6 +1212,7 @@ async function* createAccountsByOwnerReplay(options) {
         try {
           for await (const response of newStream) {
             retryAttempt = 0;
+            lastActivityTime = Date.now();
             const event = processResponseMulti(response, assembler);
             if (event) {
               if (event.type === "account") {
@@ -1207,7 +1233,18 @@ async function* createAccountsByOwnerReplay(options) {
       return { stream: newStream, processor: newProcessor };
     };
     while (true) {
+      const hadEvents = streamBuffer.length > 0;
       yield* yieldStreamBuffer();
+      if (hadEvents) {
+        lastActivityTime = Date.now();
+      }
+      if (!streamDone && Date.now() - lastActivityTime > retryConfig.connectionTimeoutMs) {
+        logger.warn(
+          `[account-stream] no activity for ${retryConfig.connectionTimeoutMs}ms; forcing reconnection`
+        );
+        streamDone = true;
+        streamError = new Error(`Operation timed out after ${retryConfig.connectionTimeoutMs}ms`);
+      }
       if (streamDone) {
         if (streamError) {
           const backoffMs = calculateBackoff(retryAttempt, retryConfig);
@@ -1219,6 +1256,7 @@ async function* createAccountsByOwnerReplay(options) {
           streamDone = false;
           streamError = null;
           streamBuffer.length = 0;
+          lastActivityTime = Date.now();
           const { stream: newStream, processor: newProcessor } = createStreamProcessor();
           currentStream = newStream;
           currentStreamProcessor = newProcessor;
@@ -1226,6 +1264,7 @@ async function* createAccountsByOwnerReplay(options) {
         } else {
           logger.warn("[account-stream] stream ended unexpectedly; reconnecting...");
           streamDone = false;
+          lastActivityTime = Date.now();
           const { stream: newStream, processor: newProcessor } = createStreamProcessor();
           currentStream = newStream;
           currentStreamProcessor = newProcessor;