envio 3.3.0-alpha.6 → 3.3.0-alpha.8

package/src/sources/RpcSource.res

@@ -48,18 +48,16 @@ let getKnownRawBlockWithBackoff = async (
   ~chain,
   ~blockNumber,
   ~backoffMsOnFailure,
+  ~recordRequest: (~method: string, ~seconds: float) => unit,
 ) => {
   let currentBackoff = ref(backoffMsOnFailure)
   let result = ref(None)
 
   while result.contents->Option.isNone {
-    Prometheus.SourceRequestCount.increment(
-      ~sourceName,
-      ~chainId=chain->ChainMap.Chain.toChainId,
-      ~method="eth_getBlockByNumber",
-    )
+    let timerRef = Performance.now()
     switch await getKnownRawBlock(~client, ~blockNumber) {
     | exception err =>
+      recordRequest(~method="eth_getBlockByNumber", ~seconds=timerRef->Performance.secondsSince)
       Logging.warn({
         "err": err->Utils.prettifyExn,
         "msg": `Issue while running fetching batch of events from the RPC. Will wait ${currentBackoff.contents->Int.toString}ms and try again.`,
@@ -69,7 +67,9 @@ let getKnownRawBlockWithBackoff = async (
       })
       await Time.resolvePromiseAfterDelay(~delayMilliseconds=currentBackoff.contents)
       currentBackoff := currentBackoff.contents * 2
-    | json => result := Some(json)
+    | json =>
+      recordRequest(~method="eth_getBlockByNumber", ~seconds=timerRef->Performance.secondsSince)
+      result := Some(json)
     }
   }
   result.contents->Option.getOrThrow
@@ -97,16 +97,24 @@ let getErrorMessage = (exn: exn): option<string> =>
 // never helps — the same range always re-trips the same cap. The reaction is to
 // shrink the range and retry immediately, ratcheting the max range down.
 let isResponseTooLargeError = {
+  // Provider-specific "too many logs" messages, matched loosely since each names
+  // it differently: HyperRPC ("More than 50000 logs returned"), ZkEVM ("query
+  // returned more than N results"), LlamaRPC ("query exceeds max results"),
+  // 1RPC ("response size should not..."), Optimism ("(backend) response too
+  // large"), Arbitrum ("logs matched by query exceeds limit"), Ankr ("block
+  // range is too wide"). Kept as one block rather than per-line comments — the
+  // ReScript formatter doesn't preserve comments attached to regex literals in
+  // an array.
   let patterns = [
-    /more than \d+ logs/i, // HyperRPC: "More than 50000 logs returned"
+    /more than \d+ logs/i,
     /\d+ logs returned/i,
     /too many logs/i,
-    /query returned more than \d+ results/i, // ZkEVM
-    /query exceeds max results/i, // LlamaRPC
-    /response size should not/i, // 1RPC
-    /(backend )?response too large/i, // Optimism
-    /logs matched by query exceeds limit/i, // Arbitrum
-    /block range is too wide/i, // Ankr
+    /query returned more than \d+ results/i,
+    /query exceeds max results/i,
+    /response size should not/i,
+    /(backend )?response too large/i,
+    /logs matched by query exceeds limit/i,
+    /block range is too wide/i,
   ]
   (exn: exn) =>
     switch exn->getErrorMessage {
@@ -292,8 +300,7 @@ let getNextPage = (
   ~rpcClient: EvmRpcClient.t,
   ~mutSuggestedBlockIntervals,
   ~partitionId,
-  ~sourceName,
-  ~chainId,
+  ~recordRequest: (~method: string, ~seconds: float) => unit,
 ): promise<eventBatchQuery> => {
   //If the query hangs for longer than this, reject this promise to reduce the block interval
   let queryTimoutPromise =
@@ -306,7 +313,7 @@ let getNextPage = (
   let latestFetchedBlockPromise = loadBlock(toBlock)
 
   let queryLogs = ({addresses, topicQuery}: logSelection) => {
-    Prometheus.SourceRequestCount.increment(~sourceName, ~chainId, ~method="eth_getLogs")
+    let timerRef = Performance.now()
     rpcClient.getLogs({
       fromBlock,
       toBlock,
@@ -318,6 +325,9 @@ let getNextPage = (
         | Multiple(topics) => Nullable.make(topics)
         }
       ),
+    })->Promise.thenResolve(items => {
+      recordRequest(~method="eth_getLogs", ~seconds=timerRef->Performance.secondsSince)
+      items
     })
   }
 
@@ -353,8 +363,10 @@ let getNextPage = (
   ->Promise.race
   ->Promise.catch(err => {
     let executedBlockInterval = toBlock - fromBlock + 1
-    let shrunkBlockInterval =
-      Pervasives.max(1, (executedBlockInterval->Int.toFloat *. sc.backoffMultiplicative)->Float.toInt)
+    let shrunkBlockInterval = Pervasives.max(
+      1,
+      (executedBlockInterval->Int.toFloat *. sc.backoffMultiplicative)->Float.toInt,
+    )
 
     let throwFailedGettingItems = retry =>
       throw(Source.GetItemsError(FailedGettingItems({exn: err, attemptedToBlock: toBlock, retry})))
@@ -401,12 +413,12 @@ type selectionConfig = {
 }
 
 let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
-  let evmEventConfigs =
-    selection.eventConfigs->(
-      Utils.magic: array<Internal.eventConfig> => array<Internal.evmEventConfig>
+  let evmOnEventRegistrations =
+    selection.onEventRegistrations->(
+      Utils.magic: array<Internal.onEventRegistration> => array<Internal.evmOnEventRegistration>
     )
 
-  if evmEventConfigs->Utils.Array.isEmpty {
+  if evmOnEventRegistrations->Utils.Array.isEmpty {
     throw(
       Source.GetItemsError(
         UnsupportedSelection({
@@ -429,12 +441,9 @@ let getSelectionConfig = (selection: FetchState.selection, ~chain) => {
   let dynamicWildcardByContract = Dict.make()
   let contractNames = Utils.Set.make()
 
-  evmEventConfigs->Array.forEach(({
-    contractName,
-    isWildcard,
-    dependsOnAddresses,
-    getEventFiltersOrThrow,
-  }) => {
+  evmOnEventRegistrations->Array.forEach(reg => {
+    let contractName = reg.eventConfig.contractName
+    let {isWildcard, dependsOnAddresses, getEventFiltersOrThrow} = reg
     let eventFilters = getEventFiltersOrThrow(chain)
     if dependsOnAddresses {
       contractNames->Utils.Set.add(contractName)->ignore
@@ -664,11 +673,9 @@ let makeThrowingGetEventBlock = (
   }
 }
 
-// `number`, `timestamp` and `hash` are always part of the selected block
-// fields, so they can be read from the assembled block at item construction.
+// `number` is always part of the selected block fields, so it can be read
+// from the assembled block for the item's own `blockNumber`.
 @get external getBlockNumber: Internal.eventBlock => int = "number"
-@get external getBlockTimestamp: Internal.eventBlock => int = "timestamp"
-@get external getBlockHash: Internal.eventBlock => string = "hash"
 
 // Field source classification for RPC calls
 type fieldSource = TransactionOnly | ReceiptOnly | Both
@@ -984,7 +991,7 @@ type options = {
   syncConfig: Config.sourceSync,
   url: string,
   chain: ChainMap.Chain.t,
-  eventRouter: EventRouter.t<Internal.evmEventConfig>,
+  eventRouter: EventRouter.t<Internal.evmOnEventRegistration>,
   allEventParams: array<HyperSyncClient.Decoder.eventParamsInput>,
   lowercaseAddresses: bool,
   ws?: string,
@@ -1030,15 +1037,37 @@ let make = (
     ~headers?,
   )
 
+  // Requests are made from shared, memoized loaders, so they can't be
+  // attributed to a single getItemsOrThrow/getHeightOrThrow/getBlockHashes
+  // call at its call site. Every actual request (cache/dedup hits never reach
+  // recordRequest) pushes here; each method drains whatever is pending when it
+  // returns. Since a push always lands in exactly one drain, per-source totals
+  // stay exact even with concurrent in-flight calls — which call happens to
+  // drain a given entry doesn't matter, since SourceManager aggregates by
+  // (source, method) regardless of which call returned it.
+  let pendingRequestStats: array<Source.requestStat> = []
+  let recordRequest = (~method, ~seconds) => {
+    pendingRequestStats->Array.push({Source.method, seconds})->ignore
+  }
+  let drainRequestStats = () => {
+    let stats = pendingRequestStats->Utils.Array.copy
+    pendingRequestStats->Utils.Array.clearInPlace
+    stats
+  }
+
   let makeTransactionLoader = () =>
     LazyLoader.make(
       ~loaderFn=transactionHash => {
-        Prometheus.SourceRequestCount.increment(
-          ~sourceName=name,
-          ~chainId=chain->ChainMap.Chain.toChainId,
-          ~method="eth_getTransactionByHash",
-        )
-        Rpc.GetTransactionByHash.rawRoute->Rest.fetch(transactionHash, ~client)
+        let timerRef = Performance.now()
+        Rpc.GetTransactionByHash.rawRoute
+        ->Rest.fetch(transactionHash, ~client)
+        ->Promise.thenResolve(res => {
+          recordRequest(
+            ~method="eth_getTransactionByHash",
+            ~seconds=timerRef->Performance.secondsSince,
+          )
+          res
+        })
       },
       ~onError=(am, ~exn) => {
         Logging.error({
@@ -1066,6 +1095,7 @@ let make = (
           ~chain,
           ~backoffMsOnFailure=1000,
           ~blockNumber,
+          ~recordRequest,
         )
       },
       ~onError=(am, ~exn) => {
@@ -1088,12 +1118,16 @@ let make = (
   let makeReceiptLoader = () =>
     LazyLoader.make(
       ~loaderFn=transactionHash => {
-        Prometheus.SourceRequestCount.increment(
-          ~sourceName=name,
-          ~chainId=chain->ChainMap.Chain.toChainId,
-          ~method="eth_getTransactionReceipt",
-        )
-        Rpc.GetTransactionReceipt.rawRoute->Rest.fetch(transactionHash, ~client)
+        let timerRef = Performance.now()
+        Rpc.GetTransactionReceipt.rawRoute
+        ->Rest.fetch(transactionHash, ~client)
+        ->Promise.thenResolve(res => {
+          recordRequest(
+            ~method="eth_getTransactionReceipt",
+            ~seconds=timerRef->Performance.secondsSince,
+          )
+          res
+        })
       },
       ~onError=(am, ~exn) => {
         Logging.error({
@@ -1152,13 +1186,16 @@ let make = (
     ~knownHeight,
     ~partitionId,
     ~selection: FetchState.selection,
+    ~itemsTarget as _,
     ~retry,
     ~logger as _,
   ) => {
     let startFetchingBatchTimeRef = Performance.now()
 
     let sourceMaxBlockInterval =
-      mutSuggestedBlockIntervals->getSourceMaxBlockInterval(~intervalCeiling=syncConfig.intervalCeiling)
+      mutSuggestedBlockIntervals->getSourceMaxBlockInterval(
+        ~intervalCeiling=syncConfig.intervalCeiling,
+      )
     let suggestedBlockInterval = Pervasives.min(
       mutSuggestedBlockIntervals
       ->Utils.Dict.dangerouslyGetNonOption(partitionId)
@@ -1198,8 +1235,7 @@ let make = (
       ~rpcClient,
       ~mutSuggestedBlockIntervals,
       ~partitionId,
-      ~sourceName=name,
-      ~chainId=chain->ChainMap.Chain.toChainId,
+      ~recordRequest,
     )
 
     let executedBlockInterval = suggestedToBlock - fromBlock + 1
@@ -1233,7 +1269,11 @@ let make = (
         ~contractAddress=routedAddress,
       ) {
       | None => None
-      | Some(eventConfig) =>
+      | Some(onEventRegistration) =>
+        let eventConfig =
+          onEventRegistration.eventConfig->(
+            Utils.magic: Internal.eventConfig => Internal.evmEventConfig
+          )
         switch maybeDecodedEvent
         ->Nullable.toOption
         ->Option.flatMap(Dict.get(_, eventConfig.contractName)) {
@@ -1280,10 +1320,8 @@ let make = (
                 }
 
                 Internal.Event({
-                  eventConfig: (eventConfig :> Internal.eventConfig),
-                  timestamp: block->getBlockTimestamp,
+                  onEventRegistration: (onEventRegistration :> Internal.onEventRegistration),
                   blockNumber: block->getBlockNumber,
-                  blockHash: block->getBlockHash,
                   chain,
                   logIndex: log.logIndex,
                   transactionIndex: log.transactionIndex,
@@ -1337,14 +1375,16 @@ let make = (
       latestFetchedBlockTimestamp: latestFetchedBlockInfo.timestamp,
       latestFetchedBlockNumber: latestFetchedBlockInfo.number,
       parsedQueueItems,
-      // RPC keeps the transaction inline on the payload; no store page.
+      // RPC keeps the transaction and block inline on the payload; no store pages.
       transactionStore: None,
+      blockStore: None,
       stats: {
         totalTimeElapsed: totalTimeElapsed,
       },
       knownHeight,
       blockHashes,
       fromBlockQueried: fromBlock,
+      requestStats: drainRequestStats(),
     }
   }
 
@@ -1361,21 +1401,25 @@ let make = (
     ->Array.map(blockNum => blockLoader.contents->LazyLoader.get(blockNum))
     ->Promise.all
     ->Promise.thenResolve(rawBlocks => {
-      rawBlocks
-      ->Array.map(json => {
-        let b = parseBlockInfo(json)
-
-        (
-          {
-            blockNumber: b.number,
-            blockHash: b.hash,
-            blockTimestamp: b.timestamp,
-          }: ReorgDetection.blockDataWithTimestamp
-        )
-      })
-      ->Ok
+      let result =
+        rawBlocks
+        ->Array.map(json => {
+          let b = parseBlockInfo(json)
+
+          (
+            {
+              blockNumber: b.number,
+              blockHash: b.hash,
+              blockTimestamp: b.timestamp,
+            }: ReorgDetection.blockDataWithTimestamp
+          )
+        })
+        ->Ok
+      {Source.result, requestStats: drainRequestStats()}
     })
-    ->Promise.catch(exn => exn->Error->Promise.resolve)
+    ->Promise.catch(exn =>
+      {Source.result: Error(exn), requestStats: drainRequestStats()}->Promise.resolve
+    )
   }
 
   let createHeightSubscription =
@@ -1397,33 +1441,11 @@ let make = (
         await rpcClient.getHeight()
       } catch {
       | exn =>
-        let seconds = timerRef->Performance.secondsSince
-        Prometheus.SourceRequestCount.increment(
-          ~sourceName=name,
-          ~chainId=chain->ChainMap.Chain.toChainId,
-          ~method="eth_blockNumber",
-        )
-        Prometheus.SourceRequestCount.addSeconds(
-          ~sourceName=name,
-          ~chainId=chain->ChainMap.Chain.toChainId,
-          ~method="eth_blockNumber",
-          ~seconds,
-        )
+        recordRequest(~method="eth_blockNumber", ~seconds=timerRef->Performance.secondsSince)
         exn->throw
       }
-      let seconds = timerRef->Performance.secondsSince
-      Prometheus.SourceRequestCount.increment(
-        ~sourceName=name,
-        ~chainId=chain->ChainMap.Chain.toChainId,
-        ~method="eth_blockNumber",
-      )
-      Prometheus.SourceRequestCount.addSeconds(
-        ~sourceName=name,
-        ~chainId=chain->ChainMap.Chain.toChainId,
-        ~method="eth_blockNumber",
-        ~seconds,
-      )
-      height
+      recordRequest(~method="eth_blockNumber", ~seconds=timerRef->Performance.secondsSince)
+      {height, requestStats: drainRequestStats()}
     },
     getItemsOrThrow,
     ?createHeightSubscription,

package/src/sources/RpcSource.res.mjs

@@ -9,7 +9,6 @@ import * as Address from "../Address.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as Internal from "../Internal.res.mjs";
 import * as LazyLoader from "../LazyLoader.res.mjs";
-import * as Prometheus from "../Prometheus.res.mjs";
 import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as EventRouter from "./EventRouter.res.mjs";
 import * as Performance from "../bindings/Performance.res.mjs";
@@ -47,11 +46,11 @@ function parseBlockInfo(json) {
   };
 }
 
-async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumber, backoffMsOnFailure) {
+async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumber, backoffMsOnFailure, recordRequest) {
   let currentBackoff = backoffMsOnFailure;
   let result;
   while (Stdlib_Option.isNone(result)) {
-    Prometheus.SourceRequestCount.increment(sourceName, chain, "eth_getBlockByNumber");
+    let timerRef = Performance.now();
     let exit = 0;
     let json;
     try {
@@ -59,6 +58,7 @@ async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumbe
       exit = 1;
     } catch (raw_err) {
       let err = Primitive_exceptions.internalToException(raw_err);
+      recordRequest("eth_getBlockByNumber", Performance.secondsSince(timerRef));
       Logging.warn({
         err: Utils.prettifyExn(err),
         msg: `Issue while running fetching batch of events from the RPC. Will wait ` + currentBackoff.toString() + `ms and try again.`,
@@ -70,6 +70,7 @@ async function getKnownRawBlockWithBackoff(client, sourceName, chain, blockNumbe
       currentBackoff = (currentBackoff << 1);
     }
     if (exit === 1) {
+      recordRequest("eth_getBlockByNumber", Performance.secondsSince(timerRef));
       result = json;
     }
   };
@@ -265,14 +266,14 @@ function mergeAndDedupItems(itemsPerSelection) {
   return merged;
 }
 
-function getNextPage(fromBlock, toBlock, logSelections, loadBlock, sc, rpcClient, mutSuggestedBlockIntervals, partitionId, sourceName, chainId) {
+function getNextPage(fromBlock, toBlock, logSelections, loadBlock, sc, rpcClient, mutSuggestedBlockIntervals, partitionId, recordRequest) {
   let queryTimoutPromise = Time.resolvePromiseAfterDelay(sc.queryTimeoutMillis).then(() => Promise.reject({
     RE_EXN_ID: QueryTimout,
     _1: `Query took longer than ` + (sc.queryTimeoutMillis / 1000 | 0).toString() + ` seconds`
   }));
   let latestFetchedBlockPromise = loadBlock(toBlock);
   let queryLogs = param => {
-    Prometheus.SourceRequestCount.increment(sourceName, chainId, "eth_getLogs");
+    let timerRef = Performance.now();
     return rpcClient.getLogs({
       fromBlock: fromBlock,
       toBlock: toBlock,
@@ -286,6 +287,9 @@ function getNextPage(fromBlock, toBlock, logSelections, loadBlock, sc, rpcClient
           return filter;
         }
       })
+    }).then(items => {
+      recordRequest("eth_getLogs", Performance.secondsSince(timerRef));
+      return items;
     });
   };
   let len = logSelections.length;
@@ -353,8 +357,8 @@ function getNextPage(fromBlock, toBlock, logSelections, loadBlock, sc, rpcClient
 }
 
 function getSelectionConfig(selection, chain) {
-  let evmEventConfigs = selection.eventConfigs;
-  if (Utils.$$Array.isEmpty(evmEventConfigs)) {
+  let evmOnEventRegistrations = selection.onEventRegistrations;
+  if (Utils.$$Array.isEmpty(evmOnEventRegistrations)) {
     throw {
       RE_EXN_ID: Source.GetItemsError,
       _1: {
@@ -369,15 +373,15 @@ function getSelectionConfig(selection, chain) {
   let dynamicByContract = {};
   let dynamicWildcardByContract = {};
   let contractNames = new Set();
-  evmEventConfigs.forEach(param => {
-    let contractName = param.contractName;
-    let eventFilters = param.getEventFiltersOrThrow(chain);
-    if (param.dependsOnAddresses) {
+  evmOnEventRegistrations.forEach(reg => {
+    let contractName = reg.eventConfig.contractName;
+    let eventFilters = reg.getEventFiltersOrThrow(chain);
+    if (reg.dependsOnAddresses) {
       contractNames.add(contractName);
       if (eventFilters.TAG === "Static") {
         return Utils.Dict.pushMany(staticByContract, contractName, eventFilters._0);
       } else {
-        return Utils.Dict.push(param.isWildcard ? dynamicWildcardByContract : dynamicByContract, contractName, eventFilters._0);
+        return Utils.Dict.push(reg.isWildcard ? dynamicWildcardByContract : dynamicByContract, contractName, eventFilters._0);
       }
     }
     let tmp;
@@ -973,9 +977,24 @@ function make(param) {
   let mutSuggestedBlockIntervals = {};
   let client = Rpc.makeClient(url, headers);
   let rpcClient = EvmRpcClient.make(url, !lowercaseAddresses, undefined, headers, param.allEventParams);
+  let pendingRequestStats = [];
+  let recordRequest = (method, seconds) => {
+    pendingRequestStats.push({
+      method: method,
+      seconds: seconds
+    });
+  };
+  let drainRequestStats = () => {
+    let stats = pendingRequestStats.slice();
+    Utils.$$Array.clearInPlace(pendingRequestStats);
+    return stats;
+  };
   let makeTransactionLoader = () => LazyLoader.make(transactionHash => {
-    Prometheus.SourceRequestCount.increment(name, chain, "eth_getTransactionByHash");
-    return Rest.fetch(Rpc.GetTransactionByHash.rawRoute, transactionHash, client);
+    let timerRef = Performance.now();
+    return Rest.fetch(Rpc.GetTransactionByHash.rawRoute, transactionHash, client).then(res => {
+      recordRequest("eth_getTransactionByHash", Performance.secondsSince(timerRef));
+      return res;
+    });
   }, (am, exn) => Logging.error({
     err: Utils.prettifyExn(exn),
     msg: `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ` + (am._retryDelayMillis / 1000 | 0).toString() + ` seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the "suggestedFix" in the metadata of this command`,
@@ -986,7 +1005,7 @@ function make(param) {
       suggestedFix: "This likely means the RPC url you are using is not responding correctly. Please try another RPC endipoint."
     }
   }), undefined, undefined, undefined, undefined);
-  let makeBlockLoader = () => LazyLoader.make(blockNumber => getKnownRawBlockWithBackoff(client, name, chain, blockNumber, 1000), (am, exn) => Logging.error({
+  let makeBlockLoader = () => LazyLoader.make(blockNumber => getKnownRawBlockWithBackoff(client, name, chain, blockNumber, 1000, recordRequest), (am, exn) => Logging.error({
     err: Utils.prettifyExn(exn),
     msg: `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ` + (am._retryDelayMillis / 1000 | 0).toString() + ` seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the "suggestedFix" in the metadata of this command`,
     source: name,
@@ -997,8 +1016,11 @@ function make(param) {
     }
   }), undefined, undefined, undefined, undefined);
   let makeReceiptLoader = () => LazyLoader.make(transactionHash => {
-    Prometheus.SourceRequestCount.increment(name, chain, "eth_getTransactionReceipt");
-    return Rest.fetch(Rpc.GetTransactionReceipt.rawRoute, transactionHash, client);
+    let timerRef = Performance.now();
+    return Rest.fetch(Rpc.GetTransactionReceipt.rawRoute, transactionHash, client).then(res => {
+      recordRequest("eth_getTransactionReceipt", Performance.secondsSince(timerRef));
+      return res;
+    });
   }, (am, exn) => Logging.error({
     err: Utils.prettifyExn(exn),
     msg: `Top level promise timeout reached. Please review other errors or warnings in the code. This function will retry in ` + (am._retryDelayMillis / 1000 | 0).toString() + ` seconds. It is highly likely that your indexer isn't syncing on one or more chains currently. Also take a look at the "suggestedFix" in the metadata of this command`,
@@ -1040,7 +1062,7 @@ function make(param) {
       Error: new Error()
     };
   }, lowercaseAddresses);
-  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, contractNameByAddress, knownHeight, partitionId, selection, retry, param) => {
+  let getItemsOrThrow = async (fromBlock, toBlock, addressesByContractName, contractNameByAddress, knownHeight, partitionId, selection, param, retry, param$1) => {
     let startFetchingBatchTimeRef = Performance.now();
     let sourceMaxBlockInterval = getSourceMaxBlockInterval(mutSuggestedBlockIntervals, syncConfig.intervalCeiling);
     let suggestedBlockInterval = Primitive_int.min(Stdlib_Option.getOr(mutSuggestedBlockIntervals[partitionId], syncConfig.initialBlockInterval), sourceMaxBlockInterval);
@@ -1049,7 +1071,7 @@ function make(param) {
     let firstBlockParentPromise = fromBlock > 0 ? LazyLoader.get(blockLoader.contents, fromBlock - 1 | 0).then(json => parseBlockInfo(json)) : Promise.resolve(undefined);
     let match = getSelectionConfig(selection);
     let logSelections = match.getLogSelectionsOrThrow(addressesByContractName);
-    let match$1 = await getNextPage(fromBlock, suggestedToBlock, logSelections, blockNumber => LazyLoader.get(blockLoader.contents, blockNumber).then(parseBlockInfo), syncConfig, rpcClient, mutSuggestedBlockIntervals, partitionId, name, chain);
+    let match$1 = await getNextPage(fromBlock, suggestedToBlock, logSelections, blockNumber => LazyLoader.get(blockLoader.contents, blockNumber).then(parseBlockInfo), syncConfig, rpcClient, mutSuggestedBlockIntervals, partitionId, recordRequest);
     let latestFetchedBlockInfo = match$1.latestFetchedBlockInfo;
     let items = match$1.items;
     let executedBlockInterval = (suggestedToBlock - fromBlock | 0) + 1 | 0;
@@ -1060,10 +1082,11 @@ function make(param) {
       let log = param.log;
       let topic0 = Stdlib_Option.getOr(log.topics[0], "0x0");
       let routedAddress = lowercaseAddresses ? Address.Evm.fromAddressLowercaseOrThrow(log.address) : Address.Evm.fromAddressOrThrow(log.address);
-      let eventConfig = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, contractNameByAddress);
-      if (eventConfig === undefined) {
+      let onEventRegistration = EventRouter.get(eventRouter, EventRouter.getEvmEventId(topic0, log.topics.length), routedAddress, contractNameByAddress);
+      if (onEventRegistration === undefined) {
         return;
       }
+      let eventConfig = onEventRegistration.eventConfig;
       let decoded = Stdlib_Option.flatMap(Primitive_option.fromNullable(param.params), __x => __x[eventConfig.contractName]);
       if (decoded === undefined) {
         return;
@@ -1110,11 +1133,9 @@ function make(param) {
         let block = match[0];
         return {
           kind: 0,
-          eventConfig: eventConfig,
-          timestamp: block.timestamp,
+          onEventRegistration: onEventRegistration,
           chain: chain,
           blockNumber: block.number,
-          blockHash: block.hash,
           logIndex: log.logIndex,
           transactionIndex: log.transactionIndex,
           payload: {
@@ -1125,7 +1146,7 @@ function make(param) {
             srcAddress: routedAddress,
             logIndex: log.logIndex,
             transaction: Primitive_option.some(match[1]),
-            block: block
+            block: Primitive_option.some(block)
           }
         };
       })();
@@ -1162,12 +1183,14 @@ function make(param) {
       blockHashes: blockHashes,
       parsedQueueItems: parsedQueueItems,
       transactionStore: undefined,
+      blockStore: undefined,
       fromBlockQueried: fromBlock,
       latestFetchedBlockNumber: latestFetchedBlockInfo.number,
       latestFetchedBlockTimestamp: latestFetchedBlockInfo.timestamp,
       stats: {
         "total time elapsed (s)": totalTimeElapsed
-      }
+      },
+      requestStats: drainRequestStats()
     };
   };
   let onReorg = param => {
@@ -1175,19 +1198,28 @@ function make(param) {
     transactionLoader.contents = makeTransactionLoader();
     receiptLoader.contents = makeReceiptLoader();
   };
-  let getBlockHashes = (blockNumbers, _currentlyUnusedLogger) => Stdlib_Promise.$$catch(Promise.all(blockNumbers.map(blockNum => LazyLoader.get(blockLoader.contents, blockNum))).then(rawBlocks => ({
-    TAG: "Ok",
-    _0: rawBlocks.map(json => {
-      let b = parseBlockInfo(json);
-      return {
-        blockHash: b.hash,
-        blockNumber: b.number,
-        blockTimestamp: b.timestamp
-      };
-    })
-  })), exn => Promise.resolve({
-    TAG: "Error",
-    _0: exn
+  let getBlockHashes = (blockNumbers, _currentlyUnusedLogger) => Stdlib_Promise.$$catch(Promise.all(blockNumbers.map(blockNum => LazyLoader.get(blockLoader.contents, blockNum))).then(rawBlocks => {
+    let result = {
+      TAG: "Ok",
+      _0: rawBlocks.map(json => {
+        let b = parseBlockInfo(json);
+        return {
+          blockHash: b.hash,
+          blockNumber: b.number,
+          blockTimestamp: b.timestamp
+        };
+      })
+    };
+    return {
+      result: result,
+      requestStats: drainRequestStats()
+    };
+  }), exn => Promise.resolve({
+    result: {
+      TAG: "Error",
+      _0: exn
+    },
+    requestStats: drainRequestStats()
   }));
   let createHeightSubscription = Stdlib_Option.map(param.ws, wsUrl => (onHeight => RpcWebSocketHeightStream.subscribe(wsUrl, chain, onHeight)));
   return {
@@ -1203,15 +1235,14 @@ function make(param) {
       try {
         height = await rpcClient.getHeight();
       } catch (exn) {
-        let seconds = Performance.secondsSince(timerRef);
-        Prometheus.SourceRequestCount.increment(name, chain, "eth_blockNumber");
-        Prometheus.SourceRequestCount.addSeconds(name, chain, "eth_blockNumber", seconds);
+        recordRequest("eth_blockNumber", Performance.secondsSince(timerRef));
         throw exn;
       }
-      let seconds$1 = Performance.secondsSince(timerRef);
-      Prometheus.SourceRequestCount.increment(name, chain, "eth_blockNumber");
-      Prometheus.SourceRequestCount.addSeconds(name, chain, "eth_blockNumber", seconds$1);
-      return height;
+      recordRequest("eth_blockNumber", Performance.secondsSince(timerRef));
+      return {
+        height: height,
+        requestStats: drainRequestStats()
+      };
     },
     getItemsOrThrow: getItemsOrThrow,
     createHeightSubscription: createHeightSubscription,

package/src/sources/RpcWebSocketHeightStream.res

@@ -108,11 +108,6 @@ let subscribe = (~wsUrl, ~chainId, ~onHeight: int => unit): (unit => unit) => {
           | NewHead(blockNumber) =>
             errorCount := 0
             resetStaleTimeout()
-            Prometheus.SourceRequestCount.increment(
-              ~sourceName="WebSocket",
-              ~chainId,
-              ~method="eth_subscribe",
-            )
             onHeight(blockNumber)
           | SubscriptionConfirmed(_) => resetStaleTimeout()
           | ErrorResponse =>