envio 2.32.3 → 2.32.7

package/src/sources/SourceManager.res.js

@@ -11,6 +11,7 @@ var Belt_Array = require("rescript/lib/js/belt_Array.js");
 var FetchState = require("../FetchState.res.js");
 var Prometheus = require("../Prometheus.res.js");
 var Belt_Option = require("rescript/lib/js/belt_Option.js");
+var Caml_option = require("rescript/lib/js/caml_option.js");
 var ErrorHandling = require("../ErrorHandling.res.js");
 var Caml_js_exceptions = require("rescript/lib/js/caml_js_exceptions.js");
 
@@ -36,7 +37,15 @@ function make(sources, maxPartitionConcurrency, newBlockFallbackStallTimeoutOpt,
   Prometheus.IndexingMaxConcurrency.set(maxPartitionConcurrency, initialActiveSource.chain);
   Prometheus.IndexingConcurrency.set(0, initialActiveSource.chain);
   return {
-          sources: new Set(sources),
+          sourcesState: Belt_Array.map(sources, (function (source) {
+                  return {
+                          source: source,
+                          knownHeight: 0,
+                          unsubscribe: undefined,
+                          pendingHeightResolvers: [],
+                          disabled: false
+                        };
+                })),
           statusStart: Hrtime.makeTimer(),
           status: "Idle",
           maxPartitionConcurrency: maxPartitionConcurrency,
@@ -70,9 +79,9 @@ function trackNewStatus(sourceManager, newStatus) {
 }
 
 async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQuery, waitForNewBlock, onNewBlock, stateId) {
-  var queries = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0, currentBlockHeight, stateId);
-  if (typeof queries !== "object") {
-    switch (queries) {
+  var nextQuery = FetchState.getNextQuery(fetchState, sourceManager.maxPartitionConcurrency - sourceManager.fetchingPartitionsCount | 0, currentBlockHeight, stateId);
+  if (typeof nextQuery !== "object") {
+    switch (nextQuery) {
       case "WaitingForNewBlock" :
           var waitingStateId = sourceManager.waitingForNewBlockStateId;
           if (waitingStateId !== undefined && waitingStateId >= stateId) {
@@ -80,12 +89,12 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
           }
           trackNewStatus(sourceManager, "WaitingForNewBlock");
           sourceManager.waitingForNewBlockStateId = stateId;
-          var currentBlockHeight$1 = await waitForNewBlock(currentBlockHeight);
+          var knownHeight = await waitForNewBlock(currentBlockHeight);
           var waitingStateId$1 = sourceManager.waitingForNewBlockStateId;
           if (waitingStateId$1 !== undefined && waitingStateId$1 === stateId) {
             trackNewStatus(sourceManager, "Idle");
             sourceManager.waitingForNewBlockStateId = undefined;
-            return onNewBlock(currentBlockHeight$1);
+            return onNewBlock(knownHeight);
           } else {
             return ;
           }
@@ -95,12 +104,12 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
       
     }
   } else {
-    var queries$1 = queries._0;
-    FetchState.startFetchingQueries(fetchState, queries$1, stateId);
-    sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount + queries$1.length | 0;
+    var queries = nextQuery._0;
+    FetchState.startFetchingQueries(fetchState, queries, stateId);
+    sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount + queries.length | 0;
     Prometheus.IndexingConcurrency.set(sourceManager.fetchingPartitionsCount, sourceManager.activeSource.chain);
     trackNewStatus(sourceManager, "Querieng");
-    await Promise.all(Belt_Array.map(queries$1, (function (q) {
+    await Promise.all(Belt_Array.map(queries, (function (q) {
                 var promise = executeQuery(q);
                 promise.then(function (param) {
                       sourceManager.fetchingPartitionsCount = sourceManager.fetchingPartitionsCount - 1 | 0;
@@ -116,63 +125,109 @@ async function fetchNext(sourceManager, fetchState, currentBlockHeight, executeQ
   }
 }
 
-async function getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger) {
-  var newHeight = 0;
+function disableSource(sourceState) {
+  if (sourceState.disabled) {
+    return false;
+  }
+  sourceState.disabled = true;
+  var unsubscribe = sourceState.unsubscribe;
+  if (unsubscribe !== undefined) {
+    unsubscribe();
+  }
+  return true;
+}
+
+async function getSourceNewHeight(sourceManager, sourceState, knownHeight, status, logger) {
+  var source = sourceState.source;
+  var initialHeight = sourceState.knownHeight;
+  var newHeight = initialHeight;
   var retry = 0;
-  while(newHeight <= currentBlockHeight && status.contents !== "Done") {
-    try {
-      var endTimer = Prometheus.SourceGetHeightDuration.startTimer({
-            source: source.name,
-            chainId: source.chain
-          });
-      var height = await source.getHeightOrThrow();
-      endTimer();
-      newHeight = height;
-      if (height <= currentBlockHeight) {
-        retry = 0;
-        var pollingInterval = status.contents === "Stalled" ? sourceManager.stalledPollingInterval : source.pollingInterval;
-        await Utils.delay(pollingInterval);
+  while(newHeight <= knownHeight && status.contents !== "Done") {
+    var match = sourceState.unsubscribe;
+    if (match !== undefined) {
+      var height = await new Promise((function (resolve, _reject) {
+              sourceState.pendingHeightResolvers.push(resolve);
+            }));
+      if (height > initialHeight) {
+        newHeight = height;
       }
       
-    }
-    catch (raw_exn){
-      var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
-      var retryInterval = sourceManager.getHeightRetryInterval(retry);
-      Logging.childTrace(logger, {
-            msg: "Height retrieval from " + source.name + " source failed. Retrying in " + String(retryInterval) + "ms.",
-            source: source.name,
-            err: Utils.prettifyExn(exn)
-          });
-      retry = retry + 1 | 0;
-      await Utils.delay(retryInterval);
+    } else {
+      try {
+        var endTimer = Prometheus.SourceGetHeightDuration.startTimer({
+              source: source.name,
+              chainId: source.chain
+            });
+        var height$1 = await source.getHeightOrThrow();
+        endTimer();
+        newHeight = height$1;
+        if (height$1 <= knownHeight) {
+          retry = 0;
+          var createSubscription = source.createHeightSubscription;
+          if (createSubscription !== undefined) {
+            var unsubscribe = createSubscription(function (newHeight) {
+                  sourceState.knownHeight = newHeight;
+                  var resolvers = sourceState.pendingHeightResolvers;
+                  sourceState.pendingHeightResolvers = [];
+                  Belt_Array.forEach(resolvers, (function (resolve) {
+                          resolve(newHeight);
+                        }));
+                });
+            sourceState.unsubscribe = unsubscribe;
+          } else {
+            var pollingInterval = status.contents === "Stalled" ? sourceManager.stalledPollingInterval : source.pollingInterval;
+            await Utils.delay(pollingInterval);
+          }
+        }
+        
+      }
+      catch (raw_exn){
+        var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+        var retryInterval = sourceManager.getHeightRetryInterval(retry);
+        Logging.childTrace(logger, {
+              msg: "Height retrieval from " + source.name + " source failed. Retrying in " + String(retryInterval) + "ms.",
+              source: source.name,
+              err: Utils.prettifyExn(exn)
+            });
+        retry = retry + 1 | 0;
+        await Utils.delay(retryInterval);
+      }
     }
   };
-  Prometheus.SourceHeight.set(source.name, source.chain, newHeight);
+  if (newHeight > initialHeight) {
+    Prometheus.SourceHeight.set(source.name, source.chain, newHeight);
+  }
   return newHeight;
 }
 
-async function waitForNewBlock(sourceManager, currentBlockHeight) {
+async function waitForNewBlock(sourceManager, knownHeight) {
   var logger = Logging.createChild({
         chainId: sourceManager.activeSource.chain,
-        currentBlockHeight: currentBlockHeight
+        knownHeight: knownHeight
       });
   Logging.childTrace(logger, "Initiating check for new blocks.");
   var syncSources = [];
   var fallbackSources = [];
-  sourceManager.sources.forEach(function (source) {
-        if (source.sourceFor === "Sync" || source === sourceManager.activeSource) {
-          syncSources.push(source);
-        } else {
-          fallbackSources.push(source);
-        }
-      });
+  Belt_Array.forEach(sourceManager.sourcesState, (function (sourceState) {
+          var source = sourceState.source;
+          if (sourceState.disabled) {
+            return ;
+          } else {
+            if (source.sourceFor === "Sync" || source === sourceManager.activeSource) {
+              syncSources.push(sourceState);
+            } else {
+              fallbackSources.push(sourceState);
+            }
+            return ;
+          }
+        }));
   var status = {
     contents: "Active"
   };
-  var match = await Promise.race(Belt_Array.concat(Belt_Array.map(syncSources, (async function (source) {
+  var match = await Promise.race(Belt_Array.concat(Belt_Array.map(syncSources, (async function (sourceState) {
                   return [
-                          source,
-                          await getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger)
+                          sourceState.source,
+                          await getSourceNewHeight(sourceManager, sourceState, knownHeight, status, logger)
                         ];
                 })), [Utils.delay(sourceManager.newBlockFallbackStallTimeout).then(function () {
                   if (status.contents !== "Done") {
@@ -183,10 +238,10 @@ async function waitForNewBlock(sourceManager, currentBlockHeight) {
                       Logging.childWarn(logger, "No new blocks detected within " + String(sourceManager.newBlockFallbackStallTimeout / 1000 | 0) + "s. Polling will continue at a reduced rate. For better reliability, refer to our RPC fallback guide: https://docs.envio.dev/docs/HyperIndex/rpc-sync");
                     }
                   }
-                  return Promise.race(Belt_Array.map(fallbackSources, (async function (source) {
+                  return Promise.race(Belt_Array.map(fallbackSources, (async function (sourceState) {
                                     return [
-                                            source,
-                                            await getSourceNewHeight(sourceManager, source, currentBlockHeight, status, logger)
+                                            sourceState.source,
+                                            await getSourceNewHeight(sourceManager, sourceState, knownHeight, status, logger)
                                           ];
                                   })));
                 })]));
@@ -203,29 +258,33 @@ async function waitForNewBlock(sourceManager, currentBlockHeight) {
   return newBlockHeight;
 }
 
-function getNextSyncSource(sourceManager, initialSource, currentSource, attemptFallbacksOpt) {
+function getNextSyncSourceState(sourceManager, initialSourceState, currentSourceState, attemptFallbacksOpt) {
   var attemptFallbacks = attemptFallbacksOpt !== undefined ? attemptFallbacksOpt : false;
   var before = [];
   var after = [];
   var hasActive = {
     contents: false
   };
-  sourceManager.sources.forEach(function (source) {
-        if (source === currentSource) {
-          hasActive.contents = true;
-          return ;
-        }
-        var match = source.sourceFor;
-        var tmp;
-        tmp = match === "Sync" ? true : attemptFallbacks || source === initialSource;
-        if (tmp) {
-          (
-              hasActive.contents ? after : before
-            ).push(source);
-          return ;
-        }
-        
-      });
+  Belt_Array.forEach(sourceManager.sourcesState, (function (sourceState) {
+          var source = sourceState.source;
+          if (sourceState.disabled) {
+            return ;
+          }
+          if (sourceState === currentSourceState) {
+            hasActive.contents = true;
+            return ;
+          }
+          var match = source.sourceFor;
+          var tmp;
+          tmp = match === "Sync" ? true : attemptFallbacks || sourceState === initialSourceState;
+          if (tmp) {
+            (
+                hasActive.contents ? after : before
+              ).push(sourceState);
+            return ;
+          }
+          
+        }));
   var s = Belt_Array.get(after, 0);
   if (s !== undefined) {
     return s;
@@ -234,7 +293,7 @@ function getNextSyncSource(sourceManager, initialSource, currentSource, attemptF
   if (s$1 !== undefined) {
     return s$1;
   } else {
-    return currentSource;
+    return currentSourceState;
   }
 }
 
@@ -246,11 +305,15 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
     );
   var responseRef;
   var retryRef = 0;
-  var initialSource = sourceManager.activeSource;
-  var sourceRef = initialSource;
+  var initialSourceState = sourceManager.sourcesState.find(function (s) {
+        return s.source === sourceManager.activeSource;
+      });
+  var initialSourceState$1 = initialSourceState === undefined ? undefined : Caml_option.some(initialSourceState);
+  var sourceStateRef = initialSourceState$1;
   var shouldUpdateActiveSource = false;
   while(Belt_Option.isNone(responseRef)) {
-    var source = sourceRef;
+    var sourceState = sourceStateRef;
+    var source = sourceState.source;
     var toBlock = toBlockRef;
     var retry = retryRef;
     var logger = Logging.createChild({
@@ -301,7 +364,7 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
                 case "WithBackoff" :
                     var backoffMillis = match$1.backoffMillis;
                     var attemptFallbacks = retry >= 10;
-                    var nextSource = !(retry === 0 || retry === 1) && retry % 2 === 0 ? getNextSyncSource(sourceManager, initialSource, source, attemptFallbacks) : source;
+                    var nextSourceState = !(retry === 0 || retry === 1) && retry % 2 === 0 ? getNextSyncSourceState(sourceManager, initialSourceState$1, sourceState, attemptFallbacks) : sourceState;
                     var log = retry >= 4 ? Logging.childWarn : Logging.childTrace;
                     log(logger, {
                           msg: match$1.message,
@@ -310,13 +373,13 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
                           retry: retry,
                           err: Utils.prettifyExn(exn)
                         });
-                    var shouldSwitch = nextSource !== source;
+                    var shouldSwitch = nextSourceState !== sourceState;
                     if (shouldSwitch) {
                       Logging.childInfo(logger, {
                             msg: "Switching to another data-source",
-                            source: nextSource.name
+                            source: nextSourceState.source.name
                           });
-                      sourceRef = nextSource;
+                      sourceStateRef = nextSourceState;
                       shouldUpdateActiveSource = true;
                     } else {
                       await Utils.delay(backoffMillis < 60000 ? backoffMillis : 60000);
@@ -324,8 +387,8 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
                     retryRef = retryRef + 1 | 0;
                     break;
                 case "ImpossibleForTheQuery" :
-                    var nextSource$1 = getNextSyncSource(sourceManager, initialSource, source, true);
-                    var hasAnotherSource = nextSource$1 !== initialSource;
+                    var nextSourceState$1 = getNextSyncSourceState(sourceManager, initialSourceState$1, sourceState, true);
+                    var hasAnotherSource = nextSourceState$1 !== initialSourceState$1;
                     Logging.childWarn(logger, {
                           msg: match$1.message + (
                             hasAnotherSource ? " - Attempting to another source" : ""
@@ -334,7 +397,7 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
                           err: Utils.prettifyExn(exn)
                         });
                     if (hasAnotherSource) {
-                      sourceRef = nextSource$1;
+                      sourceStateRef = nextSourceState$1;
                       shouldUpdateActiveSource = false;
                       retryRef = 0;
                     } else {
@@ -347,9 +410,9 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
           
         }
         if (exit === 1) {
-          var nextSource$2 = getNextSyncSource(sourceManager, initialSource, source, undefined);
-          var notAlreadyDeleted = sourceManager.sources.delete(source);
-          if (notAlreadyDeleted) {
+          var nextSourceState$2 = getNextSyncSourceState(sourceManager, initialSourceState$1, sourceState, undefined);
+          var notAlreadyDisabled = disableSource(sourceState);
+          if (notAlreadyDisabled) {
             switch (error$1.TAG) {
               case "UnsupportedSelection" :
                   Logging.childError(logger, error$1.message);
@@ -367,14 +430,14 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
               
             }
           }
-          if (nextSource$2 === source) {
+          if (nextSourceState$2 === sourceState) {
             ErrorHandling.mkLogAndRaise(logger, "The indexer doesn't have data-sources which can continue fetching. Please, check the error logs or reach out to the Envio team.", null);
           } else {
             Logging.childInfo(logger, {
                   msg: "Switching to another data-source",
-                  source: nextSource$2.name
+                  source: nextSourceState$2.source.name
                 });
-            sourceRef = nextSource$2;
+            sourceStateRef = nextSourceState$2;
             shouldUpdateActiveSource = true;
             retryRef = 0;
           }
@@ -386,7 +449,7 @@ async function executeQuery(sourceManager, query, currentBlockHeight) {
     }
   };
   if (shouldUpdateActiveSource) {
-    sourceManager.activeSource = sourceRef;
+    sourceManager.activeSource = sourceStateRef.source;
   }
   return responseRef;
 }

package/src/sources/SourceManager.resi

@@ -15,12 +15,12 @@ let fetchNext: (
   ~fetchState: FetchState.t,
   ~currentBlockHeight: int,
   ~executeQuery: FetchState.query => promise<unit>,
-  ~waitForNewBlock: (~currentBlockHeight: int) => promise<int>,
-  ~onNewBlock: (~currentBlockHeight: int) => unit,
+  ~waitForNewBlock: (~knownHeight: int) => promise<int>,
+  ~onNewBlock: (~knownHeight: int) => unit,
   ~stateId: int,
 ) => promise<unit>
 
-let waitForNewBlock: (t, ~currentBlockHeight: int) => promise<int>
+let waitForNewBlock: (t, ~knownHeight: int) => promise<int>
 
 let executeQuery: (
   t,