ponder 0.14.13 → 0.15.0

package/src/indexing-store/cache.ts

@@ -1,12 +1,11 @@
 import type { QB } from "@/database/queryBuilder.js";
-import { getPrimaryKeyColumns } from "@/drizzle/index.js";
+import { getPartitionName, getPrimaryKeyColumns } from "@/drizzle/index.js";
 import { getColumnCasing } from "@/drizzle/kit/index.js";
 import { addErrorMeta, toErrorMeta } from "@/indexing/index.js";
 import type { Common } from "@/internal/common.js";
 import {
   CopyFlushError,
   DelayedInsertError,
-  RetryableError,
   ShutdownError,
 } from "@/internal/errors.js";
 import type {
@@ -16,6 +15,7 @@ import type {
 } from "@/internal/types.js";
 import { dedupe } from "@/utils/dedupe.js";
 import { prettyPrint } from "@/utils/print.js";
+import { promiseAllSettledWithThrow } from "@/utils/promiseAllSettledWithThrow.js";
 import { startClock } from "@/utils/timer.js";
 import {
   type Table,
@@ -274,14 +274,12 @@ export const getCopyText = (table: Table, rows: Row[]) => {
   return result;
 };
 
-export const getCopyHelper = (qb: QB) => {
+export const getCopyHelper = (qb: QB, chainId?: number) => {
   if (qb.$dialect === "pglite") {
     return async (table: Table, text: string, includeSchema = true) => {
       const target = includeSchema
-        ? `"${getTableConfig(table).schema ?? "public"}"."${getTableName(
-            table,
-          )}"`
-        : `"${getTableName(table)}"`;
+        ? `"${getTableConfig(table).schema ?? "public"}"."${chainId === undefined ? getTableName(table) : getPartitionName(table, chainId)}"`
+        : `"${chainId === undefined ? getTableName(table) : getPartitionName(table, chainId)}"`;
       await qb.$client
         .query(`COPY ${target} FROM '/dev/blob'`, [], {
           blob: new Blob([text]),
@@ -295,10 +293,8 @@ export const getCopyHelper = (qb: QB) => {
   } else {
     return async (table: Table, text: string, includeSchema = true) => {
       const target = includeSchema
-        ? `"${getTableConfig(table).schema ?? "public"}"."${getTableName(
-            table,
-          )}"`
-        : `"${getTableName(table)}"`;
+        ? `"${getTableConfig(table).schema ?? "public"}"."${chainId === undefined ? getTableName(table) : getPartitionName(table, chainId)}"`
+        : `"${chainId === undefined ? getTableName(table) : getPartitionName(table, chainId)}"`;
       const copyStream = qb.$client.query(
         copy.from(`COPY ${target} FROM STDIN`),
       );
@@ -348,11 +344,13 @@ export const createIndexingCache = ({
   schemaBuild: { schema },
   crashRecoveryCheckpoint,
   eventCount,
+  chainId,
 }: {
   common: Common;
   schemaBuild: Pick<SchemaBuild, "schema">;
   crashRecoveryCheckpoint: CrashRecoveryCheckpoint;
   eventCount: { [eventName: string]: number };
+  chainId?: number;
 }): IndexingCache => {
   let event: Event | undefined;
   let qb: QB = undefined!;
@@ -363,8 +361,6 @@ export const createIndexingCache = ({
   /** Profiling data about access patterns for each event. */
   const profile: Profile = new Map();
 
-  let isFlushRetry = false;
-
   const tables = Object.values(schema).filter(isTable);
   const primaryKeyCache = getPrimaryKeyCache(tables);
 
@@ -393,11 +389,14 @@ export const createIndexingCache = ({
       );
     },
     async get({ table, key }) {
-      if (event && eventCount[event.name]! % SAMPLING_RATE === 1) {
-        if (profile.has(event.name) === false) {
-          profile.set(event.name, new Map());
+      if (
+        event &&
+        eventCount[event.eventCallback.name]! % SAMPLING_RATE === 1
+      ) {
+        if (profile.has(event.eventCallback.name) === false) {
+          profile.set(event.eventCallback.name, new Map());
           for (const table of tables) {
-            profile.get(event.name)!.set(table, new Map());
+            profile.get(event.eventCallback.name)!.set(table, new Map());
           }
         }
 
@@ -405,18 +404,19 @@ export const createIndexingCache = ({
           event,
           table,
           key,
-          Array.from(profile.get(event.name)!.get(table)!.values()).map(
-            ({ pattern }) => pattern,
-          ),
+          Array.from(
+            profile.get(event.eventCallback.name)!.get(table)!.values(),
+          ).map(({ pattern }) => pattern),
           primaryKeyCache,
         );
         if (pattern) {
           const key = getProfilePatternKey(pattern);
-          if (profile.get(event.name)!.get(table)!.has(key)) {
-            profile.get(event.name)!.get(table)!.get(key)!.count++;
+          if (profile.get(event.eventCallback.name)!.get(table)!.has(key)) {
+            profile.get(event.eventCallback.name)!.get(table)!.get(key)!
+              .count++;
           } else {
             profile
-              .get(event.name)!
+              .get(event.eventCallback.name)!
               .get(table)!
               .set(key, { pattern, count: 1 });
           }
@@ -530,150 +530,86 @@ export const createIndexingCache = ({
       };
       const flushEndClock = startClock();
 
-      const copy = getCopyHelper(qb);
-
-      // Note `isFlushRetry` is true when the previous flush failed. When `isFlushRetry` is false, this
-      // function takes an optimized fast path, with support for small batch sizes. PGlite always takes
-      // the fast path because it doesn't support delayed insert errors.
-
-      if (isFlushRetry && qb.$dialect === "postgres") {
-        for (const table of cache.keys()) {
-          const shouldRecordBytes = cache.get(table)!.isCacheComplete;
-          if (
-            tableNames !== undefined &&
-            tableNames.has(getTableName(table)) === false
-          ) {
-            continue;
-          }
-
-          const tableCache = cache.get(table)!;
-
-          const insertValues = Array.from(insertBuffer.get(table)!.values());
-          const updateValues = Array.from(updateBuffer.get(table)!.values());
-
-          if (insertValues.length > 0) {
-            const endClock = startClock();
+      const copy = getCopyHelper(qb, chainId);
 
-            await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
+      const flushTable = async (table: Table) => {
+        const shouldRecordBytes = cache.get(table)!.isCacheComplete;
+        if (
+          tableNames !== undefined &&
+          tableNames.has(getTableName(table)) === false
+        ) {
+          return;
+        }
 
-            try {
-              const text = getCopyText(
-                table,
-                insertValues.map(({ row }) => row),
-              );
+        const tableCache = cache.get(table)!;
 
-              await new Promise(setImmediate);
-
-              await copy(table, text);
-            } catch (_error) {
-              let error = _error as Error;
-              const result = await recoverBatchError(
-                insertValues,
-                async (values) => {
-                  await qb.wrap(
-                    (db) => db.execute("ROLLBACK to flush"),
-                    context,
-                  );
-                  const text = getCopyText(
-                    table,
-                    values.map(({ row }) => row),
-                  );
-                  await copy(table, text);
-
-                  await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
-                },
-              );
+        const target =
+          chainId === undefined
+            ? getTableName(table)
+            : getPartitionName(table, chainId);
 
-              if (result.status === "error") {
-                error = new DelayedInsertError(result.error.message);
-                error.stack = undefined;
+        const insertValues = Array.from(insertBuffer.get(table)!.values());
+        const updateValues = Array.from(updateBuffer.get(table)!.values());
 
-                addErrorMeta(
-                  error,
-                  `db.insert arguments:\n${prettyPrint(result.value.row)}`,
-                );
+        if (insertValues.length > 0) {
+          const endClock = startClock();
 
-                if (result.value.metadata.event) {
-                  addErrorMeta(error, toErrorMeta(result.value.metadata.event));
-
-                  common.logger.warn({
-                    msg: "Failed to write cached database rows",
-                    event: result.value.metadata.event.name,
-                    type: "insert",
-                    table: getTableName(table),
-                    row_count: insertValues.length,
-                    duration: endClock(),
-                    error,
-                  });
-                } else {
-                  common.logger.warn({
-                    msg: "Failed to write cached database rows",
-                    type: "insert",
-                    table: getTableName(table),
-                    row_count: insertValues.length,
-                    duration: endClock(),
-                    error,
-                  });
-                }
+          if (insertValues.length > LOW_BATCH_THRESHOLD) {
+            const text = getCopyText(
+              table,
+              insertValues.map(({ row }) => row),
+            );
 
-                // @ts-ignore remove meta from error
-                error.meta = undefined;
-              } else {
-                error.stack = undefined;
+            await new Promise(setImmediate);
 
-                common.logger.warn({
-                  msg: "Failed to write cached database rows",
-                  type: "insert",
-                  table: getTableName(table),
-                  row_count: insertValues.length,
-                  duration: endClock(),
-                  error,
-                });
-              }
+            await copy(table, text);
+          } else {
+            await qb.wrap(
+              (db) =>
+                db.insert(table).values(insertValues.map(({ row }) => row)),
+              context,
+            );
+          }
 
-              throw error;
+          common.metrics.ponder_indexing_cache_query_duration.observe(
+            {
+              table: getTableName(table),
+              method: "flush",
+            },
+            endClock(),
+          );
+
+          let bytes = 0;
+          for (const [key, entry] of insertBuffer.get(table)!) {
+            if (shouldRecordBytes && tableCache.cache.has(key) === false) {
+              bytes += getBytes(entry.row) + getBytes(key);
             }
+            tableCache.cache.set(key, entry.row);
+          }
+          tableCache.bytes += bytes;
+          insertBuffer.get(table)!.clear();
 
-            common.metrics.ponder_indexing_cache_query_duration.observe(
-              {
-                table: getTableName(table),
-                method: "flush",
-              },
-              endClock(),
-            );
+          await new Promise(setImmediate);
+        }
 
-            let bytes = 0;
-            for (const [key, entry] of insertBuffer.get(table)!) {
-              if (shouldRecordBytes && tableCache.cache.has(key) === false) {
-                bytes += getBytes(entry.row) + getBytes(key);
-              }
-              tableCache.cache.set(key, entry.row);
-            }
-            tableCache.bytes += bytes;
-            insertBuffer.get(table)!.clear();
+        if (updateValues.length > 0) {
+          const primaryKeys = getPrimaryKeyColumns(table);
 
-            await new Promise(setImmediate);
-          }
+          const endClock = startClock();
 
-          if (updateValues.length > 0) {
+          if (updateValues.length > LOW_BATCH_THRESHOLD) {
             // Steps for flushing "update" entries:
             // 1. Create temp table
             // 2. Copy into temp table
             // 3. Update target table with data from temp
 
-            const primaryKeys = getPrimaryKeyColumns(table);
-
             const createTempTableQuery = `
-              CREATE TEMP TABLE IF NOT EXISTS "${getTableName(table)}"
-              AS SELECT * FROM "${
-                getTableConfig(table).schema ?? "public"
-              }"."${getTableName(table)}"
-              WITH NO DATA;
-            `;
+              CREATE TEMP TABLE IF NOT EXISTS "${target}" 
+              AS SELECT * FROM "${getTableConfig(table).schema ?? "public"}"."${target}"
+              WITH NO DATA;`;
+
             const updateQuery = `
-              UPDATE "${
-                getTableConfig(table).schema ?? "public"
-              }"."${getTableName(table)}" as target
+              UPDATE "${getTableConfig(table).schema ?? "public"}"."${target}" as target
               SET ${Object.values(getTableColumns(table))
                 .map(
                   (column) =>
@@ -683,321 +619,255 @@ export const createIndexingCache = ({
                     )}" = source."${getColumnCasing(column, "snake_case")}"`,
                 )
                 .join(",\n")}
-              FROM "${getTableName(table)}" source
+              FROM "${target}" source
               WHERE ${primaryKeys
                 .map(({ sql }) => `target."${sql}" = source."${sql}"`)
-                .join(" AND ")};
-            `;
-
-            const endClock = startClock();
+                .join(" AND ")};`;
 
             await qb.wrap((db) => db.execute(createTempTableQuery), context);
-            await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
-
-            try {
-              const text = getCopyText(
-                table,
-                updateValues.map(({ row }) => row),
-              );
-
-              await new Promise(setImmediate);
-
-              await copy(table, text, false);
-            } catch (_error) {
-              let error = _error as Error;
-              const result = await recoverBatchError(
-                updateValues,
-                async (values) => {
-                  await qb.wrap(
-                    (db) => db.execute("ROLLBACK to flush"),
-                    context,
-                  );
-                  const text = getCopyText(
-                    table,
-                    values.map(({ row }) => row),
-                  );
-                  await copy(table, text, false);
-
-                  await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
-                },
-              );
-
-              if (result.status === "error") {
-                error = new DelayedInsertError(result.error.message);
-                error.stack = undefined;
-
-                addErrorMeta(
-                  error,
-                  `db.update arguments:\n${prettyPrint(result.value.row)}`,
-                );
-
-                if (result.value.metadata.event) {
-                  addErrorMeta(error, toErrorMeta(result.value.metadata.event));
-
-                  common.logger.warn({
-                    msg: "Failed to write cached database rows",
-                    event: result.value.metadata.event.name,
-                    type: "update",
-                    table: getTableName(table),
-                    row_count: updateValues.length,
-                    duration: endClock(),
-                    error,
-                  });
-                } else {
-                  common.logger.warn({
-                    msg: "Failed to write cached database rows",
-                    type: "update",
-                    table: getTableName(table),
-                    row_count: updateValues.length,
-                    duration: endClock(),
-                    error,
-                  });
-                }
-
-                // @ts-ignore remove meta from error
-                error.meta = undefined;
-              } else {
-                error.stack = undefined;
-
-                common.logger.warn({
-                  msg: "Failed to write cached database rows",
-                  type: "update",
-                  table: getTableName(table),
-                  row_count: updateValues.length,
-                  duration: endClock(),
-                  error,
-                });
-              }
 
-              throw error;
-            }
+            const text = getCopyText(
+              table,
+              updateValues.map(({ row }) => row),
+            );
+            await new Promise(setImmediate);
 
+            await copy(table, text, false);
             await qb.wrap((db) => db.execute(updateQuery), context);
             await qb.wrap(
-              (db) => db.execute(`TRUNCATE TABLE "${getTableName(table)}"`),
+              (db) => db.execute(`TRUNCATE TABLE "${target}"`),
               context,
             );
-
-            common.metrics.ponder_indexing_cache_query_duration.observe(
-              {
-                table: getTableName(table),
-                method: "flush",
-              },
-              endClock(),
+          } else {
+            await qb.wrap(
+              (db) =>
+                db
+                  .insert(table)
+                  .values(updateValues.map(({ row }) => row))
+                  .onConflictDoUpdate({
+                    // @ts-ignore
+                    target: primaryKeys.map(({ js }) => table[js]!),
+                    set: Object.fromEntries(
+                      Object.entries(getTableColumns(table)).map(
+                        ([columnName, column]) => [
+                          columnName,
+                          sql.raw(
+                            `excluded."${getColumnCasing(column, "snake_case")}"`,
+                          ),
+                        ],
+                      ),
+                    ),
+                  }),
+              context,
             );
+          }
 
-            let bytes = 0;
-            for (const [key, entry] of updateBuffer.get(table)!) {
-              if (shouldRecordBytes && tableCache.cache.has(key) === false) {
-                bytes += getBytes(entry.row) + getBytes(key);
-              }
-              tableCache.cache.set(key, entry.row);
+          common.metrics.ponder_indexing_cache_query_duration.observe(
+            {
+              table: getTableName(table),
+              method: "flush",
+            },
+            endClock(),
+          );
+
+          let bytes = 0;
+          for (const [key, entry] of updateBuffer.get(table)!) {
+            if (shouldRecordBytes && tableCache.cache.has(key) === false) {
+              bytes += getBytes(entry.row) + getBytes(key);
             }
-            tableCache.bytes += bytes;
-            updateBuffer.get(table)!.clear();
-
-            await new Promise(setImmediate);
+            tableCache.cache.set(key, entry.row);
           }
+          tableCache.bytes += bytes;
+          updateBuffer.get(table)!.clear();
 
-          if (insertValues.length > 0 || updateValues.length > 0) {
-            common.logger.debug({
-              msg: "Wrote database rows",
-              table: getTableName(table),
-              row_count: insertValues.length + updateValues.length,
-              duration: flushEndClock(),
-            });
+          await new Promise(setImmediate);
+        }
 
-            await qb.wrap((db) => db.execute("RELEASE flush"), context);
+        if (insertValues.length > 0 || updateValues.length > 0) {
+          common.logger.debug({
+            msg: "Wrote database rows",
+            table: target,
+            row_count: insertValues.length + updateValues.length,
+            duration: flushEndClock(),
+          });
+        }
+      };
+
+      try {
+        if (qb.$dialect === "postgres") {
+          await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
+
+          await promiseAllSettledWithThrow(
+            Array.from(cache.keys()).map(flushTable),
+          );
+
+          await qb.wrap((db) => db.execute("RELEASE flush"), context);
+        } else {
+          // Note: pglite must run sequentially
+          for (const table of cache.keys()) {
+            await flushTable(table);
           }
         }
-      } else {
-        isFlushRetry = true;
-
-        // Note: Must use `Promise.allSettled` to avoid short-circuiting while queries are running.
-
-        const results = await Promise.allSettled(
-          Array.from(cache.keys()).map(async (table) => {
-            const shouldRecordBytes = cache.get(table)!.isCacheComplete;
-            if (
-              tableNames !== undefined &&
-              tableNames.has(getTableName(table)) === false
-            ) {
-              return;
-            }
+      } catch (_error) {
+        let error = _error as Error;
+        if (error instanceof ShutdownError || qb.$dialect === "pglite") {
+          throw error;
+        }
+
+        // Note `isFlushRetry` is true when the previous flush failed. When `isFlushRetry` is false, this
+        // function takes an optimized fast path, with support for small batch sizes. PGlite always takes
+        // the fast path because it doesn't support delayed insert errors.
+
+        await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
+
+        for (const table of cache.keys()) {
+          if (
+            tableNames !== undefined &&
+            tableNames.has(getTableName(table)) === false
+          ) {
+            continue;
+          }
 
-            const tableCache = cache.get(table)!;
+          const target =
+            chainId === undefined
+              ? getTableName(table)
+              : getPartitionName(table, chainId);
+
+          const insertValues = Array.from(insertBuffer.get(table)!.values());
+          const updateValues = Array.from(updateBuffer.get(table)!.values());
 
-            const insertValues = Array.from(insertBuffer.get(table)!.values());
-            const updateValues = Array.from(updateBuffer.get(table)!.values());
+          if (insertValues.length > 0) {
+            const endClock = startClock();
 
-            if (insertValues.length > 0) {
-              const endClock = startClock();
+            await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
 
-              if (insertValues.length > LOW_BATCH_THRESHOLD) {
+            const result = await recoverBatchError(
+              insertValues,
+              async (values) => {
+                await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
                 const text = getCopyText(
                   table,
-                  insertValues.map(({ row }) => row),
+                  values.map(({ row }) => row),
                 );
+                await copy(table, text);
 
-                await new Promise(setImmediate);
+                await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
+              },
+            );
 
-                await copy(table, text);
-              } else {
-                await qb.wrap(
-                  (db) =>
-                    db.insert(table).values(insertValues.map(({ row }) => row)),
-                  context,
-                );
-              }
+            if (result.status === "error") {
+              error = new DelayedInsertError(result.error.message);
+              error.stack = undefined;
 
-              common.metrics.ponder_indexing_cache_query_duration.observe(
-                {
-                  table: getTableName(table),
-                  method: "flush",
-                },
-                endClock(),
+              addErrorMeta(
+                error,
+                `db.insert arguments:\n${prettyPrint(result.value.row)}`,
               );
 
-              let bytes = 0;
-              for (const [key, entry] of insertBuffer.get(table)!) {
-                if (shouldRecordBytes && tableCache.cache.has(key) === false) {
-                  bytes += getBytes(entry.row) + getBytes(key);
-                }
-                tableCache.cache.set(key, entry.row);
+              if (result.value.metadata.event) {
+                addErrorMeta(error, toErrorMeta(result.value.metadata.event));
+
+                common.logger.warn({
+                  msg: "Failed to write cached database rows",
+                  event: result.value.metadata.event.eventCallback.name,
+                  type: "insert",
+                  table: getTableName(table),
+                  row_count: insertValues.length,
+                  duration: endClock(),
+                  error,
+                });
+              } else {
+                common.logger.warn({
+                  msg: "Failed to write cached database rows",
+                  type: "insert",
+                  table: getTableName(table),
+                  row_count: insertValues.length,
+                  duration: endClock(),
+                  error,
+                });
               }
-              tableCache.bytes += bytes;
-              insertBuffer.get(table)!.clear();
 
-              await new Promise(setImmediate);
+              throw error;
             }
+          }
 
-            if (updateValues.length > 0) {
-              const primaryKeys = getPrimaryKeyColumns(table);
-
-              const endClock = startClock();
-
-              if (updateValues.length > LOW_BATCH_THRESHOLD) {
-                // Steps for flushing "update" entries:
-                // 1. Create temp table
-                // 2. Copy into temp table
-                // 3. Update target table with data from temp
-
-                const createTempTableQuery = `
-                CREATE TEMP TABLE IF NOT EXISTS "${getTableName(table)}" 
-                AS SELECT * FROM "${
-                  getTableConfig(table).schema ?? "public"
-                }"."${getTableName(table)}"
-                WITH NO DATA;
-              `;
-
-                const updateQuery = `
-                UPDATE "${
-                  getTableConfig(table).schema ?? "public"
-                }"."${getTableName(table)}" as target
-                SET ${Object.values(getTableColumns(table))
-                  .map(
-                    (column) =>
-                      `"${getColumnCasing(
-                        column,
-                        "snake_case",
-                      )}" = source."${getColumnCasing(column, "snake_case")}"`,
-                  )
-                  .join(",\n")}
-                FROM "${getTableName(table)}" source
-                WHERE ${primaryKeys
-                  .map(({ sql }) => `target."${sql}" = source."${sql}"`)
-                  .join(" AND ")};
-              `;
-
-                await qb.wrap(
-                  (db) => db.execute(createTempTableQuery),
-                  context,
-                );
+          if (updateValues.length > 0) {
+            // Steps for flushing "update" entries:
+            // 1. Create temp table
+            // 2. Copy into temp table
+            // 3. Update target table with data from temp
+
+            const createTempTableQuery = `
+              CREATE TEMP TABLE IF NOT EXISTS "${target}"
+              AS SELECT * FROM "${getTableConfig(table).schema ?? "public"}"."${target}"
+              WITH NO DATA;
+            `;
 
+            const endClock = startClock();
+
+            await qb.wrap((db) => db.execute(createTempTableQuery), context);
+            await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
+
+            const result = await recoverBatchError(
+              updateValues,
+              async (values) => {
+                await qb.wrap((db) => db.execute("ROLLBACK to flush"), context);
                 const text = getCopyText(
                   table,
-                  updateValues.map(({ row }) => row),
+                  values.map(({ row }) => row),
                 );
-
-                await new Promise(setImmediate);
-
                 await copy(table, text, false);
 
-                await qb.wrap((db) => db.execute(updateQuery), context);
+                await qb.wrap((db) => db.execute("SAVEPOINT flush"), context);
+              },
+            );
 
-                await qb.wrap(
-                  (db) => db.execute(`TRUNCATE TABLE "${getTableName(table)}"`),
-                  context,
-                );
-              } else {
-                await qb.wrap(
-                  (db) =>
-                    db
-                      .insert(table)
-                      .values(updateValues.map(({ row }) => row))
-                      .onConflictDoUpdate({
-                        // @ts-ignore
-                        target: primaryKeys.map(({ js }) => table[js]!),
-                        set: Object.fromEntries(
-                          Object.entries(getTableColumns(table)).map(
-                            ([columnName, column]) => [
-                              columnName,
-                              sql.raw(
-                                `excluded."${getColumnCasing(column, "snake_case")}"`,
-                              ),
-                            ],
-                          ),
-                        ),
-                      }),
-                  context,
-                );
-              }
+            await qb.wrap(
+              (db) => db.execute(`TRUNCATE TABLE "${target}"`),
+              context,
+            );
 
-              common.metrics.ponder_indexing_cache_query_duration.observe(
-                {
-                  table: getTableName(table),
-                  method: "flush",
-                },
-                endClock(),
+            if (result.status === "error") {
+              error = new DelayedInsertError(result.error.message);
+              error.stack = undefined;
+
+              addErrorMeta(
+                error,
+                `db.update arguments:\n${prettyPrint(result.value.row)}`,
               );
 
-              let bytes = 0;
-              for (const [key, entry] of updateBuffer.get(table)!) {
-                if (shouldRecordBytes && tableCache.cache.has(key) === false) {
-                  bytes += getBytes(entry.row) + getBytes(key);
-                }
-                tableCache.cache.set(key, entry.row);
-              }
-              tableCache.bytes += bytes;
-              updateBuffer.get(table)!.clear();
+              if (result.value.metadata.event) {
+                addErrorMeta(error, toErrorMeta(result.value.metadata.event));
 
-              await new Promise(setImmediate);
-            }
+                common.logger.warn({
+                  msg: "Failed to write cached database rows",
+                  event: result.value.metadata.event.eventCallback.name,
+                  type: "update",
+                  table: getTableName(table),
+                  row_count: updateValues.length,
+                  duration: endClock(),
+                  error,
+                });
+              } else {
+                common.logger.warn({
+                  msg: "Failed to write cached database rows",
+                  type: "update",
+                  table: getTableName(table),
+                  row_count: updateValues.length,
+                  duration: endClock(),
+                  error,
+                });
+              }
 
-            if (insertValues.length > 0 || updateValues.length > 0) {
-              common.logger.debug({
-                msg: "Wrote database rows",
-                table: getTableName(table),
-                row_count: insertValues.length + updateValues.length,
-                duration: flushEndClock(),
-              });
+              throw error;
             }
-          }),
-        );
-
-        if (results.some((result) => result.status === "rejected")) {
-          const rejected = results.find(
-            (result): result is PromiseRejectedResult =>
-              result.status === "rejected",
-          )!;
-          if (rejected.reason instanceof ShutdownError) {
-            throw rejected.reason;
           }
-          throw new RetryableError(rejected.reason.message);
         }
-      }
 
-      isFlushRetry = false;
+        // Note: if we weren't able to find the exact row that caused the error,
+        // throw the original error.
+        throw error;
+      }
     },
     async prefetch({ events }) {
       const context = {
@@ -1050,14 +920,15 @@ export const createIndexingCache = ({
       }
 
       for (const event of events) {
-        if (profile.has(event.name)) {
+        if (profile.has(event.eventCallback.name)) {
           for (const table of tables) {
             if (cache.get(table)!.isCacheComplete) continue;
             for (const [, { count, pattern }] of profile
-              .get(event.name)!
+              .get(event.eventCallback.name)!
               .get(table)!) {
               // Expected value of times the prediction will be used.
-              const ev = (count * SAMPLING_RATE) / eventCount[event.name]!;
+              const ev =
+                (count * SAMPLING_RATE) / eventCount[event.eventCallback.name]!;
               if (ev > PREDICTION_THRESHOLD) {
                 const row = recoverProfilePattern(pattern, event);
                 const key = getCacheKey(table, row, primaryKeyCache);