envio 3.3.0-alpha.0 → 3.3.0-alpha.10

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 =>

package/src/sources/RpcWebSocketHeightStream.res.mjs

@@ -3,7 +3,6 @@
 import * as Rpc from "./Rpc.res.mjs";
 import * as Utils from "../Utils.res.mjs";
 import * as Logging from "../Logging.res.mjs";
-import * as Prometheus from "../Prometheus.res.mjs";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
@@ -105,7 +104,6 @@ function subscribe(wsUrl, chainId, onHeight) {
         }
         errorCount.contents = 0;
         resetStaleTimeout();
-        Prometheus.SourceRequestCount.increment("WebSocket", chainId, "eth_subscribe");
         return onHeight(blockNumber._0);
       } catch (raw_e) {
         let e = Primitive_exceptions.internalToException(raw_e);

package/src/sources/SimulateSource.res

@@ -6,29 +6,31 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
 
   {
     name: "SimulateSource",
+    simulateItems: items,
     sourceFor: Sync,
     chain,
     poweredByHyperSync: false,
     pollingInterval: 0,
     getBlockHashes: (~blockNumbers as _, ~logger as _) => {
-      Promise.resolve(Ok([]))
+      Promise.resolve({Source.result: Ok([]), requestStats: []})
     },
     getHeightOrThrow: () => {
       // Report at least height 1 so the engine doesn't treat 0 as "no blocks available"
-      Promise.resolve(max(endBlock, 1))
+      Promise.resolve({Source.height: max(endBlock, 1), requestStats: []})
     },
     getItemsOrThrow: (
       ~fromBlock as _,
       ~toBlock as _,
       ~addressesByContractName as _,
-      ~indexingAddresses as _,
+      ~contractNameByAddress as _,
       ~knownHeight as _,
       ~partitionId as _,
       ~selection as _,
+      ~itemsTarget as _,
       ~retry as _,
       ~logger as _,
     ) => {
-      // Return all items on first call, empty on subsequent calls
+      // Return all items on the first call, empty on subsequent.
       let result = if delivered.contents {
         []
       } else {
@@ -41,12 +43,16 @@ let make = (~items: array<Internal.item>, ~endBlock: int, ~chain: ChainMap.Chain
         Source.knownHeight: reportedHeight,
         blockHashes: [],
         parsedQueueItems: result,
+        // Simulate keeps the transaction and block inline on the payload; no store pages.
+        transactionStore: None,
+        blockStore: None,
         fromBlockQueried: 0,
         latestFetchedBlockNumber: reportedHeight,
         latestFetchedBlockTimestamp: 0,
         stats: {
           totalTimeElapsed: 0.,
         },
+        requestStats: [],
       })
     },
   }

package/src/sources/SimulateSource.res.mjs

@@ -13,25 +13,35 @@ function make(items, endBlock, chain) {
     poweredByHyperSync: false,
     pollingInterval: 0,
     getBlockHashes: (param, param$1) => Promise.resolve({
-      TAG: "Ok",
-      _0: []
+      result: {
+        TAG: "Ok",
+        _0: []
+      },
+      requestStats: []
     }),
-    getHeightOrThrow: () => Promise.resolve(Primitive_int.max(endBlock, 1)),
-    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8) => {
+    getHeightOrThrow: () => Promise.resolve({
+      height: Primitive_int.max(endBlock, 1),
+      requestStats: []
+    }),
+    getItemsOrThrow: (param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) => {
       let result = delivered.contents ? [] : (delivered.contents = true, items);
       let reportedHeight = Primitive_int.max(endBlock, 1);
       return Promise.resolve({
         knownHeight: reportedHeight,
         blockHashes: [],
         parsedQueueItems: result,
+        transactionStore: undefined,
+        blockStore: undefined,
         fromBlockQueried: 0,
         latestFetchedBlockNumber: reportedHeight,
         latestFetchedBlockTimestamp: 0,
         stats: {
           "total time elapsed (s)": 0
-        }
+        },
+        requestStats: []
       });
-    }
+    },
+    simulateItems: items
   };
 }
 

