envio 3.3.0-alpha.12 → 3.3.0-alpha.13

package/src/LoadLayer.res

@@ -72,28 +72,29 @@ let loadById = (
 let callEffect = (
   ~effect: Internal.effect,
   ~arg: Internal.effectArgs,
-  ~inMemTable: IndexerState.effectCacheInMemTable,
+  ~inMemTable: EffectState.effectCacheInMemTable,
   ~timerRef,
   ~onError,
 ) => {
   let effectName = effect.name
-  let hadActiveCalls = effect.activeCallsCount > 0
-  effect.activeCallsCount = effect.activeCallsCount + 1
+  let scopeLabel = inMemTable.scope->Internal.EffectCache.scopeToString
+  let hadActiveCalls = inMemTable.activeCallsCount > 0
+  inMemTable.activeCallsCount = inMemTable.activeCallsCount + 1
   Prometheus.EffectCalls.activeCallsCount->Prometheus.SafeGauge.handleInt(
-    ~labels=effectName,
-    ~value=effect.activeCallsCount,
+    ~labels={"effect": effectName, "scope": scopeLabel},
+    ~value=inMemTable.activeCallsCount,
   )
 
   if hadActiveCalls {
-    let elapsed = Performance.secondsBetween(~from=effect.prevCallStartTimerRef, ~to=timerRef)
+    let elapsed = Performance.secondsBetween(~from=inMemTable.prevCallStartTimerRef, ~to=timerRef)
     if elapsed > 0. {
       Prometheus.EffectCalls.timeCounter->Prometheus.SafeCounter.handleFloat(
-        ~labels=effectName,
+        ~labels={"effect": effectName, "scope": scopeLabel},
         ~value=elapsed,
       )
     }
   }
-  effect.prevCallStartTimerRef = timerRef
+  inMemTable.prevCallStartTimerRef = timerRef
 
   effect.handler(arg)
   ->Promise.thenResolve(output => {
@@ -108,21 +109,23 @@ let callEffect = (
     onError(~inputKey=arg.cacheKey, ~exn)
   })
   ->Promise.finally(() => {
-    effect.activeCallsCount = effect.activeCallsCount - 1
+    inMemTable.activeCallsCount = inMemTable.activeCallsCount - 1
     Prometheus.EffectCalls.activeCallsCount->Prometheus.SafeGauge.handleInt(
-      ~labels=effectName,
-      ~value=effect.activeCallsCount,
+      ~labels={"effect": effectName, "scope": scopeLabel},
+      ~value=inMemTable.activeCallsCount,
     )
     let newTimer = Performance.now()
     Prometheus.EffectCalls.timeCounter->Prometheus.SafeCounter.handleFloat(
-      ~labels=effectName,
-      ~value=Performance.secondsBetween(~from=effect.prevCallStartTimerRef, ~to=newTimer),
+      ~labels={"effect": effectName, "scope": scopeLabel},
+      ~value=Performance.secondsBetween(~from=inMemTable.prevCallStartTimerRef, ~to=newTimer),
     )
-    effect.prevCallStartTimerRef = newTimer
+    inMemTable.prevCallStartTimerRef = newTimer
 
-    Prometheus.EffectCalls.totalCallsCount->Prometheus.SafeCounter.increment(~labels=effectName)
+    Prometheus.EffectCalls.totalCallsCount->Prometheus.SafeCounter.increment(
+      ~labels={"effect": effectName, "scope": scopeLabel},
+    )
     Prometheus.EffectCalls.sumTimeCounter->Prometheus.SafeCounter.handleFloat(
-      ~labels=effectName,
+      ~labels={"effect": effectName, "scope": scopeLabel},
       ~value=timerRef->Performance.secondsSince,
     )
   })
@@ -131,7 +134,7 @@ let callEffect = (
 let rec executeWithRateLimit = (
   ~effect: Internal.effect,
   ~effectArgs: array<Internal.effectArgs>,
-  ~inMemTable,
+  ~inMemTable: EffectState.effectCacheInMemTable,
   ~onError,
   ~isFromQueue: bool,
 ) => {
@@ -140,7 +143,7 @@ let rec executeWithRateLimit = (
   let timerRef = Performance.now()
   let promises = []
 
-  switch effect.rateLimit {
+  switch inMemTable.rateLimitState {
   | None =>
     // No rate limiting - execute all immediately
     for idx in 0 to effectArgs->Array.length - 1 {
@@ -193,7 +196,11 @@ let rec executeWithRateLimit = (
     if immediateCount > 0 && isFromQueue {
       // Update queue count metric
       state.queueCount = state.queueCount - immediateCount
-      Prometheus.EffectQueueCount.set(~count=state.queueCount, ~effectName)
+      Prometheus.EffectQueueCount.set(
+        ~count=state.queueCount,
+        ~effectName,
+        ~scope=inMemTable.scope->Internal.EffectCache.scopeToString,
+      )
     }
 
     // Handle queued items
@@ -201,7 +208,11 @@ let rec executeWithRateLimit = (
       if !isFromQueue {
         // Update queue count metric
         state.queueCount = state.queueCount + queuedArgs->Array.length
-        Prometheus.EffectQueueCount.set(~count=state.queueCount, ~effectName)
+        Prometheus.EffectQueueCount.set(
+          ~count=state.queueCount,
+          ~effectName,
+          ~scope=inMemTable.scope->Internal.EffectCache.scopeToString,
+        )
       }
 
       let millisUntilReset = ref(0)
@@ -249,14 +260,23 @@ let loadEffect = (
   ~persistence: Persistence.t,
   ~effect: Internal.effect,
   ~effectArgs,
+  ~scope: Internal.chainScope,
   ~indexerState,
   ~shouldGroup,
   ~item,
   ~ecosystem,
 ) => {
   let effectName = effect.name
-  let key = `${effectName}.effect`
-  let inMemTable = indexerState->InMemoryStore.getEffectInMemTable(~effect)
+  let inMemTable = indexerState->InMemoryStore.getEffectInMemTable(~effect, ~scope)
+  let table = inMemTable.table
+  let tableName = table.tableName
+  // The operation key must differ per scope so chain-scoped calls with the same
+  // input never dedup across chains. Cross-chain keeps the bare effect name so
+  // the storage-load metric stays stable.
+  let key = switch scope {
+  | CrossChain => `${effectName}.effect`
+  | Chain(chainId) => `${effectName}.effect.${chainId->Int.toString}`
+  }
 
   let load = async (args, ~onError) => {
     let idsToLoad = args->Array.map((arg: Internal.effectArgs) => arg.cacheKey)
@@ -264,13 +284,13 @@ let loadEffect = (
 
     if (
       switch persistence.storageStatus {
-      | Ready({cache}) => cache->Dict.has(effectName)
+      | Ready({cache}) => cache->Dict.has(tableName)
       | _ => false
       }
     ) {
       let storage = persistence->Persistence.getInitializedStorageOrThrow
       let timerRef = Prometheus.StorageLoad.startOperation(~storage=storage.name, ~operation=key)
-      let {table, outputSchema} = effect.storageMeta
+      let {outputSchema} = effect.storageMeta
 
       let dbEntities = try {
         (

package/src/LoadLayer.res.mjs

@@ -3,6 +3,7 @@
 import * as Table from "./db/Table.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as Internal from "./Internal.res.mjs";
 import * as Ecosystem from "./Ecosystem.res.mjs";
 import * as Prometheus from "./Prometheus.res.mjs";
 import * as LoadManager from "./LoadManager.res.mjs";
@@ -51,24 +52,43 @@ function loadById(loadManager, persistence, entityConfig, indexerState, shouldGr
 
 function callEffect(effect, arg, inMemTable, timerRef, onError) {
   let effectName = effect.name;
-  let hadActiveCalls = effect.activeCallsCount > 0;
-  effect.activeCallsCount = effect.activeCallsCount + 1 | 0;
-  Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
+  let scopeLabel = Internal.EffectCache.scopeToString(inMemTable.scope);
+  let hadActiveCalls = inMemTable.activeCallsCount > 0;
+  inMemTable.activeCallsCount = inMemTable.activeCallsCount + 1 | 0;
+  Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, {
+    effect: effectName,
+    scope: scopeLabel
+  }, inMemTable.activeCallsCount);
   if (hadActiveCalls) {
-    let elapsed = Performance.secondsBetween(effect.prevCallStartTimerRef, timerRef);
+    let elapsed = Performance.secondsBetween(inMemTable.prevCallStartTimerRef, timerRef);
     if (elapsed > 0) {
-      Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, elapsed);
+      Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, {
+        effect: effectName,
+        scope: scopeLabel
+      }, elapsed);
     }
   }
-  effect.prevCallStartTimerRef = timerRef;
+  inMemTable.prevCallStartTimerRef = timerRef;
   return effect.handler(arg).then(output => InMemoryStore.setEffectOutput(inMemTable, arg.checkpointId, arg.cacheKey, output, arg.context.cache)).catch(exn => onError(arg.cacheKey, exn)).finally(() => {
-    effect.activeCallsCount = effect.activeCallsCount - 1 | 0;
-    Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, effectName, effect.activeCallsCount);
+    inMemTable.activeCallsCount = inMemTable.activeCallsCount - 1 | 0;
+    Prometheus.SafeGauge.handleInt(Prometheus.EffectCalls.activeCallsCount, {
+      effect: effectName,
+      scope: scopeLabel
+    }, inMemTable.activeCallsCount);
     let newTimer = Performance.now();
-    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, effectName, Performance.secondsBetween(effect.prevCallStartTimerRef, newTimer));
-    effect.prevCallStartTimerRef = newTimer;
-    Prometheus.SafeCounter.increment(Prometheus.EffectCalls.totalCallsCount, effectName);
-    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.sumTimeCounter, effectName, Performance.secondsSince(timerRef));
+    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.timeCounter, {
+      effect: effectName,
+      scope: scopeLabel
+    }, Performance.secondsBetween(inMemTable.prevCallStartTimerRef, newTimer));
+    inMemTable.prevCallStartTimerRef = newTimer;
+    Prometheus.SafeCounter.increment(Prometheus.EffectCalls.totalCallsCount, {
+      effect: effectName,
+      scope: scopeLabel
+    });
+    Prometheus.SafeCounter.handleFloat(Prometheus.EffectCalls.sumTimeCounter, {
+      effect: effectName,
+      scope: scopeLabel
+    }, Performance.secondsSince(timerRef));
   });
 }
 
@@ -76,7 +96,7 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
   let effectName = effect.name;
   let timerRef = Performance.now();
   let promises = [];
-  let state = effect.rateLimit;
+  let state = inMemTable.rateLimitState;
   if (state !== undefined) {
     let now = Date.now();
     if (now >= state.windowStartTime + state.durationMs) {
@@ -93,12 +113,12 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
     }
     if (immediateCount > 0 && isFromQueue) {
       state.queueCount = state.queueCount - immediateCount | 0;
-      Prometheus.EffectQueueCount.set(state.queueCount, effectName);
+      Prometheus.EffectQueueCount.set(state.queueCount, effectName, Internal.EffectCache.scopeToString(inMemTable.scope));
     }
     if (Utils.$$Array.notEmpty(queuedArgs)) {
       if (!isFromQueue) {
         state.queueCount = state.queueCount + queuedArgs.length | 0;
-        Prometheus.EffectQueueCount.set(state.queueCount, effectName);
+        Prometheus.EffectQueueCount.set(state.queueCount, effectName, Internal.EffectCache.scopeToString(inMemTable.scope));
       }
       let millisUntilReset = {
         contents: 0
@@ -128,16 +148,19 @@ function executeWithRateLimit(effect, effectArgs, inMemTable, onError, isFromQue
   return Promise.all(promises);
 }
 
-function loadEffect(loadManager, persistence, effect, effectArgs, indexerState, shouldGroup, item, ecosystem) {
+function loadEffect(loadManager, persistence, effect, effectArgs, scope, indexerState, shouldGroup, item, ecosystem) {
   let effectName = effect.name;
-  let key = effectName + `.effect`;
-  let inMemTable = InMemoryStore.getEffectInMemTable(indexerState, effect);
+  let inMemTable = InMemoryStore.getEffectInMemTable(indexerState, effect, scope);
+  let table = inMemTable.table;
+  let tableName = table.tableName;
+  let key;
+  key = scope === "crossChain" ? effectName + `.effect` : effectName + `.effect.` + scope.toString();
   let load = async (args, onError) => {
     let idsToLoad = args.map(arg => arg.cacheKey);
     let idsFromCache = new Set();
     let match = persistence.storageStatus;
     let tmp;
-    tmp = typeof match !== "object" || match.TAG === "Initializing" ? false : effectName in match._0.cache;
+    tmp = typeof match !== "object" || match.TAG === "Initializing" ? false : tableName in match._0.cache;
     if (tmp) {
       let storage = Persistence.getInitializedStorageOrThrow(persistence);
       let timerRef = Prometheus.StorageLoad.startOperation(storage.name, key);
@@ -149,7 +172,7 @@ function loadEffect(loadManager, persistence, effect, effectArgs, indexerState,
           operator: "in",
           fieldName: Table.idFieldName,
           fieldValue: idsToLoad
-        }, match$1.table);
+        }, table);
       } catch (raw_exn) {
         let exn = Primitive_exceptions.internalToException(raw_exn);
         Logging.childWarn(Ecosystem.getItemLogger(item, ecosystem), {

package/src/LoadLayer.resi

@@ -25,6 +25,7 @@ let loadEffect: (
   ~persistence: Persistence.t,
   ~effect: Internal.effect,
   ~effectArgs: Internal.effectArgs,
+  ~scope: Internal.chainScope,
   ~indexerState: IndexerState.t,
   ~shouldGroup: bool,
   ~item: Internal.item,

package/src/Persistence.res

@@ -6,9 +6,14 @@
 // DbFunctions, Db, Migrations, InMemoryStore modules which use codegen code directly.
 
 // The type reflects an cache table in the db
-// It might be present even if the effect is not used in the application
+// It might be present even if the effect is not used in the application.
+// `initialState.cache` is keyed by `tableName` (the full cache address), so a
+// cross-chain and a chain-scoped cache for the same effect are tracked
+// independently.
 type effectCacheRecord = {
   effectName: string,
+  scope: Internal.chainScope,
+  tableName: string,
   // Number of rows in the table
   mutable count: int,
 }
@@ -40,8 +45,12 @@ type initialState = {
   envioInfo: option<JSON.t>,
 }
 
+// Carries the already-resolved cache address (`table`) rather than an effect +
+// scope: the scope is contextual (resolved per call from the handler's chain),
+// so the write layer only needs the concrete table it targets.
 type updatedEffectCache = {
-  effect: Internal.effect,
+  table: Table.table,
+  itemSchema: S.t<Internal.effectCacheItem>,
   items: array<Internal.effectCacheItem>,
   shouldInitialize: bool,
 }
@@ -112,7 +121,7 @@ type storage = {
   getRollbackData: (
     ~entityConfig: Internal.entityConfig,
     ~rollbackTargetCheckpointId: Internal.checkpointId,
-  ) => promise<(array<{"id": string}>, array<unknown>)>,
+  ) => promise<(array<string>, array<unknown>)>,
   // Write batch to storage
   writeBatch: (
     ~batch: Batch.t,