envio 3.3.0-alpha.9 → 3.3.0

package/src/Prometheus.res

@@ -606,29 +606,39 @@ let effectLabelsSchema = S.object(s => {
   s.field("effect", S.string)
 })
 
+// For metrics whose backing state lives per scope ("crossChain" or a chain
+// id) — without the label, scopes of the same effect would clobber each
+// other's gauge value.
+let effectScopeLabelsSchema = S.schema(s =>
+  {
+    "effect": s.matches(S.string),
+    "scope": s.matches(S.string),
+  }
+)
+
 module EffectCalls = {
   let timeCounter = SafeCounter.makeOrThrow(
     ~name="envio_effect_call_seconds",
     ~help="Processing time taken to call the Effect function.",
-    ~labelSchema=effectLabelsSchema,
+    ~labelSchema=effectScopeLabelsSchema,
   )
 
   let sumTimeCounter = SafeCounter.makeOrThrow(
     ~name="envio_effect_call_seconds_total",
     ~help="Cumulative time spent calling the Effect function during the indexing process.",
-    ~labelSchema=effectLabelsSchema,
+    ~labelSchema=effectScopeLabelsSchema,
   )
 
   let totalCallsCount = SafeCounter.makeOrThrow(
     ~name="envio_effect_call_total",
     ~help="Cumulative number of resolved Effect function calls during the indexing process.",
-    ~labelSchema=effectLabelsSchema,
+    ~labelSchema=effectScopeLabelsSchema,
   )
 
   let activeCallsCount = SafeGauge.makeOrThrow(
     ~name="envio_effect_active_calls",
     ~help="The number of Effect function calls that are currently running.",
-    ~labelSchema=effectLabelsSchema,
+    ~labelSchema=effectScopeLabelsSchema,
   )
 }
 