package/src/sources/Source.res

@@ -7,6 +7,11 @@ type blockRangeFetchStats = {
   @as("page fetch time (s)") pageFetchTime?: float,
 }
 
+// A single backend request a source method actually made (cache/dedup hits
+// aren't requests), with the time it took. SourceManager aggregates these
+// per (source, method) into the envio_source_request_* metrics.
+type requestStat = {method: string, seconds: float}
+
 /**
 Thes response returned from a block range fetch
 */
@@ -18,10 +23,26 @@ type blockRangeFetchResponse = {
   // a within-array hash mismatch on the same block number as a reorg.
   blockHashes: array<ReorgDetection.blockData>,
   parsedQueueItems: array<Internal.item>,
+  // Page of transactions for this response's items, keyed by (blockNumber,
+  // transactionIndex); merged into the chain's store on apply. `None` for
+  // sources that keep the transaction inline on the payload (RPC/Fuel/Simulate).
+  transactionStore: option<TransactionStore.t>,
+  // Page of blocks for this response's items, keyed by block number; merged into
+  // the chain's store on apply. `None` for sources that keep the block fully
+  // inline on the payload (RPC/Fuel/Simulate).
+  blockStore: option<BlockStore.t>,
   fromBlockQueried: int,
   latestFetchedBlockNumber: int,
   latestFetchedBlockTimestamp: int,
   stats: blockRangeFetchStats,
+  requestStats: array<requestStat>,
+}
+
+type getHeightResponse = {height: int, requestStats: array<requestStat>}
+
+type getBlockHashesResponse = {
+  result: result<array<ReorgDetection.blockDataWithTimestamp>, exn>,
+  requestStats: array<requestStat>,
 }
 
 type getItemsRetry =
