ponder 0.8.7 → 0.8.9

package/dist/bin/ponder.js

@@ -3922,13 +3922,28 @@ var ReadonlyClient = class extends pg.Client {
     }
   }
 };
-function createPool(config) {
-  return new pg.Pool({
+function createErrorHandler(logger) {
+  return (error) => {
+    const client = error.client;
+    const pid = client?.processID ?? "unknown";
+    const applicationName = client?.connectionParameters?.application_name ?? "unknown";
+    logger.error({
+      service: "postgres",
+      msg: `Pool error (application_name: ${applicationName}, pid: ${pid})`,
+      error
+    });
+  };
+}
+function createPool(config, logger) {
+  const pool = new pg.Pool({
     // https://stackoverflow.com/questions/59155572/how-to-set-query-timeout-in-relation-to-statement-timeout
     statement_timeout: 2 * 60 * 1e3,
     // 2 minutes
     ...config
   });
+  const onError2 = createErrorHandler(logger);
+  pool.on("error", onError2);
+  return pool;
 }
 
 // src/utils/pglite.ts
@@ -4108,28 +4123,40 @@ var createDatabase = ({
     );
     const [readonlyMax, userMax, syncMax] = common.options.command === "serve" ? [preBuild.databaseConfig.poolConfig.max - internalMax, 0, 0] : [equalMax, equalMax, equalMax];
     driver = {
-      internal: createPool({
-        ...preBuild.databaseConfig.poolConfig,
-        application_name: `${preBuild.namespace}_internal`,
-        max: internalMax,
-        statement_timeout: 10 * 60 * 1e3
-        // 10 minutes to accommodate slow sync store migrations.
-      }),
-      user: createPool({
-        ...preBuild.databaseConfig.poolConfig,
-        application_name: `${preBuild.namespace}_user`,
-        max: userMax
-      }),
-      readonly: createPool({
-        ...preBuild.databaseConfig.poolConfig,
-        application_name: `${preBuild.namespace}_readonly`,
-        max: readonlyMax
-      }),
-      sync: createPool({
-        ...preBuild.databaseConfig.poolConfig,
-        application_name: "ponder_sync",
-        max: syncMax
-      })
+      internal: createPool(
+        {
+          ...preBuild.databaseConfig.poolConfig,
+          application_name: `${preBuild.namespace}_internal`,
+          max: internalMax,
+          statement_timeout: 10 * 60 * 1e3
+          // 10 minutes to accommodate slow sync store migrations.
+        },
+        common.logger
+      ),
+      user: createPool(
+        {
+          ...preBuild.databaseConfig.poolConfig,
+          application_name: `${preBuild.namespace}_user`,
+          max: userMax
+        },
+        common.logger
+      ),
+      readonly: createPool(
+        {
+          ...preBuild.databaseConfig.poolConfig,
+          application_name: `${preBuild.namespace}_readonly`,
+          max: readonlyMax
+        },
+        common.logger
+      ),
+      sync: createPool(
+        {
+          ...preBuild.databaseConfig.poolConfig,
+          application_name: "ponder_sync",
+          max: syncMax
+        },
+        common.logger
+      )
     };
     qb = {
       internal: new HeadlessKysely({
@@ -5402,6 +5429,7 @@ ${prettyPrint(key)}`
         await database.createTriggers();
         await indexingStore.flush();
         await database.removeTriggers();
+        isDatabaseEmpty = false;
         const query2 = { sql: _sql, params, typings };
         const res = await database.qb.user.wrap({ method: "sql" }, async () => {
           try {
@@ -9926,6 +9954,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 +9973,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 +10547,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 +10586,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 +10601,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) });