envio 3.3.0 → 3.3.1-rc.0

package/src/EventProcessing.res

@@ -74,7 +74,7 @@ let runEventHandlerOrThrow = async (
   }
   let handlerDuration = timeBeforeHandler->Performance.secondsSince
   let eventConfig = eventItem.onEventRegistration.eventConfig
-  Prometheus.ProcessingHandler.increment(
+  indexerState->IndexerState.recordHandlerDuration(
     ~contract=eventConfig.contractName,
     ~event=eventConfig.name,
     ~duration=handlerDuration,
@@ -163,16 +163,18 @@ let preloadBatchOrThrow = async (
       let item = batch.items->Array.getUnsafe(itemIdx.contents + idx)
       switch item {
       | Event(_) =>
-        let {handler, eventConfig: {contractName, name: eventName}} =
-          (item->Internal.castUnsafeEventItem).onEventRegistration
+        let {handler, eventConfig: {contractName, name: eventName}} = (
+          item->Internal.castUnsafeEventItem
+        ).onEventRegistration
         switch handler {
         | None => ()
         | Some(handler) =>
           try {
-            let timerRef = Prometheus.PreloadHandler.startOperation(
-              ~contract=contractName,
-              ~event=eventName,
-            )
+            let timerRef =
+              indexerState->IndexerState.startPreloadHandler(
+                ~contract=contractName,
+                ~event=eventName,
+              )
             promises->Array.push(
               handler({
                 event: item->Ecosystem.getItemEvent(~ecosystem=config.ecosystem),
@@ -189,7 +191,8 @@ let preloadBatchOrThrow = async (
                 }),
               })
               ->Promise.thenResolve(_ => {
-                timerRef->Prometheus.PreloadHandler.endOperation(
+                indexerState->IndexerState.endPreloadHandler(
+                  timerRef,
                   ~contract=contractName,
                   ~event=eventName,
                 )
@@ -270,6 +273,7 @@ let runBatchHandlersOrThrow = async (
 let registerProcessEventBatchMetrics = (
   ~logger,
   ~batch: Batch.t,
+  ~indexerState,
   ~loadDuration,
   ~handlerDuration,
 ) => {
@@ -282,7 +286,7 @@ let registerProcessEventBatchMetrics = (
     })
   })
 
-  Prometheus.ProcessingBatch.registerMetrics(~loadDuration, ~handlerDuration)
+  indexerState->IndexerState.recordBatchDurations(~loadDuration, ~handlerDuration)
 }
 
 type logPartitionInfo = {
@@ -380,6 +384,7 @@ let processEventBatch = async (
     registerProcessEventBatchMetrics(
       ~logger,
       ~batch,
+      ~indexerState,
       ~loadDuration=loaderDuration,
       ~handlerDuration,
     )

package/src/EventProcessing.res.mjs

@@ -6,12 +6,12 @@ import * as Writing from "./Writing.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
-import * as Prometheus from "./Prometheus.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as UserContext from "./UserContext.res.mjs";
+import * as IndexerState from "./IndexerState.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
@@ -66,7 +66,7 @@ async function runEventHandlerOrThrow(item, checkpointId, handler, indexerState,
   }
   let handlerDuration = Performance.secondsSince(timeBeforeHandler);
   let eventConfig = item.onEventRegistration.eventConfig;
-  return Prometheus.ProcessingHandler.increment(eventConfig.contractName, eventConfig.name, handlerDuration);
+  return IndexerState.recordHandlerDuration(indexerState, eventConfig.contractName, eventConfig.name, handlerDuration);
 }
 
 async function runHandlerOrThrow(item, checkpointId, indexerState, loadManager, persistence, config, chains) {
@@ -121,7 +121,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
           let contractName = match$1.contractName;
           let eventName = match$1.name;
           try {
-            let timerRef = Prometheus.PreloadHandler.startOperation(contractName, eventName);
+            let timerRef = IndexerState.startPreloadHandler(indexerState, contractName, eventName);
             promises.push(Utils.$$Promise.silentCatch(handler({
               event: Ecosystem.getItemEvent(item, config.ecosystem),
               context: UserContext.getHandlerContext({
@@ -135,7 +135,7 @@ async function preloadBatchOrThrow(batch, loadManager, persistence, config, inde
                 config: config,
                 isResolved: false
               })
-            }).then(() => Prometheus.PreloadHandler.endOperation(timerRef, contractName, eventName))));
+            }).then(() => IndexerState.endPreloadHandler(indexerState, timerRef, contractName, eventName))));
           } catch (exn) {
             
           }
@@ -176,14 +176,14 @@ async function runBatchHandlersOrThrow(batch, indexerState, loadManager, persist
   }
 }
 
-function registerProcessEventBatchMetrics(logger, batch, loadDuration, handlerDuration) {
+function registerProcessEventBatchMetrics(logger, batch, indexerState, loadDuration, handlerDuration) {
   Stdlib_Dict.forEachWithKey(batch.progressedChainsById, (chainAfterBatch, chainId) => Logging.childTrace(logger, {
     msg: "Finished processing",
     chainId: Stdlib_Int.fromString(chainId, undefined),
     batchSize: chainAfterBatch.batchSize,
     progress: chainAfterBatch.progressBlockNumber
   }));
-  Prometheus.ProcessingBatch.registerMetrics(loadDuration, handlerDuration);
+  IndexerState.recordBatchDurations(indexerState, loadDuration, handlerDuration);
 }
 
 async function materializeBatchEvents(batch, chainStates, ecosystem) {
@@ -231,7 +231,7 @@ async function processEventBatch(batch, indexerState, loadManager, persistence,
     let elapsedTimeAfterProcessing = Performance.secondsSince(timeRef);
     Writing.commitBatch(indexerState, batch);
     let handlerDuration = elapsedTimeAfterProcessing - elapsedTimeAfterLoaders;
-    registerProcessEventBatchMetrics(logger, batch, elapsedTimeAfterLoaders, handlerDuration);
+    registerProcessEventBatchMetrics(logger, batch, indexerState, elapsedTimeAfterLoaders, handlerDuration);
     return {
       TAG: "Ok",
       _0: undefined

package/src/FetchState.res

@@ -909,19 +909,6 @@ let updateInternal = (
     firstEventBlock: fetchState.firstEventBlock,
   }
 
-  Prometheus.IndexingPartitions.set(
-    ~partitionsCount=optimizedPartitions->OptimizedPartitions.count,
-    ~chainId=fetchState.chainId,
-  )
-  Prometheus.IndexingBufferSize.set(
-    ~bufferSize=updatedFetchState.buffer->Array.length,
-    ~chainId=fetchState.chainId,
-  )
-  Prometheus.IndexingBufferBlockNumber.set(
-    ~blockNumber=updatedFetchState->bufferBlockNumber,
-    ~chainId=fetchState.chainId,
-  )
-
   updatedFetchState
 }
 
@@ -2340,22 +2327,13 @@ let make = (
     firstEventBlock,
   }
 
-  Prometheus.IndexingPartitions.set(
-    ~partitionsCount=optimizedPartitions->OptimizedPartitions.count,
-    ~chainId,
-  )
-  Prometheus.IndexingBufferSize.set(~bufferSize=buffer->Array.length, ~chainId)
-  Prometheus.IndexingBufferBlockNumber.set(~blockNumber=fetchState->bufferBlockNumber, ~chainId)
-  switch endBlock {
-  | Some(endBlock) => Prometheus.IndexingEndBlock.set(~endBlock, ~chainId)
-  | None => ()
-  }
-
   fetchState
 }
 
 let bufferSize = ({buffer}: t) => buffer->Array.length
 
+let partitionsCount = ({optimizedPartitions}: t) => optimizedPartitions->OptimizedPartitions.count
+
 let rollbackPendingQueries = (mutPendingQueries: array<pendingQuery>, ~targetBlockNumber) => {
   // - Remove queries where fromBlock > target
   // - Cap fetchedBlock at target where fetchedBlock > target
@@ -2556,14 +2534,26 @@ let isFetchingAtHead = ({endBlock, blockLag, knownHeight} as fetchState: t) => {
     }
 }
 
-let isReadyToEnterReorgThreshold = ({endBlock, blockLag, buffer, knownHeight} as fetchState: t) => {
+// Frontier at (or within `tolerance` of) the lagged head with no processable
+// items left — the moment the chain can cross into the reorg threshold.
+// `tolerance` absorbs the head advancing between a chain catching up and this
+// check, so it applies only when the (moving) head is the target: a finite
+// endBlock at or below the lagged head is an exact target and is reached without
+// tolerance. Uses bufferReadyCount, not an empty buffer: items stuck above the
+// frontier behind a lagging partition's gap are reorg-safe (all <= head -
+// blockLag) and must not defer entry, or a many-partition chain never enters.
+let isReadyToEnterReorgThreshold = (
+  ~tolerance,
+  {endBlock, blockLag, knownHeight} as fetchState: t,
+) => {
   let bufferBlockNumber = fetchState->bufferBlockNumber
+  let laggedHead = knownHeight - blockLag
   knownHeight !== 0 &&
   switch endBlock {
-  | Some(endBlock) if bufferBlockNumber >= endBlock => true
-  | _ => bufferBlockNumber >= knownHeight - blockLag
+  | Some(endBlock) if endBlock <= laggedHead => bufferBlockNumber >= endBlock
+  | _ => bufferBlockNumber >= laggedHead - tolerance
   } &&
-  buffer->Utils.Array.isEmpty
+  fetchState->bufferReadyCount == 0
 }
 
 // Lower progress percentage = further behind = higher priority. Progress is
@@ -2630,7 +2620,6 @@ let getProgressBlockNumberAt = ({buffer} as fetchState: t, ~index) => {
 
 let updateKnownHeight = (fetchState: t, ~knownHeight) => {
   if knownHeight > fetchState.knownHeight {
-    Prometheus.IndexingKnownHeight.set(~blockNumber=knownHeight, ~chainId=fetchState.chainId)
     fetchState->updateInternal(~knownHeight)
   } else {
     fetchState

package/src/FetchState.res.mjs

@@ -3,7 +3,6 @@
 import * as Utils from "./Utils.res.mjs";
 import * as Js_math from "@rescript/runtime/lib/es6/Js_math.js";
 import * as Logging from "./Logging.res.mjs";
-import * as Prometheus from "./Prometheus.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
@@ -679,34 +678,21 @@ function updateInternal(fetchState, optimizedPartitionsOpt, mutItems, mutItemsSo
   } else {
     latestOnBlockBlockNumber = knownHeight;
   }
-  let updatedFetchState_startBlock = fetchState.startBlock;
-  let updatedFetchState_endBlock = fetchState.endBlock;
-  let updatedFetchState_normalSelection = fetchState.normalSelection;
-  let updatedFetchState_contractConfigs = fetchState.contractConfigs;
-  let updatedFetchState_chainId = fetchState.chainId;
-  let updatedFetchState_buffer = blockItems.length !== 0 ? mergeIntoBuffer(base, blockItems) : base;
-  let updatedFetchState_maxOnBlockBufferSize = fetchState.maxOnBlockBufferSize;
-  let updatedFetchState_onBlockRegistrations = fetchState.onBlockRegistrations;
-  let updatedFetchState_firstEventBlock = fetchState.firstEventBlock;
-  let updatedFetchState = {
+  return {
     optimizedPartitions: optimizedPartitions,
-    startBlock: updatedFetchState_startBlock,
-    endBlock: updatedFetchState_endBlock,
-    normalSelection: updatedFetchState_normalSelection,
-    contractConfigs: updatedFetchState_contractConfigs,
-    chainId: updatedFetchState_chainId,
+    startBlock: fetchState.startBlock,
+    endBlock: fetchState.endBlock,
+    normalSelection: fetchState.normalSelection,
+    contractConfigs: fetchState.contractConfigs,
+    chainId: fetchState.chainId,
     latestOnBlockBlockNumber: latestOnBlockBlockNumber,
     blockLag: blockLag,
-    buffer: updatedFetchState_buffer,
-    maxOnBlockBufferSize: updatedFetchState_maxOnBlockBufferSize,
-    onBlockRegistrations: updatedFetchState_onBlockRegistrations,
+    buffer: blockItems.length !== 0 ? mergeIntoBuffer(base, blockItems) : base,
+    maxOnBlockBufferSize: fetchState.maxOnBlockBufferSize,
+    onBlockRegistrations: fetchState.onBlockRegistrations,
     knownHeight: knownHeight,
-    firstEventBlock: updatedFetchState_firstEventBlock
+    firstEventBlock: fetchState.firstEventBlock
   };
-  Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, fetchState.chainId);
-  Prometheus.IndexingBufferSize.set(updatedFetchState_buffer.length, fetchState.chainId);
-  Prometheus.IndexingBufferBlockNumber.set(bufferBlockNumber(updatedFetchState), fetchState.chainId);
-  return updatedFetchState;
 }
 
 function warnDifferentContractType(fetchState, existingContract, dc) {
@@ -1525,7 +1511,7 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
   } else {
     latestOnBlockBlockNumber = progressBlockNumber;
   }
-  let fetchState = {
+  return {
     optimizedPartitions: optimizedPartitions,
     startBlock: startBlock,
     endBlock: endBlock,
@@ -1540,19 +1526,16 @@ function make$1(startBlock, endBlock, onEventRegistrations, contractConfigs, add
     knownHeight: knownHeight,
     firstEventBlock: firstEventBlock
   };
-  Prometheus.IndexingPartitions.set(optimizedPartitions.idsInAscOrder.length, chainId);
-  Prometheus.IndexingBufferSize.set(buffer.length, chainId);
-  Prometheus.IndexingBufferBlockNumber.set(bufferBlockNumber(fetchState), chainId);
-  if (endBlock !== undefined) {
-    Prometheus.IndexingEndBlock.set(endBlock, chainId);
-  }
-  return fetchState;
 }
 
 function bufferSize(param) {
   return param.buffer.length;
 }
 
+function partitionsCount(param) {
+  return param.optimizedPartitions.idsInAscOrder.length;
+}
+
 function rollbackPendingQueries(mutPendingQueries, targetBlockNumber) {
   let adjusted = [];
   for (let qIdx = 0, qIdx_finish = mutPendingQueries.length; qIdx < qIdx_finish; ++qIdx) {
@@ -1750,15 +1733,15 @@ function isFetchingAtHead(fetchState) {
   }
 }
 
-function isReadyToEnterReorgThreshold(fetchState) {
+function isReadyToEnterReorgThreshold(tolerance, fetchState) {
   let knownHeight = fetchState.knownHeight;
-  let blockLag = fetchState.blockLag;
   let endBlock = fetchState.endBlock;
   let bufferBlockNumber$1 = bufferBlockNumber(fetchState);
+  let laggedHead = knownHeight - fetchState.blockLag | 0;
   if (knownHeight !== 0 && (
-      endBlock !== undefined && bufferBlockNumber$1 >= endBlock ? true : bufferBlockNumber$1 >= (knownHeight - blockLag | 0)
+      endBlock !== undefined && endBlock <= laggedHead ? bufferBlockNumber$1 >= endBlock : bufferBlockNumber$1 >= (laggedHead - tolerance | 0)
     )) {
-    return Utils.$$Array.isEmpty(fetchState.buffer);
+    return bufferReadyCount(fetchState) === 0;
   } else {
     return false;
   }
@@ -1824,7 +1807,6 @@ function getProgressBlockNumberAt(fetchState, index) {
 
 function updateKnownHeight(fetchState, knownHeight) {
   if (knownHeight > fetchState.knownHeight) {
-    Prometheus.IndexingKnownHeight.set(knownHeight, fetchState.chainId);
     return updateInternal(fetchState, undefined, undefined, undefined, undefined, knownHeight);
   } else {
     return fetchState;
@@ -1876,6 +1858,7 @@ export {
   getReadyItemsCount,
   make$1 as make,
   bufferSize,
+  partitionsCount,
   rollbackPendingQueries,
   rollback,
   resetPendingQueries,

package/src/IndexerState.res

@@ -28,6 +28,49 @@ module EntityTables = {
   }
 }
 
+// Per-(contract, event) handler counters rendered into the
+// envio_processing_handler_* and envio_preload_handler_* metrics.
+type handlerStat = {
+  contract: string,
+  event: string,
+  mutable processingSeconds: float,
+  // Floats: cumulative counters outgrow int32.
+  mutable processingCount: float,
+  // Wall-clock preload time: overlapping preloads of the same handler count once.
+  mutable preloadSeconds: float,
+  mutable preloadCount: float,
+  // Cumulative per-call preload time; exceeds preloadSeconds under parallel execution.
+  mutable preloadSecondsTotal: float,
+  mutable preloadPendingCount: int,
+  mutable preloadPendingTimerRef: Performance.timeRef,
+}
+
+// Per-(storage, operation) load counters rendered into the
+// envio_storage_load_* metrics.
+type storageLoadStat = {
+  operation: string,
+  storage: string,
+  // Wall-clock load time: overlapping loads of the same operation count once.
+  mutable seconds: float,
+  mutable secondsTotal: float,
+  mutable count: float,
+  mutable whereSize: float,
+  mutable size: float,
+  mutable pendingCount: int,
+  mutable pendingTimerRef: Performance.timeRef,
+}
+
+type storageWriteStat = {
+  storage: string,
+  mutable seconds: float,
+  mutable count: int,
+}
+
+type historyPruneStat = {
+  mutable seconds: float,
+  mutable count: int,
+}
+
 type t = {
   config: Config.t,
   persistence: Persistence.t,
@@ -82,6 +125,16 @@ type t = {
   mutable epoch: int,
   // None off the simulate path.
   simulateDeadInputTracker: option<SimulateDeadInputTracker.t>,
+  // --- Metric counters, rendered by Metrics at scrape time. ---
+  mutable preloadSeconds: float,
+  mutable processingSeconds: float,
+  handlerStats: dict<handlerStat>,
+  storageLoadStats: dict<storageLoadStat>,
+  storageWriteStats: dict<storageWriteStat>,
+  historyPruneStats: dict<historyPruneStat>,
+  mutable rollbackSeconds: float,
+  mutable rollbackCount: int,
+  mutable rollbackEventsCount: float,
 }
 
 let make = (
@@ -144,6 +197,15 @@ let make = (
     isStopped: false,
     epoch: 0,
     simulateDeadInputTracker: SimulateDeadInputTracker.makeFromConfig(config),
+    preloadSeconds: 0.,
+    processingSeconds: 0.,
+    handlerStats: Dict.make(),
+    storageLoadStats: Dict.make(),
+    storageWriteStats: Dict.make(),
+    historyPruneStats: Dict.make(),
+    rollbackSeconds: 0.,
+    rollbackCount: 0,
+    rollbackEventsCount: 0.,
   }
 }
 
@@ -181,16 +243,6 @@ let makeFromDbState = (
     )
   }
 
-  Prometheus.ProcessingMaxBatchSize.set(~maxBatchSize=config.batchSize)
-  Prometheus.ReorgThreshold.set(~isInReorgThreshold)
-  initialState.cache->Utils.Dict.forEach(({effectName, count, scope}) => {
-    Prometheus.EffectCacheCount.set(
-      ~count,
-      ~effectName,
-      ~scope=scope->Internal.EffectCache.scopeToString,
-    )
-  })
-
   // updateSyncTimeOnRestart wipes the saved timestamp so a restart re-enters
   // backfill mode for all chains.
   let isRealtime =
@@ -216,27 +268,7 @@ let makeFromDbState = (
     )
   })
 
-  // Set initial progress metrics from DB state so dashboards reflect
-  // the persisted state immediately on restart
-  let allChainsReady = ref(initialState.chains->Array.length > 0)
-  chainStates->Utils.Dict.forEach(cs => {
-    let chainId = (cs->ChainState.chainConfig).id
-    Prometheus.ProgressBlockNumber.set(
-      ~blockNumber=cs->ChainState.committedProgressBlockNumber,
-      ~chainId,
-    )
-    Prometheus.ProgressReady.init(~chainId)
-    if cs->ChainState.isReady {
-      Prometheus.ProgressReady.set(~chainId)
-    } else {
-      allChainsReady := false
-    }
-  })
-  if allChainsReady.contents {
-    Prometheus.ProgressReady.setAllReady()
-  }
-
-  make(
+  let state = make(
     ~config,
     ~persistence,
     ~chainStates,
@@ -249,6 +281,10 @@ let makeFromDbState = (
     ~exitAfterFirstEventBlock,
     ~onError,
   )
+  initialState.cache->Utils.Dict.forEach(({effectName, count, scope}) => {
+    state.effectState->EffectState.setUnregisteredCacheCount(~effectName, ~scope, ~count)
+  })
+  state
 }
 
 // A fetch response or new-block waiter is stale once the indexer stopped or the
@@ -384,6 +420,219 @@ let epoch = (state: t) => state.epoch
 let lastPrunedAtMillis = (state: t) => state.lastPrunedAtMillis
 let simulateDeadInputTracker = (state: t) => state.simulateDeadInputTracker
 
+// Read-only snapshot of every metric; the single window into the mutable
+// counters for the /metrics endpoint, the TUI and the console API.
+let toMetrics = (state: t): Metrics.t => {
+  let chainStates = state.crossChainState->CrossChainState.chainStates
+  let sourceRequests = []
+  let sourceHeights = []
+  chainStates->Utils.Dict.forEach(cs => {
+    let sourceManager = cs->ChainState.sourceManager
+    sourceManager
+    ->SourceManager.getRequestStatSamples
+    ->Array.forEach(s =>
+      sourceRequests->Array.push({
+        Metrics.source: s.sourceName,
+        chainId: s.chainId,
+        method: s.method,
+        count: s.count,
+        seconds: s.seconds,
+      })
+    )
+    sourceManager
+    ->SourceManager.getSourceHeightSamples
+    ->Array.forEach(s =>
+      sourceHeights->Array.push({
+        Metrics.source: s.sourceName,
+        chainId: s.chainId,
+        height: s.height,
+      })
+    )
+  })
+  let historyPrunes = []
+  state.historyPruneStats->Utils.Dict.forEachWithKey((s, entityName) =>
+    historyPrunes->Array.push({
+      Metrics.entity: entityName,
+      seconds: s.seconds,
+      count: s.count,
+    })
+  )
+  {
+    startTime: state.indexerStartTime,
+    targetBufferSize: state.crossChainState->CrossChainState.targetBufferSize,
+    isInReorgThreshold: state.crossChainState->CrossChainState.isInReorgThreshold,
+    rollbackEnabled: state.config.shouldRollbackOnReorg,
+    maxBatchSize: state.config.batchSize,
+    preloadSeconds: state.preloadSeconds,
+    processingSeconds: state.processingSeconds,
+    rollbackSeconds: state.rollbackSeconds,
+    rollbackCount: state.rollbackCount,
+    rollbackEventsCount: state.rollbackEventsCount,
+    chains: chainStates->Dict.valuesToArray->Array.map(ChainState.toMetrics),
+    handlers: state.handlerStats
+    ->Dict.valuesToArray
+    ->Array.map(s => {
+      Metrics.contract: s.contract,
+      event: s.event,
+      processingSeconds: s.processingSeconds,
+      processingCount: s.processingCount,
+      preloadSeconds: s.preloadSeconds,
+      preloadCount: s.preloadCount,
+      preloadSecondsTotal: s.preloadSecondsTotal,
+    }),
+    effects: state.effectState->EffectState.toMetrics,
+    storageLoads: state.storageLoadStats
+    ->Dict.valuesToArray
+    ->Array.map(s => {
+      Metrics.operation: s.operation,
+      storage: s.storage,
+      seconds: s.seconds,
+      secondsTotal: s.secondsTotal,
+      count: s.count,
+      whereSize: s.whereSize,
+      size: s.size,
+    }),
+    storageWrites: state.storageWriteStats
+    ->Dict.valuesToArray
+    ->Array.map(s => {
+      Metrics.storage: s.storage,
+      seconds: s.seconds,
+      count: s.count,
+    }),
+    historyPrunes,
+    sourceRequests,
+    sourceHeights,
+  }
+}
+
+// --- Metric counters. ---
+
+let recordBatchDurations = (state: t, ~loadDuration, ~handlerDuration) => {
+  state.preloadSeconds = state.preloadSeconds +. loadDuration
+  state.processingSeconds = state.processingSeconds +. handlerDuration
+}
+
+let getHandlerStat = (state: t, ~contract, ~event) => {
+  // Length-prefixed so names containing the separator can't collide.
+  let key = contract->String.length->Int.toString ++ ":" ++ contract ++ event
+  switch state.handlerStats->Utils.Dict.dangerouslyGetNonOption(key) {
+  | Some(stat) => stat
+  | None =>
+    let stat: handlerStat = {
+      contract,
+      event,
+      processingSeconds: 0.,
+      processingCount: 0.,
+      preloadSeconds: 0.,
+      preloadCount: 0.,
+      preloadSecondsTotal: 0.,
+      preloadPendingCount: 0,
+      preloadPendingTimerRef: %raw(`null`),
+    }
+    state.handlerStats->Dict.set(key, stat)
+    stat
+  }
+}
+
+let recordHandlerDuration = (state: t, ~contract, ~event, ~duration) => {
+  let stat = state->getHandlerStat(~contract, ~event)
+  stat.processingSeconds = stat.processingSeconds +. duration
+  stat.processingCount = stat.processingCount +. 1.
+}
+
+let startPreloadHandler = (state: t, ~contract, ~event) => {
+  let stat = state->getHandlerStat(~contract, ~event)
+  if stat.preloadPendingCount === 0 {
+    stat.preloadPendingTimerRef = Performance.now()
+  }
+  stat.preloadPendingCount = stat.preloadPendingCount + 1
+  Performance.now()
+}
+
+let endPreloadHandler = (state: t, timerRef, ~contract, ~event) => {
+  let stat = state->getHandlerStat(~contract, ~event)
+  stat.preloadPendingCount = stat.preloadPendingCount - 1
+  if stat.preloadPendingCount === 0 {
+    stat.preloadSeconds =
+      stat.preloadSeconds +. stat.preloadPendingTimerRef->Performance.secondsSince
+  }
+  stat.preloadSecondsTotal = stat.preloadSecondsTotal +. timerRef->Performance.secondsSince
+  stat.preloadCount = stat.preloadCount +. 1.
+}
+
+let getStorageLoadStat = (state: t, ~storage, ~operation) => {
+  // Length-prefixed so names containing the separator can't collide.
+  let key = storage->String.length->Int.toString ++ ":" ++ storage ++ operation
+  switch state.storageLoadStats->Utils.Dict.dangerouslyGetNonOption(key) {
+  | Some(stat) => stat
+  | None =>
+    let stat: storageLoadStat = {
+      operation,
+      storage,
+      seconds: 0.,
+      secondsTotal: 0.,
+      count: 0.,
+      whereSize: 0.,
+      size: 0.,
+      pendingCount: 0,
+      pendingTimerRef: %raw(`null`),
+    }
+    state.storageLoadStats->Dict.set(key, stat)
+    stat
+  }
+}
+
+let startStorageLoad = (state: t, ~storage, ~operation) => {
+  let stat = state->getStorageLoadStat(~storage, ~operation)
+  if stat.pendingCount === 0 {
+    stat.pendingTimerRef = Performance.now()
+  }
+  stat.pendingCount = stat.pendingCount + 1
+  Performance.now()
+}
+
+let endStorageLoad = (state: t, timerRef, ~storage, ~operation, ~whereSize, ~size) => {
+  let stat = state->getStorageLoadStat(~storage, ~operation)
+  stat.pendingCount = stat.pendingCount - 1
+  if stat.pendingCount === 0 {
+    stat.seconds = stat.seconds +. stat.pendingTimerRef->Performance.secondsSince
+  }
+  stat.secondsTotal = stat.secondsTotal +. timerRef->Performance.secondsSince
+  stat.count = stat.count +. 1.
+  stat.whereSize = stat.whereSize +. whereSize->Int.toFloat
+  stat.size = stat.size +. size->Int.toFloat
+}
+
+let recordStorageWrite = (state: t, ~storage, ~timeSeconds) => {
+  let stat = switch state.storageWriteStats->Utils.Dict.dangerouslyGetNonOption(storage) {
+  | Some(stat) => stat
+  | None =>
+    let stat: storageWriteStat = {storage, seconds: 0., count: 0}
+    state.storageWriteStats->Dict.set(storage, stat)
+    stat
+  }
+  stat.seconds = stat.seconds +. timeSeconds
+  stat.count = stat.count + 1
+}
+
+let recordHistoryPrune = (state: t, ~entityName, ~timeSeconds) => {
+  let stat = switch state.historyPruneStats->Utils.Dict.dangerouslyGetNonOption(entityName) {
+  | Some(stat) => stat
+  | None =>
+    let stat: historyPruneStat = {seconds: 0., count: 0}
+    state.historyPruneStats->Dict.set(entityName, stat)
+    stat
+  }
+  stat.seconds = stat.seconds +. timeSeconds
+  stat.count = stat.count + 1
+}
+
+let recordRollbackSuccess = (state: t, ~timeSeconds, ~rollbackedProcessedEvents) => {
+  state.rollbackSeconds = state.rollbackSeconds +. timeSeconds
+  state.rollbackCount = state.rollbackCount + 1
+  state.rollbackEventsCount = state.rollbackEventsCount +. rollbackedProcessedEvents
+}
+
 // --- Store domain operations. ---
 
 // Queue a processed batch for writing and advance the processing frontier.