@@ -636,11 +646,11 @@ module EffectCacheCount = {
   let gauge = SafeGauge.makeOrThrow(
     ~name="envio_effect_cache",
     ~help="The number of items in the effect cache.",
-    ~labelSchema=effectLabelsSchema,
+    ~labelSchema=effectScopeLabelsSchema,
   )
 
-  let set = (~count, ~effectName) => {
-    gauge->SafeGauge.handleInt(~labels=effectName, ~value=count)
+  let set = (~count, ~effectName, ~scope) => {
+    gauge->SafeGauge.handleInt(~labels={"effect": effectName, "scope": scope}, ~value=count)
   }
 }
 
@@ -660,7 +670,7 @@ module EffectQueueCount = {
   let gauge = SafeGauge.makeOrThrow(
     ~name="envio_effect_queue",
     ~help="The number of effect calls waiting in the rate limit queue.",
-    ~labelSchema=effectLabelsSchema,
+    ~labelSchema=effectScopeLabelsSchema,
   )
 
   let timeCounter = SafeCounter.makeOrThrow(
@@ -669,8 +679,8 @@ module EffectQueueCount = {
     ~labelSchema=effectLabelsSchema,
   )
 
-  let set = (~count, ~effectName) => {
-    gauge->SafeGauge.handleInt(~labels=effectName, ~value=count)
+  let set = (~count, ~effectName, ~scope) => {
+    gauge->SafeGauge.handleInt(~labels={"effect": effectName, "scope": scope}, ~value=count)
   }
 }
 

package/src/Prometheus.res.mjs

@@ -651,13 +651,18 @@ let ProgressLatency = {
 
 let effectLabelsSchema = S$RescriptSchema.object(s => s.f("effect", S$RescriptSchema.string));
 
-let timeCounter$5 = makeOrThrow("envio_effect_call_seconds", "Processing time taken to call the Effect function.", effectLabelsSchema);
+let effectScopeLabelsSchema = S$RescriptSchema.schema(s => ({
+  effect: s.m(S$RescriptSchema.string),
+  scope: s.m(S$RescriptSchema.string)
+}));
+
+let timeCounter$5 = makeOrThrow("envio_effect_call_seconds", "Processing time taken to call the Effect function.", effectScopeLabelsSchema);
 
-let sumTimeCounter$1 = makeOrThrow("envio_effect_call_seconds_total", "Cumulative time spent calling the Effect function during the indexing process.", effectLabelsSchema);
+let sumTimeCounter$1 = makeOrThrow("envio_effect_call_seconds_total", "Cumulative time spent calling the Effect function during the indexing process.", effectScopeLabelsSchema);
 
-let totalCallsCount = makeOrThrow("envio_effect_call_total", "Cumulative number of resolved Effect function calls during the indexing process.", effectLabelsSchema);
+let totalCallsCount = makeOrThrow("envio_effect_call_total", "Cumulative number of resolved Effect function calls during the indexing process.", effectScopeLabelsSchema);
 
-let activeCallsCount = makeOrThrow$1("envio_effect_active_calls", "The number of Effect function calls that are currently running.", effectLabelsSchema);
+let activeCallsCount = makeOrThrow$1("envio_effect_active_calls", "The number of Effect function calls that are currently running.", effectScopeLabelsSchema);
 
 let EffectCalls = {
   timeCounter: timeCounter$5,
@@ -666,10 +671,13 @@ let EffectCalls = {
   activeCallsCount: activeCallsCount
 };
 
-let gauge$19 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
+let gauge$19 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectScopeLabelsSchema);
 
-function set$19(count, effectName) {
-  handleInt$1(gauge$19, effectName, count);
+function set$19(count, effectName, scope) {
+  handleInt$1(gauge$19, {
+    effect: effectName,
+    scope: scope
+  }, count);
 }
 
 let EffectCacheCount = {
@@ -688,12 +696,15 @@ let EffectCacheInvalidationsCount = {
   increment: increment$7
 };
 
-let gauge$20 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
+let gauge$20 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectScopeLabelsSchema);
 
 let timeCounter$6 = makeOrThrow("envio_effect_queue_wait_seconds", "The time spent waiting in the rate limit queue.", effectLabelsSchema);
 
-function set$20(count, effectName) {
-  handleInt$1(gauge$20, effectName, count);
+function set$20(count, effectName, scope) {
+  handleInt$1(gauge$20, {
+    effect: effectName,
+    scope: scope
+  }, count);
 }
 
 let EffectQueueCount = {
@@ -825,6 +836,7 @@ export {
   ProgressEventsCount,
   ProgressLatency,
   effectLabelsSchema,
+  effectScopeLabelsSchema,
   EffectCalls,
   EffectCacheCount,
   EffectCacheInvalidationsCount,

package/src/PruneStaleHistory.res

@@ -1,45 +1,156 @@
-// Throttled prune of stale entity-history rows below the safe checkpoint.
-
-let runPrune = async (state: IndexerState.t) => {
-  switch state->IndexerState.getSafeCheckpointId {
-  | None => ()
-  | Some(safeCheckpointId) =>
-    let persistence = state->IndexerState.persistence
-    await persistence.storage.pruneStaleCheckpoints(~safeCheckpointId)
-
-    for idx in 0 to persistence.allEntities->Array.length - 1 {
-      if idx !== 0 {
-        // Add some delay between entities
-        // To unblock the pg client if it's needed for something else
-        await Utils.delay(1000)
+// Prune of stale entity-history rows below the safe checkpoint.
+//
+// Pruning must never run concurrently with a write to the same entity's history
+// table: the prune's anchor deletion relies on "no history after the safe
+// checkpoint", which a concurrently committing batch can falsify, losing the
+// anchor and breaking a later rollback. The write loop enforces the safety by
+// running the concurrent group only for entities absent from the batch being
+// written (and awaiting it before the next write starts), and the forced group
+// alone after the write.
+
+let maxEntitiesPerWrite = 5
+let forcedIntervalMultiplier = 5.
+
+type targets = {
+  safeCheckpointId: Internal.checkpointId,
+  concurrent: array<Internal.entityConfig>,
+  forced: array<Internal.entityConfig>,
+}
+
+let selectFrom = (
+  ~allEntities: array<Internal.entityConfig>,
+  ~lastPrunedAtMillis: dict<float>,
+  ~writtenEntityNames: Utils.Set.t<string>,
+  ~isRollback,
+  ~nowMillis,
+  ~intervalMillis,
+  ~safeCheckpointId,
+) => {
+  let byOldestPrune = ((a, _), (b, _)) => a -. b
+  let toEntities = candidates => candidates->Array.map(((_, entityConfig)) => entityConfig)
+
+  let concurrentCandidates = []
+  let forcedCandidates = []
+  allEntities->Array.forEach(entityConfig => {
+    if entityConfig.storage.postgres {
+      let lastPrunedAt =
+        lastPrunedAtMillis
+        ->Utils.Dict.dangerouslyGetNonOption(entityConfig.name)
+        ->Option.getOr(0.)
+      if (
+        !isRollback &&
+        !(writtenEntityNames->Utils.Set.has(entityConfig.name)) &&
+        nowMillis -. lastPrunedAt >= intervalMillis
+      ) {
+        concurrentCandidates->Array.push((lastPrunedAt, entityConfig))
+      } else if nowMillis -. lastPrunedAt >= intervalMillis *. forcedIntervalMultiplier {
+        forcedCandidates->Array.push((lastPrunedAt, entityConfig))
       }
-      let entityConfig = persistence.allEntities->Array.getUnsafe(idx)
-      let timeRef = Performance.now()
-      try {
-        let () = await persistence.storage.pruneStaleEntityHistory(
-          ~entityName=entityConfig.name,
-          ~entityIndex=entityConfig.index,
+    }
+  })
+
+  let sortedConcurrent = concurrentCandidates->Array.toSorted(byOldestPrune)
+  // Concurrent candidates beyond the cap are not selected, so the starved
+  // ones among them still qualify for the forced group.
+  for idx in maxEntitiesPerWrite to sortedConcurrent->Array.length - 1 {
+    let (lastPrunedAt, _) = sortedConcurrent->Array.getUnsafe(idx)
+    if nowMillis -. lastPrunedAt >= intervalMillis *. forcedIntervalMultiplier {
+      forcedCandidates->Array.push(sortedConcurrent->Array.getUnsafe(idx))
+    }
+  }
+
+  {
+    safeCheckpointId,
+    concurrent: sortedConcurrent->Array.slice(~start=0, ~end=maxEntitiesPerWrite)->toEntities,
+    forced: forcedCandidates
+    ->Array.toSorted(byOldestPrune)
+    ->Array.slice(~start=0, ~end=maxEntitiesPerWrite)
+    ->toEntities,
+  }
+}
+
+let select = (state: IndexerState.t, ~writtenEntityNames, ~isRollback) => {
+  let config = state->IndexerState.config
+  if config->Config.shouldPruneHistory(~isInReorgThreshold=state->IndexerState.isInReorgThreshold) {
+    switch state->IndexerState.getSafeCheckpointId {
+    | None => None
+    | Some(safeCheckpointId) =>
+      Some(
+        selectFrom(
+          ~allEntities=(state->IndexerState.persistence).allEntities,
+          ~lastPrunedAtMillis=state->IndexerState.lastPrunedAtMillis,
+          ~writtenEntityNames,
+          ~isRollback,
+          ~nowMillis=Date.now(),
+          ~intervalMillis=Env.ThrottleWrites.pruneStaleDataIntervalMillis->Int.toFloat,
           ~safeCheckpointId,
-        )
-      } catch {
-      | exn =>
-        exn->ErrorHandling.mkLogAndRaise(
-          ~msg=`Failed to prune stale entity history`,
-          ~logger=Logging.createChild(
-            ~params={
-              "entityName": entityConfig.name,
-              "safeCheckpointId": safeCheckpointId,
-            },
-          ),
-        )
-      }
+        ),
+      )
+    }
+  } else {
+    None
+  }
+}
+
+let pruneEntities = async (state: IndexerState.t, ~entities, ~safeCheckpointId) => {
+  let persistence = state->IndexerState.persistence
+  for idx in 0 to entities->Array.length - 1 {
+    let entityConfig: Internal.entityConfig = entities->Array.getUnsafe(idx)
+    let timeRef = Performance.now()
+    // Recorded for failures too, so a failing prune retries on the same
+    // interval instead of on every write.
+    state->IndexerState.lastPrunedAtMillis->Dict.set(entityConfig.name, Date.now())
+    switch await persistence.storage.pruneStaleEntityHistory(
+      ~entityName=entityConfig.name,
+      ~entityIndex=entityConfig.index,
+      ~safeCheckpointId,
+    ) {
+    | () =>
       Prometheus.RollbackHistoryPrune.increment(
         ~timeSeconds=Performance.secondsSince(timeRef),
         ~entityName=entityConfig.name,
       )
+    | exception exn =>
+      // Pruning is cleanup; a failure must not fail the write loop.
+      Logging.createChild(
+        ~params={
+          "entityName": entityConfig.name,
+          "safeCheckpointId": safeCheckpointId,
+        },
+      )->Logging.childErrorWithExn(exn->Utils.prettifyExn, `Failed to prune stale entity history`)
     }
   }
 }
 
-let schedule = (state: IndexerState.t) =>
-  state->IndexerState.pruneStaleEntityHistoryThrottler->Throttler.schedule(() => runPrune(state))
+let pruneCheckpoints = async (state: IndexerState.t, ~safeCheckpointId) => {
+  switch await (state->IndexerState.persistence).storage.pruneStaleCheckpoints(~safeCheckpointId) {
+  | () => ()
+  | exception exn =>
+    Logging.createChild(~params={"safeCheckpointId": safeCheckpointId})->Logging.childErrorWithExn(
+      exn->Utils.prettifyExn,
+      `Failed to prune stale checkpoints`,
+    )
+  }
+}
+
+let runConcurrent = async (state: IndexerState.t, ~targets) => {
+  switch targets {
+  | Some({safeCheckpointId, concurrent}) if concurrent->Utils.Array.notEmpty =>
+    await pruneCheckpoints(state, ~safeCheckpointId)
+    await pruneEntities(state, ~entities=concurrent, ~safeCheckpointId)
+  | Some(_) | None => ()
+  }
+}
+
+let runForced = async (state: IndexerState.t, ~targets) => {
+  switch targets {
+  | Some({safeCheckpointId, concurrent, forced}) if forced->Utils.Array.notEmpty =>
+    // When nothing ran concurrently (eg a rollback write), checkpoint pruning
+    // lands here, after the write, so it never overlaps a rollback transaction.
+    if concurrent->Utils.Array.isEmpty {
+      await pruneCheckpoints(state, ~safeCheckpointId)
+    }
+    await pruneEntities(state, ~entities=forced, ~safeCheckpointId)
+  | Some(_) | None => ()
+  }
+}

package/src/PruneStaleHistory.res.mjs

@@ -1,46 +1,140 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
+import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Throttler from "./Throttler.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
-import * as ErrorHandling from "./ErrorHandling.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-async function runPrune(state) {
-  let safeCheckpointId = IndexerState.getSafeCheckpointId(state);
-  if (safeCheckpointId === undefined) {
+function selectFrom(allEntities, lastPrunedAtMillis, writtenEntityNames, isRollback, nowMillis, intervalMillis, safeCheckpointId) {
+  let byOldestPrune = (param, param$1) => param[0] - param$1[0];
+  let toEntities = candidates => candidates.map(param => param[1]);
+  let concurrentCandidates = [];
+  let forcedCandidates = [];
+  allEntities.forEach(entityConfig => {
+    if (!entityConfig.storage.postgres) {
+      return;
+    }
+    let lastPrunedAt = Stdlib_Option.getOr(lastPrunedAtMillis[entityConfig.name], 0);
+    if (!isRollback && !writtenEntityNames.has(entityConfig.name) && nowMillis - lastPrunedAt >= intervalMillis) {
+      concurrentCandidates.push([
+        lastPrunedAt,
+        entityConfig
+      ]);
+      return;
+    } else if (nowMillis - lastPrunedAt >= intervalMillis * 5) {
+      forcedCandidates.push([
+        lastPrunedAt,
+        entityConfig
+      ]);
+      return;
+    } else {
+      return;
+    }
+  });
+  let sortedConcurrent = concurrentCandidates.toSorted(byOldestPrune);
+  for (let idx = 5, idx_finish = sortedConcurrent.length; idx < idx_finish; ++idx) {
+    let match = sortedConcurrent[idx];
+    if (nowMillis - match[0] >= intervalMillis * 5) {
+      forcedCandidates.push(sortedConcurrent[idx]);
+    }
+  }
+  return {
+    safeCheckpointId: safeCheckpointId,
+    concurrent: toEntities(sortedConcurrent.slice(0, 5)),
+    forced: toEntities(forcedCandidates.toSorted(byOldestPrune).slice(0, 5))
+  };
+}
+
+function select(state, writtenEntityNames, isRollback) {
+  let config = IndexerState.config(state);
+  if (!Config.shouldPruneHistory(config, IndexerState.isInReorgThreshold(state))) {
     return;
   }
+  let safeCheckpointId = IndexerState.getSafeCheckpointId(state);
+  if (safeCheckpointId !== undefined) {
+    return selectFrom(IndexerState.persistence(state).allEntities, IndexerState.lastPrunedAtMillis(state), writtenEntityNames, isRollback, Date.now(), Env.ThrottleWrites.pruneStaleDataIntervalMillis, safeCheckpointId);
+  }
+}
+
+async function pruneEntities(state, entities, safeCheckpointId) {
   let persistence = IndexerState.persistence(state);
-  await persistence.storage.pruneStaleCheckpoints(safeCheckpointId);
-  for (let idx = 0, idx_finish = persistence.allEntities.length; idx < idx_finish; ++idx) {
-    if (idx !== 0) {
-      await Utils.delay(1000);
-    }
-    let entityConfig = persistence.allEntities[idx];
+  for (let idx = 0, idx_finish = entities.length; idx < idx_finish; ++idx) {
+    let entityConfig = entities[idx];
     let timeRef = Performance.now();
+    IndexerState.lastPrunedAtMillis(state)[entityConfig.name] = Date.now();
+    let exit = 0;
+    let val;
     try {
-      await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+      val = await persistence.storage.pruneStaleEntityHistory(entityConfig.name, entityConfig.index, safeCheckpointId);
+      exit = 1;
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
-      ErrorHandling.mkLogAndRaise(Logging.createChild({
+      Logging.childErrorWithExn(Logging.createChild({
         entityName: entityConfig.name,
         safeCheckpointId: safeCheckpointId
-      }), `Failed to prune stale entity history`, exn);
+      }), Utils.prettifyExn(exn), `Failed to prune stale entity history`);
+    }
+    if (exit === 1) {
+      Prometheus.RollbackHistoryPrune.increment(Performance.secondsSince(timeRef), entityConfig.name);
     }
-    Prometheus.RollbackHistoryPrune.increment(Performance.secondsSince(timeRef), entityConfig.name);
   }
 }
 
-function schedule(state) {
-  Throttler.schedule(IndexerState.pruneStaleEntityHistoryThrottler(state), () => runPrune(state));
+async function pruneCheckpoints(state, safeCheckpointId) {
+  try {
+    await IndexerState.persistence(state).storage.pruneStaleCheckpoints(safeCheckpointId);
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Logging.childErrorWithExn(Logging.createChild({
+      safeCheckpointId: safeCheckpointId
+    }), Utils.prettifyExn(exn), `Failed to prune stale checkpoints`);
+  }
+}
+
+async function runConcurrent(state, targets) {
+  if (targets === undefined) {
+    return;
+  }
+  let concurrent = targets.concurrent;
+  let safeCheckpointId = targets.safeCheckpointId;
+  if (Utils.$$Array.notEmpty(concurrent)) {
+    await pruneCheckpoints(state, safeCheckpointId);
+    return await pruneEntities(state, concurrent, safeCheckpointId);
+  }
+}
+
+async function runForced(state, targets) {
+  if (targets === undefined) {
+    return;
+  }
+  let forced = targets.forced;
+  let safeCheckpointId = targets.safeCheckpointId;
+  if (Utils.$$Array.notEmpty(forced)) {
+    if (Utils.$$Array.isEmpty(targets.concurrent)) {
+      await pruneCheckpoints(state, safeCheckpointId);
+    }
+    return await pruneEntities(state, forced, safeCheckpointId);
+  }
 }
 
+let maxEntitiesPerWrite = 5;
+
+let forcedIntervalMultiplier = 5;
+
 export {
-  runPrune,
-  schedule,
+  maxEntitiesPerWrite,
+  forcedIntervalMultiplier,
+  selectFrom,
+  select,
+  pruneEntities,
+  pruneCheckpoints,
+  runConcurrent,
+  runForced,
 }
-/* Utils Not a pure module */
+/* Env Not a pure module */

package/src/RawEvent.res

@@ -32,8 +32,8 @@ let make = (
   ~blockTimestamp: int,
   ~cleanUpRawEventFieldsInPlace: JSON.t => unit,
 ): Internal.rawEvent => {
-  let {onEventRegistration, chain, blockNumber, logIndex} = eventItem
-  let eventConfig = onEventRegistration.eventConfig
+  let {chain, blockNumber, logIndex} = eventItem
+  let eventConfig = eventItem.onEventRegistration.eventConfig
   let chainId = chain->ChainMap.Chain.toChainId
   let eventId = EventUtils.packEventIndex(~logIndex, ~blockNumber)
   let blockFields =

package/src/Rollback.res

@@ -72,7 +72,7 @@ let rec rollback = async (
     // found yet. Wait for the ReorgDetected branch above to find it and re-kick.
     | FindingReorgDepth => ()
     | FoundReorgDepth(_) if state->IndexerState.isProcessing =>
-      Logging.info("Waiting for batch to finish processing before executing rollback")
+      Logging.trace("Waiting for batch to finish processing before executing rollback")
     | FoundReorgDepth({chain: reorgChain, rollbackTargetBlockNumber}) =>
       await executeRollback(
         state,
@@ -96,10 +96,10 @@ and executeRollback = async (
 ) => {
   let startTime = Performance.now()
 
-  let chainState = state->IndexerState.getChainState(~chain=reorgChain)
-
-  let logger = Logging.createChildFrom(
-    ~logger=chainState->ChainState.logger,
+  // Not derived from the reorg chain's logger: that would bind its chainId onto
+  // every line, colliding with the per-chain chainId on the "Rollbacked" logs.
+  // The reorg chain is identified by the reorgChain param instead.
+  let logger = Logging.createChild(
     ~params={
       "action": "Rollback",
       "reorgChain": reorgChain,
@@ -161,10 +161,12 @@ and executeRollback = async (
     }
   }
 
+  let rolledBackChains = []
   state
   ->IndexerState.chainStates
   ->Utils.Dict.forEach(cs => {
     let chainId = (cs->ChainState.chainConfig).id
+    let fromBlock = cs->ChainState.committedProgressBlockNumber
     cs->ChainState.rollback(
       ~newProgressBlockNumber=newProgressBlockNumberPerChain->Utils.Dict.dangerouslyGetByIntNonOption(
         chainId,
@@ -175,6 +177,19 @@ and executeRollback = async (
       ~rollbackTargetBlockNumber,
       ~isReorgChain=chainId === reorgChainId,
     )
+    let toBlock = cs->ChainState.committedProgressBlockNumber
+    if fromBlock !== toBlock {
+      rolledBackChains
+      ->Array.push({
+        "chainId": chainId,
+        "fromBlock": fromBlock,
+        "toBlock": toBlock,
+        "rollbackedEvents": eventsProcessedDiffByChain
+        ->Utils.Dict.dangerouslyGetByIntNonOption(chainId)
+        ->Option.getOr(0.),
+      })
+      ->ignore
+    }
   })
 
   let diff = await state->InMemoryStore.prepareRollbackDiff(
@@ -183,15 +198,19 @@ and executeRollback = async (
     ~progressBlockNumberByChainId=newProgressBlockNumberPerChain,
   )
 
+  rolledBackChains->Array.forEach(chain => {
+    logger->Logging.childInfo({
+      "msg": "Rollbacked",
+      "chainId": chain["chainId"],
+      "fromBlock": chain["fromBlock"],
+      "toBlock": chain["toBlock"],
+      "rollbackedEvents": chain["rollbackedEvents"],
+    })
+  })
   logger->Logging.childTrace({
-    "msg": "Finished rollback on reorg",
-    "entityChanges": {
-      "deleted": diff["deletedEntities"],
-      "upserted": diff["setEntities"],
-    },
-    "rollbackedEvents": rollbackedProcessedEvents.contents,
-    "beforeCheckpointId": state->IndexerState.committedCheckpointId,
-    "targetCheckpointId": rollbackTargetCheckpointId,
+    "msg": "Rollback entity changes",
+    "deleted": diff["deletedEntities"],
+    "upserted": diff["setEntities"],
   })
   Prometheus.RollbackSuccess.increment(
     ~timeSeconds=Performance.secondsSince(startTime),

package/src/Rollback.res.mjs

@@ -33,8 +33,7 @@ async function getLastKnownValidBlock(chainState, reorgBlockNumber, isRealtime)
 
 async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing) {
   let startTime = Performance.now();
-  let chainState = IndexerState.getChainState(state, reorgChain);
-  let logger = Logging.createChildFrom(ChainState.logger(chainState), {
+  let logger = Logging.createChild({
     action: "Rollback",
     reorgChain: reorgChain,
     targetBlockNumber: rollbackTargetBlockNumber
@@ -55,20 +54,34 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     eventsProcessedDiffByChain[diff.chain_id] = eventsProcessedDiff;
     newProgressBlockNumberPerChain[diff.chain_id] = rollbackTargetCheckpointId === 0n && diff.chain_id === reorgChain ? Primitive_int.min(diff.new_progress_block_number, rollbackTargetBlockNumber) : diff.new_progress_block_number;
   }
+  let rolledBackChains = [];
   Utils.Dict.forEach(IndexerState.chainStates(state), cs => {
     let chainId = ChainState.chainConfig(cs).id;
+    let fromBlock = ChainState.committedProgressBlockNumber(cs);
     ChainState.rollback(cs, newProgressBlockNumberPerChain[chainId], eventsProcessedDiffByChain[chainId], rollbackTargetBlockNumber, chainId === reorgChain);
+    let toBlock = ChainState.committedProgressBlockNumber(cs);
+    if (fromBlock !== toBlock) {
+      rolledBackChains.push({
+        chainId: chainId,
+        fromBlock: fromBlock,
+        toBlock: toBlock,
+        rollbackedEvents: Stdlib_Option.getOr(eventsProcessedDiffByChain[chainId], 0)
+      });
+      return;
+    }
   });
   let diff$1 = await InMemoryStore.prepareRollbackDiff(state, rollbackTargetCheckpointId, IndexerState.committedCheckpointId(state) + 1n, newProgressBlockNumberPerChain);
+  rolledBackChains.forEach(chain => Logging.childInfo(logger, {
+    msg: "Rollbacked",
+    chainId: chain.chainId,
+    fromBlock: chain.fromBlock,
+    toBlock: chain.toBlock,
+    rollbackedEvents: chain.rollbackedEvents
+  }));
   Logging.childTrace(logger, {
-    msg: "Finished rollback on reorg",
-    entityChanges: {
-      deleted: diff$1.deletedEntities,
-      upserted: diff$1.setEntities
-    },
-    rollbackedEvents: rollbackedProcessedEvents,
-    beforeCheckpointId: IndexerState.committedCheckpointId(state),
-    targetCheckpointId: rollbackTargetCheckpointId
+    msg: "Rollback entity changes",
+    deleted: diff$1.deletedEntities,
+    upserted: diff$1.setEntities
   });
   Prometheus.RollbackSuccess.increment(Performance.secondsSince(startTime), rollbackedProcessedEvents);
   IndexerState.completeRollback(state, eventsProcessedDiffByChain);
@@ -97,7 +110,7 @@ async function rollback(state, scheduleFetch, scheduleProcessing, scheduleRollba
         return scheduleRollback();
       case "FoundReorgDepth" :
         if (IndexerState.isProcessing(state)) {
-          return Logging.info("Waiting for batch to finish processing before executing rollback");
+          return Logging.trace("Waiting for batch to finish processing before executing rollback");
         } else {
           return await executeRollback(state, match.chain, match.rollbackTargetBlockNumber, scheduleFetch, scheduleProcessing);
         }

package/src/SimulateDeadInputTracker.res

@@ -10,7 +10,7 @@ let itemKey = (item: Internal.item): string =>
     `${chain
       ->ChainMap.Chain.toChainId
       ->Int.toString}:${blockNumber->Int.toString}:${logIndex->Int.toString}`
-  | _ => "" // non-event items are never a provided simulate input
+  | Internal.Block(_) => ""
   }
 
 // `index` is the item's position in its chain's `simulate` array, reported back