ponder 0.8.7 → 0.8.8

package/dist/bin/ponder.js

@@ -9926,6 +9926,10 @@ var createSync = async (args) => {
               limit: getEventsMaxBatchSize
             });
             consecutiveErrors = 0;
+            args.common.logger.debug({
+              service: "sync",
+              msg: `Fetched ${events.length} events from the database for a ${formatEta(estimateSeconds * 1e3)} range from ${decodeCheckpoint(from).blockTimestamp}`
+            });
             for (const network of args.networks) {
               updateHistoricalStatus({ events, checkpoint: cursor, network });
             }
@@ -9941,22 +9945,12 @@ var createSync = async (args) => {
             });
             yield { events, checkpoint: to };
             from = cursor;
-            const { eta, progress } = await getAppProgress(args.common.metrics);
-            if (events.length > 0) {
-              if (eta === void 0 || progress === void 0) {
-                args.common.logger.info({
-                  service: "app",
-                  msg: `Indexed ${events.length} events`
-                });
-              } else {
-                args.common.logger.info({
-                  service: "app",
-                  msg: `Indexed ${events.length} events with ${formatPercentage(progress)} complete and ${formatEta(eta)} remaining`
-                });
-              }
-            }
           } catch (error) {
             estimateSeconds = Math.max(10, Math.round(estimateSeconds / 10));
+            args.common.logger.debug({
+              service: "sync",
+              msg: `Failed to fetch events from the database, retrying with a ${formatEta(estimateSeconds * 1e3)} range`
+            });
             if (++consecutiveErrors > 4)
               throw error;
           }
@@ -10525,11 +10519,34 @@ async function run({
     let lastFlush = Date.now();
     for await (const { events, checkpoint } of sync.getEvents()) {
       end = checkpoint;
-      const result = await handleEvents(
-        decodeEvents(common, indexingBuild.sources, events),
-        checkpoint
-      );
+      const decodedEvents = decodeEvents(common, indexingBuild.sources, events);
+      const result = await handleEvents(decodedEvents, checkpoint);
+      const { eta, progress } = await getAppProgress(common.metrics);
+      if (events.length > 0) {
+        if (eta === void 0 || progress === void 0) {
+          common.logger.info({
+            service: "app",
+            msg: `Indexed ${events.length} events`
+          });
+        } else {
+          common.logger.info({
+            service: "app",
+            msg: `Indexed ${events.length} events with ${formatPercentage(progress)} complete and ${formatEta(eta)} remaining`
+          });
+        }
+      }
       if (historicalIndexingStore.isCacheFull() && events.length > 0 || common.options.command === "dev" && lastFlush + 5e3 < Date.now() && events.length > 0) {
+        if (historicalIndexingStore.isCacheFull()) {
+          common.logger.debug({
+            service: "indexing",
+            msg: `Indexing cache has exceeded ${common.options.indexingCacheMaxBytes} MB limit, starting flush`
+          });
+        } else {
+          common.logger.debug({
+            service: "indexing",
+            msg: "Dev server periodic flush triggered, starting flush"
+          });
+        }
         await database.finalize({
           checkpoint: encodeCheckpoint(zeroCheckpoint)
         });
@@ -10541,6 +10558,10 @@ async function run({
           checkpoint: events[events.length - 1].checkpoint
         });
         lastFlush = Date.now();
+        common.logger.debug({
+          service: "indexing",
+          msg: "Completed flush"
+        });
       }
       await metadataStore.setStatus(sync.getStatus());
       if (result.status === "killed") {
@@ -10552,6 +10573,10 @@ async function run({
     }
     if (isKilled)
       return;
+    common.logger.debug({
+      service: "indexing",
+      msg: "Completed all historical events, starting final flush"
+    });
     await database.finalize({ checkpoint: encodeCheckpoint(zeroCheckpoint) });
     await historicalIndexingStore.flush();
     await database.complete({ checkpoint: encodeCheckpoint(zeroCheckpoint) });