@@ -47,19 +68,22 @@ type t = {
   poweredByHyperSync: bool,
   /* Frequency (in ms) used when polling for new events on this network. */
   pollingInterval: int,
-  getBlockHashes: (
-    ~blockNumbers: array<int>,
-    ~logger: Pino.t,
-  ) => promise<result<array<ReorgDetection.blockDataWithTimestamp>, exn>>,
-  getHeightOrThrow: unit => promise<int>,
+  getBlockHashes: (~blockNumbers: array<int>, ~logger: Pino.t) => promise<getBlockHashesResponse>,
+  getHeightOrThrow: unit => promise<getHeightResponse>,
   getItemsOrThrow: (
     ~fromBlock: int,
     ~toBlock: option<int>,
     ~addressesByContractName: dict<array<Address.t>>,
-    ~indexingAddresses: dict<FetchState.indexingAddress>,
+    ~contractNameByAddress: dict<string>,
     ~knownHeight: int,
     ~partitionId: string,
     ~selection: FetchState.selection,
+    // Soft cap on the number of primary items (logs/instructions/receipts) the
+    // source should ask its backend for, from the query's own estResponseSize.
+    // A HyperSync-backed source enforces it server-side, so a wrong estimate
+    // truncates the response instead of overshooting the shared buffer. Sources
+    // without an equivalent lever (RPC, Fuel, Simulate) ignore it.
+    ~itemsTarget: int,
     ~retry: int,
     ~logger: Pino.t,
   ) => promise<blockRangeFetchResponse>,
@@ -67,4 +91,8 @@ type t = {
   // Invoked by SourceManager once a rollback target is known so the source can
   // drop any state that may now point at an orphaned chain (e.g. RPC block cache).
   onReorg?: (~rollbackTargetBlock: int) => unit,
+  // Present only on the simulate source: the items a test fed in. The chain
+  // tracks which of these never reach a handler so the run can report dead
+  // simulate inputs on completion.
+  simulateItems?: array<Internal.item>,
 }

package/src/sources/SourceManager.res

@@ -1,5 +1,10 @@
 type sourceManagerStatus = Idle | WaitingForNewBlock | Querieng
 
+// Cumulative per-method request count/time for a source, aggregated from the
+// requestStat arrays returned by its methods. Rendered into
+// envio_source_request_* by Metrics.renderSourceRequests.
+type requestStatAgg = {mutable count: int, mutable seconds: float}
+
 type sourceState = {
   source: Source.t,
   mutable knownHeight: int,
@@ -9,13 +14,35 @@ type sourceState = {
   // Timestamp (ms) when this source last failed during executeQuery.
   // Used to decide when to attempt recovery to this source.
   mutable lastFailedAt: option<float>,
+  requestStats: dict<requestStatAgg>,
+}
+
+let recordRequestStats = (sourceState: sourceState, requestStats: array<Source.requestStat>) => {
+  requestStats->Array.forEach(({method, seconds}) => {
+    switch sourceState.requestStats->Utils.Dict.dangerouslyGetNonOption(method) {
+    | Some(agg) =>
+      agg.count = agg.count + 1
+      agg.seconds = agg.seconds +. seconds
+    | None => sourceState.requestStats->Dict.set(method, {count: 1, seconds})
+    }
+  })
+}
+
+// Flattened (source, method) aggregates for Metrics.renderSourceRequests to
+// inline into the /metrics response.
+type requestStatSample = {
+  sourceName: string,
+  chainId: int,
+  method: string,
+  count: int,
+  seconds: float,
 }
 
 // Encapsulates the fetching logic for a chain's sources.
 // with a mutable state for easier reasoning and testing.
 type t = {
   sourcesState: array<sourceState>,
-  mutable statusStart: Hrtime.timeRef,
+  mutable statusStart: Performance.timeRef,
   mutable status: sourceManagerStatus,
   newBlockStallTimeout: int,
   newBlockStallTimeoutRealtime: int,
@@ -24,6 +51,10 @@ type t = {
   getHeightRetryInterval: (~retry: int) => int,
   mutable activeSource: Source.t,
   mutable waitingForNewBlockStateId: option<int>,
+  // Dedupes the "waiting for new blocks" trace so it fires once per contiguous
+  // wait period instead of on every epoch that re-enters the wait before any
+  // new block is found. Reset when blocks are found.
+  mutable waitingLogged: bool,
   // Should take into consideration partitions fetching for previous states (before rollback)
   mutable fetchingPartitionsCount: int,
   recoveryTimeout: float,
@@ -42,6 +73,25 @@ type t = {
 
 let getActiveSource = sourceManager => sourceManager.activeSource
 
+let getRequestStatSamples = (sourceManager: t): array<requestStatSample> => {
+  let samples = []
+  sourceManager.sourcesState->Array.forEach(sourceState => {
+    let chainId = sourceState.source.chain->ChainMap.Chain.toChainId
+    sourceState.requestStats->Utils.Dict.forEachWithKey((agg, method) => {
+      samples
+      ->Array.push({
+        sourceName: sourceState.source.name,
+        chainId,
+        method,
+        count: agg.count,
+        seconds: agg.seconds,
+      })
+      ->ignore
+    })
+  })
+  samples
+}
+
 // Partition queries currently in flight on this chain's sources. Summed across
 // chains by CrossChainState to enforce the indexer-wide concurrency budget.
 let inFlightCount = sourceManager => sourceManager.fetchingPartitionsCount
@@ -183,9 +233,11 @@ let make = (
       pendingHeightResolvers: [],
       disabled: false,
       lastFailedAt: None,
+      requestStats: Dict.make(),
     }),
     activeSource: initialActiveSource,
     waitingForNewBlockStateId: None,
+    waitingLogged: false,
     fetchingPartitionsCount: 0,
     newBlockStallTimeout,
     newBlockStallTimeoutRealtime,
@@ -193,7 +245,7 @@ let make = (
     reducedPollingInterval,
     getHeightRetryInterval,
     recoveryTimeout,
-    statusStart: Hrtime.makeTimer(),
+    statusStart: Performance.now(),
     status: Idle,
     hasRealtime,
     committedRateLimitTimeMs: 0.0,
@@ -211,26 +263,26 @@ let trackNewStatus = (sourceManager: t, ~newStatus) => {
   }
   promCounter->Prometheus.SafeCounter.handleFloat(
     ~labels=sourceManager.activeSource.chain->ChainMap.Chain.toChainId,
-    ~value=sourceManager.statusStart->Hrtime.timeSince->Hrtime.toSecondsFloat,
+    ~value=sourceManager.statusStart->Performance.secondsSince,
   )
-  sourceManager.statusStart = Hrtime.makeTimer()
+  sourceManager.statusStart = Performance.now()
   sourceManager.status = newStatus
 }
 
-let fetchNext = async (
+// Carry out the fetch decision made by CrossChainState.checkAndFetch: either
+// dispatch the admitted queries or start waiting for a new block. Selection
+// (getNextQuery + cross-chain admission) happens upstream so the budget is split
+// per query across all chains.
+let dispatch = async (
   sourceManager: t,
   ~fetchState: FetchState.t,
   ~executeQuery,
   ~waitForNewBlock,
   ~onNewBlock,
-  ~concurrencyLimit,
-  ~bufferLimit,
+  ~action: FetchState.nextQuery,
   ~stateId,
 ) => {
-  let nextQuery = fetchState->FetchState.getNextQuery(~concurrencyLimit, ~bufferLimit)
-
-  switch nextQuery {
-  | ReachedMaxConcurrency
+  switch action {
   | NothingToQuery => ()
   | WaitingForNewBlock =>
     switch sourceManager.waitingForNewBlockStateId {
@@ -251,7 +303,8 @@ let fetchNext = async (
       }
     }
   | Ready(queries) => {
-      fetchState->FetchState.startFetchingQueries(~queries)
+      // Queries are already marked in flight by ChainState.startFetchingQueries
+      // when they were admitted; here we just execute them.
       sourceManager.fetchingPartitionsCount =
         sourceManager.fetchingPartitionsCount + queries->Array.length
       Prometheus.IndexingConcurrency.set(
@@ -338,7 +391,9 @@ let getSourceNewHeight = async (
         let h = ref(initialHeight)
         while h.contents <= knownHeight && !(newHeight.contents > initialHeight) {
           try {
-            h := (await source.getHeightOrThrow())
+            let res = await source.getHeightOrThrow()
+            sourceState->recordRequestStats(res.requestStats)
+            h := res.height
           } catch {
           | _ => ()
           }
@@ -357,7 +412,9 @@ let getSourceNewHeight = async (
     | None =>
       // No subscription, use REST polling
       try {
-        let height = await source.getHeightOrThrow()
+        let res = await source.getHeightOrThrow()
+        sourceState->recordRequestStats(res.requestStats)
+        let height = res.height
 
         newHeight := height
         if height <= knownHeight {
@@ -379,6 +436,9 @@ let getSourceNewHeight = async (
               }
             })
             sourceState.unsubscribe = Some(unsubscribe)
+            // Count a subscription (re)start rather than every pushed height —
+            // there's no request/response to time here.
+            sourceState->recordRequestStats([{Source.method: "heightSubscription", seconds: 0.}])
           | _ =>
             // Slowdown polling when the chain isn't progressing
             let pollingInterval = if reducedPolling {
@@ -495,13 +555,14 @@ let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isRealtime, ~reduc
       "knownHeight": knownHeight,
     },
   )
-  if reducedPolling {
+  if !sourceManager.waitingLogged {
     logger->Logging.childTrace(
-      `Waiting for new blocks with reduced polling (${(sourceManager.reducedPollingInterval / 1000)
-          ->Int.toString}s). Chain is caught up, waiting for other chains to backfill.`,
+      reducedPolling
+        ? `Waiting for new blocks with reduced polling (${(sourceManager.reducedPollingInterval / 1000)
+              ->Int.toString}s). Chain is caught up, waiting for other chains to backfill.`
+        : "Initiating check for new blocks.",
     )
-  } else {
-    logger->Logging.childTrace("Initiating check for new blocks.")
+    sourceManager.waitingLogged = true
   }
 
   let mainSources = sourceManager->getNextSources(~isRealtime)
@@ -599,6 +660,7 @@ let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isRealtime, ~reduc
     "source": source.name,
     "newBlockHeight": newBlockHeight,
   })
+  sourceManager.waitingLogged = false
 
   status := Done
 
@@ -668,19 +730,15 @@ let executeQuery = async (
         ~fromBlock=query.fromBlock,
         ~toBlock,
         ~addressesByContractName=query.addressesByContractName,
-        ~indexingAddresses=query.indexingAddresses,
+        ~contractNameByAddress=query.addressesByContractName->FetchState.deriveContractNameByAddress,
         ~partitionId=query.partitionId,
         ~knownHeight,
         ~selection=query.selection,
+        ~itemsTarget=query.itemsTarget,
         ~retry,
         ~logger,
       )
-      logger->Logging.childTrace({
-        "msg": "Fetched block range from server",
-        "toBlock": response.latestFetchedBlockNumber,
-        "numEvents": response.parsedQueueItems->Array.length,
-        "stats": response.stats,
-      })
+      sourceState->recordRequestStats(response.requestStats)
       sourceState.lastFailedAt = None
       responseRef := Some(response)
     } catch {
@@ -820,7 +878,8 @@ let getBlockHashes = async (sourceManager: t, ~blockNumbers: array<int>, ~isReal
 
     try {
       let res = await source.getBlockHashes(~blockNumbers, ~logger)
-      switch res {
+      sourceState->recordRequestStats(res.requestStats)
+      switch res.result {
       | Ok(data) =>
         sourceState.lastFailedAt = None
         responseRef := Some(data)

package/src/sources/SourceManager.res.mjs

@@ -1,11 +1,11 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Utils from "../Utils.res.mjs";
-import * as Hrtime from "../bindings/Hrtime.res.mjs";
 import * as Source from "./Source.res.mjs";
 import * as Logging from "../Logging.res.mjs";
 import * as FetchState from "../FetchState.res.mjs";
 import * as Prometheus from "../Prometheus.res.mjs";
+import * as Performance from "../bindings/Performance.res.mjs";
 import * as ErrorHandling from "../ErrorHandling.res.mjs";
 import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -14,10 +14,44 @@ import * as Primitive_float from "@rescript/runtime/lib/es6/Primitive_float.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
+function recordRequestStats(sourceState, requestStats) {
+  requestStats.forEach(param => {
+    let seconds = param.seconds;
+    let method = param.method;
+    let agg = sourceState.requestStats[method];
+    if (agg !== undefined) {
+      agg.count = agg.count + 1 | 0;
+      agg.seconds = agg.seconds + seconds;
+    } else {
+      sourceState.requestStats[method] = {
+        count: 1,
+        seconds: seconds
+      };
+    }
+  });
+}
+
 function getActiveSource(sourceManager) {
   return sourceManager.activeSource;
 }
 
+function getRequestStatSamples(sourceManager) {
+  let samples = [];
+  sourceManager.sourcesState.forEach(sourceState => {
+    let chainId = sourceState.source.chain;
+    Utils.Dict.forEachWithKey(sourceState.requestStats, (agg, method) => {
+      samples.push({
+        sourceName: sourceState.source.name,
+        chainId: chainId,
+        method: method,
+        count: agg.count,
+        seconds: agg.seconds
+      });
+    });
+  });
+  return samples;
+}
+
 function inFlightCount(sourceManager) {
   return sourceManager.fetchingPartitionsCount;
 }
@@ -137,9 +171,10 @@ function make(sources, isRealtime, newBlockStallTimeoutOpt, newBlockStallTimeout
       unsubscribe: undefined,
       pendingHeightResolvers: [],
       disabled: false,
-      lastFailedAt: undefined
+      lastFailedAt: undefined,
+      requestStats: {}
     })),
-    statusStart: Hrtime.makeTimer(),
+    statusStart: Performance.now(),
     status: "Idle",
     newBlockStallTimeout: newBlockStallTimeout,
     newBlockStallTimeoutRealtime: newBlockStallTimeoutRealtime,
@@ -148,6 +183,7 @@ function make(sources, isRealtime, newBlockStallTimeoutOpt, newBlockStallTimeout
     getHeightRetryInterval: getHeightRetryInterval,
     activeSource: initialActiveSource,
     waitingForNewBlockStateId: undefined,
+    waitingLogged: false,
     fetchingPartitionsCount: 0,
     recoveryTimeout: recoveryTimeout,
     hasRealtime: hasRealtime,
@@ -172,38 +208,33 @@ function trackNewStatus(sourceManager, newStatus) {
       promCounter = Prometheus.IndexingQueryTime.counter;
       break;
   }
-  Prometheus.SafeCounter.handleFloat(promCounter, sourceManager.activeSource.chain, Hrtime.toSecondsFloat(Hrtime.timeSince(sourceManager.statusStart)));
-  sourceManager.statusStart = Hrtime.makeTimer();
+  Prometheus.SafeCounter.handleFloat(promCounter, sourceManager.activeSource.chain, Performance.secondsSince(sourceManager.statusStart));
+  sourceManager.statusStart = Performance.now();
   sourceManager.status = newStatus;
 }
 
-async function fetchNext(sourceManager, fetchState, executeQuery, waitForNewBlock, onNewBlock, concurrencyLimit, bufferLimit, stateId) {
-  let nextQuery = FetchState.getNextQuery(fetchState, concurrencyLimit, bufferLimit);
-  if (typeof nextQuery !== "object") {
-    switch (nextQuery) {
-      case "WaitingForNewBlock" :
-        let waitingStateId = sourceManager.waitingForNewBlockStateId;
-        if (waitingStateId !== undefined && waitingStateId >= stateId) {
-          return;
-        }
-        trackNewStatus(sourceManager, "WaitingForNewBlock");
-        sourceManager.waitingForNewBlockStateId = stateId;
-        let knownHeight = await waitForNewBlock(fetchState.knownHeight);
-        let waitingStateId$1 = sourceManager.waitingForNewBlockStateId;
-        if (waitingStateId$1 !== undefined && waitingStateId$1 === stateId) {
-          trackNewStatus(sourceManager, "Idle");
-          sourceManager.waitingForNewBlockStateId = undefined;
-          return onNewBlock(knownHeight);
-        } else {
-          return;
-        }
-      case "ReachedMaxConcurrency" :
-      case "NothingToQuery" :
-        return;
+async function dispatch(sourceManager, fetchState, executeQuery, waitForNewBlock, onNewBlock, action, stateId) {
+  if (typeof action !== "object") {
+    if (action !== "WaitingForNewBlock") {
+      return;
+    }
+    let waitingStateId = sourceManager.waitingForNewBlockStateId;
+    if (waitingStateId !== undefined && waitingStateId >= stateId) {
+      return;
+    }
+    trackNewStatus(sourceManager, "WaitingForNewBlock");
+    sourceManager.waitingForNewBlockStateId = stateId;
+    let knownHeight = await waitForNewBlock(fetchState.knownHeight);
+    let waitingStateId$1 = sourceManager.waitingForNewBlockStateId;
+    if (waitingStateId$1 !== undefined && waitingStateId$1 === stateId) {
+      trackNewStatus(sourceManager, "Idle");
+      sourceManager.waitingForNewBlockStateId = undefined;
+      return onNewBlock(knownHeight);
+    } else {
+      return;
     }
   } else {
-    let queries = nextQuery._0;
-    FetchState.startFetchingQueries(fetchState, queries);
+    let queries = action._0;
     sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount + queries.length | 0;
     Prometheus.IndexingConcurrency.set(sourceManager.fetchingPartitionsCount, sourceManager.activeSource.chain);
     trackNewStatus(sourceManager, "Querieng");
@@ -267,7 +298,9 @@ async function getSourceNewHeight(sourceManager, sourceState, knownHeight, stall
         let h = initialHeight;
         while (h <= knownHeight && newHeight.contents <= initialHeight) {
           try {
-            h = await source.getHeightOrThrow();
+            let res = await source.getHeightOrThrow();
+            recordRequestStats(sourceState, res.requestStats);
+            h = res.height;
           } catch (exn) {
             
           }
@@ -286,7 +319,9 @@ async function getSourceNewHeight(sourceManager, sourceState, knownHeight, stall
       }
     } else {
       try {
-        let height$1 = await source.getHeightOrThrow();
+        let res = await source.getHeightOrThrow();
+        recordRequestStats(sourceState, res.requestStats);
+        let height$1 = res.height;
         newHeight.contents = height$1;
         if (height$1 <= knownHeight) {
           retry = 0;
@@ -303,6 +338,10 @@ async function getSourceNewHeight(sourceManager, sourceState, knownHeight, stall
               resolvers.forEach(resolve => resolve(newHeight));
             });
             sourceState.unsubscribe = unsubscribe;
+            recordRequestStats(sourceState, [{
+                method: "heightSubscription",
+                seconds: 0
+              }]);
           } else {
             exit = 1;
           }
@@ -413,10 +452,9 @@ async function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPo
     chainId: sourceManager.activeSource.chain,
     knownHeight: knownHeight
   });
-  if (reducedPolling) {
-    Logging.childTrace(logger, `Waiting for new blocks with reduced polling (` + (sourceManager.reducedPollingInterval / 1000 | 0).toString() + `s). Chain is caught up, waiting for other chains to backfill.`);
-  } else {
-    Logging.childTrace(logger, "Initiating check for new blocks.");
+  if (!sourceManager.waitingLogged) {
+    Logging.childTrace(logger, reducedPolling ? `Waiting for new blocks with reduced polling (` + (sourceManager.reducedPollingInterval / 1000 | 0).toString() + `s). Chain is caught up, waiting for other chains to backfill.` : "Initiating check for new blocks.");
+    sourceManager.waitingLogged = true;
   }
   let mainSources = getNextSources(sourceManager, isRealtime, undefined);
   let status = {
@@ -458,6 +496,7 @@ async function waitForNewBlock(sourceManager, knownHeight, isRealtime, reducedPo
     source: source.name,
     newBlockHeight: newBlockHeight
   });
+  sourceManager.waitingLogged = false;
   status.contents = "Done";
   return newBlockHeight;
 }
@@ -504,13 +543,8 @@ async function executeQuery(sourceManager, query, knownHeight, isRealtime) {
       retry: retry
     });
     try {
-      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, query.indexingAddresses, knownHeight, query.partitionId, query.selection, retry, logger$2);
-      Logging.childTrace(logger$2, {
-        msg: "Fetched block range from server",
-        toBlock: response.latestFetchedBlockNumber,
-        numEvents: response.parsedQueueItems.length,
-        stats: response.stats
-      });
+      let response = await source.getItemsOrThrow(query.fromBlock, toBlock, query.addressesByContractName, FetchState.deriveContractNameByAddress(query.addressesByContractName), knownHeight, query.partitionId, query.selection, query.itemsTarget, retry, logger$2);
+      recordRequestStats(sourceState, response.requestStats);
       sourceState.lastFailedAt = undefined;
       responseRef = response;
     } catch (raw_error) {
@@ -646,11 +680,13 @@ async function getBlockHashes(sourceManager, blockNumbers, isRealtime) {
     });
     try {
       let res = await source.getBlockHashes(blockNumbers, logger$1);
-      if (res.TAG === "Ok") {
+      recordRequestStats(sourceState, res.requestStats);
+      let data = res.result;
+      if (data.TAG === "Ok") {
         sourceState.lastFailedAt = undefined;
-        responseRef = res._0;
+        responseRef = data._0;
       } else {
-        throw res._0;
+        throw data._0;
       }
     } catch (raw_exn) {
       let exn = Primitive_exceptions.internalToException(raw_exn);
@@ -682,9 +718,10 @@ export {
   getSourceRole,
   make,
   getActiveSource,
+  getRequestStatSamples,
   inFlightCount,
   onReorg,
-  fetchNext,
+  dispatch,
   waitForNewBlock,
   executeQuery,
   makeGetHeightRetryInterval,