envio 3.0.0-alpha.21 → 3.0.0-alpha.23

package/src/sources/SourceManager.res

@@ -1,5 +1,3 @@
-open Belt
-
 type sourceManagerStatus = Idle | WaitingForNewBlock | Querieng
 
 type sourceState = {
@@ -26,6 +24,7 @@ type t = {
   newBlockStallTimeout: int,
   newBlockStallTimeoutLive: int,
   stalledPollingInterval: int,
+  reducedPollingInterval: int,
   getHeightRetryInterval: (~retry: int) => int,
   mutable activeSource: Source.t,
   mutable waitingForNewBlockStateId: option<int>,
@@ -75,6 +74,7 @@ let make = (
   ~newBlockStallTimeout=60_000,
   ~newBlockStallTimeoutLive=20_000,
   ~stalledPollingInterval=5_000,
+  ~reducedPollingInterval=60_000,
   ~recoveryTimeout=60_000.0,
   ~getHeightRetryInterval=makeGetHeightRetryInterval(
     ~initialRetryInterval=1000,
@@ -82,12 +82,13 @@ let make = (
     ~maxRetryInterval=60_000,
   ),
 ) => {
-  let hasLive = sources->Js.Array2.some(s => s.sourceFor === Live)
-  let initialActiveSource = switch sources->Js.Array2.find(source =>
+  let hasLive = sources->Array.some(s => s.sourceFor === Live)
+  let initialActiveSource = switch sources->Array.find(source =>
     getSourceRole(~sourceFor=source.sourceFor, ~isLive, ~hasLive) === Some(Primary)
   ) {
   | Some(source) => source
-  | None => Js.Exn.raiseError("Invalid configuration, no data-source for historical sync provided")
+  | None =>
+    JsError.throwWithMessage("Invalid configuration, no data-source for historical sync provided")
   }
   Prometheus.IndexingMaxConcurrency.set(
     ~maxConcurrency=maxPartitionConcurrency,
@@ -113,6 +114,7 @@ let make = (
     newBlockStallTimeout,
     newBlockStallTimeoutLive,
     stalledPollingInterval,
+    reducedPollingInterval,
     getHeightRetryInterval,
     recoveryTimeout,
     statusStart: Hrtime.makeTimer(),
@@ -214,7 +216,7 @@ let disableSource = (sourceManager: t, sourceState: sourceState) => {
     if sourceState.source.sourceFor === Live {
       // Only clear hasLive if no other non-disabled Live sources remain
       let hasOtherLive =
-        sourceManager.sourcesState->Js.Array2.some(s =>
+        sourceManager.sourcesState->Array.some(s =>
           s !== sourceState && !s.disabled && s.source.sourceFor === Live
         )
       sourceManager.hasLive = hasOtherLive
@@ -233,6 +235,7 @@ let getSourceNewHeight = async (
   ~isLive,
   ~status: ref<status>,
   ~logger,
+  ~reducedPolling,
 ) => {
   let source = sourceState.source
   let initialHeight = sourceState.knownHeight
@@ -295,7 +298,9 @@ let getSourceNewHeight = async (
             sourceState.unsubscribe = Some(unsubscribe)
           | _ =>
             // Slowdown polling when the chain isn't progressing
-            let pollingInterval = if status.contents === Stalled {
+            let pollingInterval = if reducedPolling {
+              sourceManager.reducedPollingInterval
+            } else if status.contents === Stalled {
               sourceManager.stalledPollingInterval
             } else {
               source.pollingInterval
@@ -331,15 +336,15 @@ let getSourceNewHeight = async (
 
 let compareByOldestFailure = (a: sourceState, b: sourceState) =>
   switch (a.lastFailedAt, b.lastFailedAt) {
-  | (None, Some(_)) => -1
-  | (Some(_), None) => 1
-  | (Some(a), Some(b)) => a < b ? -1 : a > b ? 1 : 0
-  | (None, None) => 0
+  | (None, Some(_)) => Ordering.less
+  | (Some(_), None) => Ordering.greater
+  | (Some(a), Some(b)) => a < b ? Ordering.less : a > b ? Ordering.greater : Ordering.equal
+  | (None, None) => Ordering.equal
   }
 
 // Priority: working primaries > working secondaries > all primaries.
 let getNextSources = (sourceManager, ~isLive, ~excludedSources=?) => {
-  let now = Js.Date.now()
+  let now = Date.now()
   let workingPrimarySources = []
   let allPrimarySources = []
   let workingSecondarySources = []
@@ -377,7 +382,8 @@ let getNextSources = (sourceManager, ~isLive, ~excludedSources=?) => {
     workingSecondarySources
   } else {
     // All primaries in recovery — sort by oldest lastFailedAt (closest to recovery first)
-    allPrimarySources->Js.Array2.sortInPlaceWith(compareByOldestFailure)
+    allPrimarySources->Array.sort(compareByOldestFailure)
+    allPrimarySources
   }
 }
 
@@ -389,7 +395,7 @@ let getNextSource = (sourceManager, ~isLive, ~excludedSources=?) => {
   | None => None
   | Some(first) if first.source === sourceManager.activeSource => Some(first)
   | _ =>
-    switch sources->Js.Array2.find(s => s.source === sourceManager.activeSource) {
+    switch sources->Array.find(s => s.source === sourceManager.activeSource) {
     | Some(_) as result => result
     | None => sources->Array.get(0)
     }
@@ -397,7 +403,7 @@ let getNextSource = (sourceManager, ~isLive, ~excludedSources=?) => {
 }
 
 // Polls for a block height greater than the given block number to ensure a new block is available for indexing.
-let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isLive) => {
+let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isLive, ~reducedPolling) => {
   let {sourcesState} = sourceManager
 
   let logger = Logging.createChild(
@@ -406,13 +412,24 @@ let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isLive) => {
       "knownHeight": knownHeight,
     },
   )
-  logger->Logging.childTrace("Initiating check for new blocks.")
+  if reducedPolling {
+    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.`,
+    )
+  } else {
+    logger->Logging.childTrace("Initiating check for new blocks.")
+  }
 
   let mainSources = sourceManager->getNextSources(~isLive)
 
   let status = ref(Active)
 
-  let stallTimeout = if isLive {
+  // Use a much longer stall timeout when reduced polling is active
+  // to avoid spurious stall warnings while waiting for other chains to backfill
+  let stallTimeout = if reducedPolling {
+    sourceManager.reducedPollingInterval * 2
+  } else if isLive {
     sourceManager.newBlockStallTimeoutLive
   } else {
     sourceManager.newBlockStallTimeout
@@ -430,6 +447,7 @@ let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isLive) => {
           ~isLive,
           ~status,
           ~logger,
+          ~reducedPolling,
         ),
       )
     })
@@ -439,7 +457,7 @@ let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isLive) => {
         let fallbackSources = []
         sourcesState->Array.forEach(sourceState => {
           if (
-            !(mainSources->Js.Array2.includes(sourceState)) &&
+            !(mainSources->Array.includes(sourceState)) &&
             getSourceRole(
               ~sourceFor=sourceState.source.sourceFor,
               ~isLive,
@@ -479,6 +497,7 @@ let waitForNewBlock = async (sourceManager: t, ~knownHeight, ~isLive) => {
                 ~isLive,
                 ~status,
                 ~logger,
+                ~reducedPolling,
               ),
             )
           }),
@@ -560,7 +579,7 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~knownHeig
         ~fromBlock=query.fromBlock,
         ~toBlock,
         ~addressesByContractName=query.addressesByContractName,
-        ~indexingContracts=query.indexingContracts,
+        ~indexingAddresses=query.indexingAddresses,
         ~partitionId=query.partitionId,
         ~knownHeight,
         ~selection=query.selection,
@@ -647,7 +666,7 @@ let executeQuery = async (sourceManager: t, ~query: FetchState.query, ~knownHeig
         }
 
         if shouldSwitch {
-          let now = Js.Date.now()
+          let now = Date.now()
           sourceState.lastFailedAt = Some(now)
           // Check if there's a working (recovered) source to switch to immediately
           let nextSource =