envio 3.9.0 → 3.10.0

package/src/HandlerRegister.res

@@ -154,6 +154,7 @@ let buildOnEventRegistrationWith = (
       ~isWildcard,
       ~handler,
       ~contractRegister,
+      ~where,
       ~fieldSelection?,
       ~startBlock?,
     ) :> Internal.onEventRegistration)
@@ -320,7 +321,7 @@ let addOnEventRegistration = (
       )
     | Fuel =>
       JsError.throwWithMessage(
-        `The fields option of the "${eventName}" event registration on contract "${contractName}" is only supported on EVM. Select the fields in your config instead.`,
+        `The fields option of the "${eventName}" event registration on contract "${contractName}" is not supported on Fuel. Select the fields in your config instead.`,
       )
     }
   }
@@ -335,6 +336,21 @@ let addOnEventRegistration = (
       | None => ()
       | Some(eventConfig) =>
         matched := true
+        switch (registration.config.ecosystem.name, fieldSelection) {
+        | (Svm, Some(fieldSelection)) if fieldSelection.instructionFields->Utils.Set.has("args") =>
+          let svmEventConfig =
+            eventConfig->(Utils.magic: Internal.eventConfig => Internal.svmInstructionEventConfig)
+          let declaresArgs = switch svmEventConfig.args {
+          | JSON.Array(args) => args->Array.length > 0
+          | _ => false
+          }
+          if !declaresArgs {
+            JsError.throwWithMessage(
+              `Invalid "args" field in the fields.instruction option of the "${eventName}" instruction on program "${contractName}". The instruction declares no args in config.yaml, so there is nothing to decode. Remove "args" from the selection, or declare the instruction's args.`,
+            )
+          }
+        | _ => ()
+        }
         let reg = buildOnEventRegistrationWith(
           ~config=registration.config,
           ~chainId=chainConfig.id,
@@ -359,17 +375,18 @@ let addOnEventRegistration = (
   if !matched.contents {
     let (contractNames, eventNames) = registration->describeConfigured(~contractName)
     let listOr = (names, empty) =>
-      names->Utils.Array.isEmpty ? empty : names->Array.joinUnsafe(", ")
+      names->Utils.Array.isEmpty ? empty : names->Utils.Array.quotedJoin
+    let {contractNoun, eventNoun} = registration.config.ecosystem
     if eventNames->Utils.Array.isEmpty {
       JsError.throwWithMessage(
-        `Contract "${contractName}" is not configured on any chain, so its handler for "${eventName}" would never run. Add it to your config, or remove the registration. Configured contracts: ${listOr(
+        `${contractNoun->Utils.String.capitalize} "${contractName}" is not configured on any chain, so its handler for "${eventName}" would never run. Add it to your config, or remove the registration. Configured ${contractNoun}s: ${listOr(
             contractNames,
             "none",
           )}.`,
       )
     } else {
       JsError.throwWithMessage(
-        `Event "${eventName}" is not configured on contract "${contractName}", so its handler would never run. Add it to your config, or remove the registration. Configured events on "${contractName}": ${listOr(
+        `${eventNoun->Utils.String.capitalize} "${eventName}" is not configured on ${contractNoun} "${contractName}", so its handler would never run. Add it to your config, or remove the registration. Configured ${eventNoun}s on "${contractName}": ${listOr(
             eventNames,
             "none",
           )}.`,

package/src/HandlerRegister.res.mjs

@@ -102,7 +102,7 @@ function buildOnEventRegistrationWith(config, chainId, eventConfig, isWildcard,
     case "fuel" :
       return EventConfigBuilder.buildFuelOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, startBlock);
     case "svm" :
-      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, fieldSelection, startBlock);
+      return EventConfigBuilder.buildSvmOnEventRegistration(eventConfig, isWildcard, handler, contractRegister, where, fieldSelection, startBlock);
   }
 }
 
@@ -209,7 +209,7 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
         fieldSelection = EventConfigBuilder.resolveInlineFieldSelection(fields$1, contractName, eventName, registration.config.enableRawEvents);
         break;
       case "fuel" :
-        fieldSelection = Stdlib_JsError.throwWithMessage(`The fields option of the "` + eventName + `" event registration on contract "` + contractName + `" is only supported on EVM. Select the fields in your config instead.`);
+        fieldSelection = Stdlib_JsError.throwWithMessage(`The fields option of the "` + eventName + `" event registration on contract "` + contractName + `" is not supported on Fuel. Select the fields in your config instead.`);
         break;
       case "svm" :
         fieldSelection = EventConfigBuilder.resolveSvmInlineFieldSelection(fields$1, contractName, eventName);
@@ -231,6 +231,22 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
       return;
     }
     matched.contents = true;
+    let match = registration.config.ecosystem.name;
+    switch (match) {
+      case "evm" :
+      case "fuel" :
+        break;
+      case "svm" :
+        if (fieldSelection !== undefined && fieldSelection.instructionFields.has("args")) {
+          let args = eventConfig.args;
+          let declaresArgs;
+          declaresArgs = Array.isArray(args) ? args.length !== 0 : false;
+          if (!declaresArgs) {
+            Stdlib_JsError.throwWithMessage(`Invalid "args" field in the fields.instruction option of the "` + eventName + `" instruction on program "` + contractName + `". The instruction declares no args in config.yaml, so there is nothing to decode. Remove "args" from the selection, or declare the instruction's args.`);
+          }
+        }
+        break;
+    }
     let reg = buildOnEventRegistrationWith(registration.config, chainConfig.id, eventConfig, isWildcard, handler, contractRegister, where, fieldSelection, contract.startBlock);
     getChainRegistrations(registration, chainConfig.id).onEventRegistrations.push(reg);
   });
@@ -243,13 +259,16 @@ function addOnEventRegistration(registration, contractName, eventName, handler,
     if (Utils.$$Array.isEmpty(names)) {
       return empty;
     } else {
-      return names.join(", ");
+      return Utils.$$Array.quotedJoin(names);
     }
   };
+  let match$2 = registration.config.ecosystem;
+  let eventNoun = match$2.eventNoun;
+  let contractNoun = match$2.contractNoun;
   if (Utils.$$Array.isEmpty(eventNames)) {
-    return Stdlib_JsError.throwWithMessage(`Contract "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured contracts: ` + listOr(match$1[0], "none") + `.`);
+    return Stdlib_JsError.throwWithMessage(Utils.$$String.capitalize(contractNoun) + ` "` + contractName + `" is not configured on any chain, so its handler for "` + eventName + `" would never run. Add it to your config, or remove the registration. Configured ` + contractNoun + `s: ` + listOr(match$1[0], "none") + `.`);
   } else {
-    return Stdlib_JsError.throwWithMessage(`Event "` + eventName + `" is not configured on contract "` + contractName + `", so its handler would never run. Add it to your config, or remove the registration. Configured events on "` + contractName + `": ` + listOr(eventNames, "none") + `.`);
+    return Stdlib_JsError.throwWithMessage(Utils.$$String.capitalize(eventNoun) + ` "` + eventName + `" is not configured on ` + contractNoun + ` "` + contractName + `", so its handler would never run. Add it to your config, or remove the registration. Configured ` + eventNoun + `s on "` + contractName + `": ` + listOr(eventNames, "none") + `.`);
   }
 }
 

package/src/InMemoryStore.res

@@ -127,15 +127,15 @@ let dropCommittedEffects = (
 
 let prepareRollbackDiff = async (
   state: IndexerState.t,
-  ~rollbackTargetCheckpointId,
+  ~floors: RollbackFloors.t,
   ~rollbackDiffCheckpointId,
-  ~progressBlockNumberByChainId,
+  ~progressedChains,
   ~rolledBackAddresses,
 ) => {
   state->IndexerState.beginRollbackDiff(
-    ~targetCheckpointId=rollbackTargetCheckpointId,
     ~diffCheckpointId=rollbackDiffCheckpointId,
-    ~progressBlockNumberByChainId,
+    ~floors,
+    ~progressedChains,
     ~rolledBackAddresses,
   )
   let persistence = state->IndexerState.persistence
@@ -152,7 +152,7 @@ let prepareRollbackDiff = async (
   ->Array.map(async entityConfig => {
     let (removals, restoredEntities) = await persistence.storage.getRollbackData(
       ~entityConfig,
-      ~rollbackTargetCheckpointId,
+      ~floors,
     )
 
     removals->Array.forEach(({entityId, scope}: Persistence.rollbackRemoval) => {
@@ -215,7 +215,8 @@ let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
         }
       }
 
-      batch.registeredAddresses->Array.pushMany(
+      batch.registeredAddresses
+      ->Array.pushMany(
         chainState
         ->ChainState.drainAddressesForWrite(
           ~toBlockInclusive=progressedChain.progressBlockNumber,
@@ -230,7 +231,8 @@ let setBatchDcs = (state: IndexerState.t, ~batch: Batch.t) => {
           },
           checkpointId: checkpointIds->Array.getUnsafe(dc.checkpointIdx),
         }),
-      )->ignore
+      )
+      ->ignore
     }
   })
 }

package/src/InMemoryStore.res.mjs

@@ -106,14 +106,14 @@ function dropCommittedEffects(inMemTable, committedCheckpointId, keepLoadedFromD
   inMemTable.changesCount = inMemTable.changesCount - keysToDelete.length;
 }
 
-async function prepareRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses) {
-  IndexerState.beginRollbackDiff(state, rollbackTargetCheckpointId, rollbackDiffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses);
+async function prepareRollbackDiff(state, floors, rollbackDiffCheckpointId, progressedChains, rolledBackAddresses) {
+  IndexerState.beginRollbackDiff(state, rollbackDiffCheckpointId, floors, progressedChains, rolledBackAddresses);
   let persistence = IndexerState.persistence(state);
   let committedCheckpointId = IndexerState.committedCheckpointId(state);
   let deletedEntities = {};
   let setEntities = {};
   await Promise.all(persistence.allEntities.filter(entityConfig => entityConfig.storage.postgres).map(async entityConfig => {
-    let match = await persistence.storage.getRollbackData(entityConfig, rollbackTargetCheckpointId);
+    let match = await persistence.storage.getRollbackData(entityConfig, floors);
     match[0].forEach(param => {
       let entityId = param.entityId;
       Utils.Dict.push(deletedEntities, entityConfig.name, entityId);

package/src/IndexerState.res

@@ -355,7 +355,10 @@ let getChainState = (state: t, ~chainId: ChainId.t): ChainState.t =>
     )
   }
 
-let getSafeCheckpointId = (state: t) => state.crossChainState->CrossChainState.getSafeCheckpointId
+let getSafeCheckpointIdByChain = (state: t) =>
+  state.crossChainState->CrossChainState.getSafeCheckpointIdByChain(
+    ~committedCheckpointId=state.committedCheckpointId,
+  )
 
 let createBatch = (
   state: t,
@@ -452,7 +455,14 @@ let entities = (state: t) => state.entities
 // Every in-memory entity table across all scopes, cross-chain first. The size,
 // drop and flush passes walk the whole store this way instead of assuming a
 // single partition.
-let eachEntityTable = (state: t, fn: (~entityConfig: Internal.entityConfig, ~scope: Internal.chainScope, ~table: InMemoryTable.Entity.t) => unit) => {
+let eachEntityTable = (
+  state: t,
+  fn: (
+    ~entityConfig: Internal.entityConfig,
+    ~scope: Internal.chainScope,
+    ~table: InMemoryTable.Entity.t,
+  ) => unit,
+) => {
   let chainStates = state.crossChainState->CrossChainState.chainStates
   state.allEntities->Array.forEach(entityConfig =>
     if entityConfig.crossChain {
@@ -516,6 +526,7 @@ let toMetrics = (state: t): Metrics.t => {
   let chainStates = state.crossChainState->CrossChainState.chainStates
   let sourceRequests = []
   let sourceHeights = []
+  let sourceHeightStreams = []
   chainStates->Utils.Dict.forEach(cs => {
     let sourceManager = cs->ChainState.sourceManager
     sourceManager
@@ -538,6 +549,16 @@ let toMetrics = (state: t): Metrics.t => {
         height: s.height,
       })
     )
+    sourceManager
+    ->SourceManager.getHeightStreamSamples
+    ->Array.forEach(s =>
+      sourceHeightStreams->Array.push({
+        Metrics.source: s.sourceName,
+        chainId: s.chainId,
+        connectCount: s.stream.connectCount,
+        disconnectsByReason: s.stream.disconnectsByReason,
+      })
+    )
   })
   let historyPrunes = []
   state.historyPruneStats->Utils.Dict.forEachWithKey((s, entityName) =>
@@ -600,6 +621,7 @@ let toMetrics = (state: t): Metrics.t => {
     historyPrunes,
     sourceRequests,
     sourceHeights,
+    sourceHeightStreams,
   }
 }
 
@@ -793,6 +815,8 @@ let drainBatchRun = (state: t): Batch.t => {
   }
 }
 
+let pendingRollback = (state: t): option<Persistence.rollback> => state.rollback
+
 // Take the pending rollback diff to write, clearing it from the store.
 let takeRollback = (state: t): option<Persistence.rollback> => {
   let rollback = state.rollback
@@ -812,9 +836,9 @@ let markCommitted = (state: t, ~upToCheckpointId) => {
 // Reset the in-memory tables and arm the rollback diff that the next write commits.
 let beginRollbackDiff = (
   state: t,
-  ~targetCheckpointId,
   ~diffCheckpointId,
-  ~progressBlockNumberByChainId,
+  ~floors,
+  ~progressedChains: array<InternalTable.Chains.progressedChain>,
   ~rolledBackAddresses,
 ) => {
   let perChainEntities = state.allEntities->EntityTables.perChain
@@ -829,10 +853,23 @@ let beginRollbackDiff = (
   | Some({rolledBackAddresses: pending}) => pending->Array.concat(rolledBackAddresses)
   | None => rolledBackAddresses
   }
+  // Same for the chains: this rollback recomputes progress from the checkpoints,
+  // so a chain the pending diff already moved can land on exactly the block it
+  // is now at and go unreported here. Its stored progress still needs
+  // correcting, so the pending rows carry over — this rollback's row for a
+  // chain wins, being the later reading of the same chain state.
+  let progressedChains = switch state.rollback {
+  | Some({progressedChains: pending}) =>
+    let byChainId = Dict.make()
+    pending->Array.forEach(chain => byChainId->ChainId.Dict.set(chain.chainId, chain))
+    progressedChains->Array.forEach(chain => byChainId->ChainId.Dict.set(chain.chainId, chain))
+    byChainId->Dict.valuesToArray
+  | None => progressedChains
+  }
   state.rollback = Some({
-    targetCheckpointId,
     diffCheckpointId,
-    progressBlockNumberByChainId,
+    floors,
+    progressedChains,
     rolledBackAddresses,
   })
 }

package/src/IndexerState.res.mjs

@@ -159,8 +159,8 @@ function getChainState(state, chainId) {
   }
 }
 
-function getSafeCheckpointId(state) {
-  return CrossChainState.getSafeCheckpointId(state.crossChainState);
+function getSafeCheckpointIdByChain(state) {
+  return CrossChainState.getSafeCheckpointIdByChain(state.crossChainState, state.committedCheckpointId);
 }
 
 function createBatch(state, processedCheckpointId, batchSizeTarget, isRollback) {
@@ -392,6 +392,7 @@ function toMetrics(state) {
   let chainStates = CrossChainState.chainStates(state.crossChainState);
   let sourceRequests = [];
   let sourceHeights = [];
+  let sourceHeightStreams = [];
   Utils.Dict.forEach(chainStates, cs => {
     let sourceManager = ChainState.sourceManager(cs);
     SourceManager.getRequestStatSamples(sourceManager).forEach(s => {
@@ -410,6 +411,14 @@ function toMetrics(state) {
         height: s.height
       });
     });
+    SourceManager.getHeightStreamSamples(sourceManager).forEach(s => {
+      sourceHeightStreams.push({
+        source: s.sourceName,
+        chainId: s.chainId,
+        connectCount: s.stream.connectCount,
+        disconnectsByReason: s.stream.disconnectsByReason
+      });
+    });
   });
   let historyPrunes = [];
   Utils.Dict.forEachWithKey(state.historyPruneStats, (s, entityName) => {
@@ -464,7 +473,8 @@ function toMetrics(state) {
     })),
     historyPrunes: historyPrunes,
     sourceRequests: sourceRequests,
-    sourceHeights: sourceHeights
+    sourceHeights: sourceHeights,
+    sourceHeightStreams: sourceHeightStreams
   };
 }
 
@@ -658,6 +668,10 @@ function drainBatchRun(state) {
   };
 }
 
+function pendingRollback(state) {
+  return state.rollback;
+}
+
 function takeRollback(state) {
   let rollback = state.rollback;
   state.rollback = undefined;
@@ -668,18 +682,32 @@ function markCommitted(state, upToCheckpointId) {
   state.committedCheckpointId = upToCheckpointId;
 }
 
-function beginRollbackDiff(state, targetCheckpointId, diffCheckpointId, progressBlockNumberByChainId, rolledBackAddresses) {
+function beginRollbackDiff(state, diffCheckpointId, floors, progressedChains, rolledBackAddresses) {
   let perChainEntities = EntityTables.perChain(state.allEntities);
   state.entities = EntityTables.make(EntityTables.crossChain(state.allEntities));
   Utils.Dict.forEach(CrossChainState.chainStates(state.crossChainState), cs => ChainState.resetEntities(cs, perChainEntities));
   EffectState.resetForRollback(state.effectState);
   let match = state.rollback;
   let rolledBackAddresses$1 = match !== undefined ? match.rolledBackAddresses.concat(rolledBackAddresses) : rolledBackAddresses;
+  let match$1 = state.rollback;
+  let progressedChains$1;
+  if (match$1 !== undefined) {
+    let byChainId = {};
+    match$1.progressedChains.forEach(chain => {
+      byChainId[chain.chainId] = chain;
+    });
+    progressedChains.forEach(chain => {
+      byChainId[chain.chainId] = chain;
+    });
+    progressedChains$1 = Object.values(byChainId);
+  } else {
+    progressedChains$1 = progressedChains;
+  }
   state.rollback = {
-    targetCheckpointId: targetCheckpointId,
     diffCheckpointId: diffCheckpointId,
+    floors: floors,
     rolledBackAddresses: rolledBackAddresses$1,
-    progressBlockNumberByChainId: progressBlockNumberByChainId
+    progressedChains: progressedChains$1
   };
 }
 
@@ -766,7 +794,7 @@ export {
   markProcessingStalledOnFetch,
   recordProcessedBatch,
   createBatch,
-  getSafeCheckpointId,
+  getSafeCheckpointIdByChain,
   config,
   persistence,
   allEntities,
@@ -812,6 +840,7 @@ export {
   recordRollbackSuccess,
   queueProcessedBatch,
   drainBatchRun,
+  pendingRollback,
   takeRollback,
   markCommitted,
   beginRollbackDiff,

package/src/IndexerState.resi

@@ -1,7 +1,6 @@
 // The indexer state. `t` is opaque: other modules read it through the accessors
 // and change it only through the transitions and setters exposed here.
 
-
 type rollbackState =
   | NoRollback
   | ReorgDetected({chainId: ChainId.t, blockNumber: int})
@@ -67,7 +66,7 @@ let createBatch: (
   ~batchSizeTarget: int,
   ~isRollback: bool,
 ) => Batch.t
-let getSafeCheckpointId: t => option<Internal.checkpointId>
+let getSafeCheckpointIdByChain: t => array<(ChainId.t, option<Internal.checkpointId>)>
 
 // Accessors.
 let config: t => Config.t
@@ -136,13 +135,14 @@ let recordRollbackSuccess: (t, ~timeSeconds: float, ~rollbackedProcessedEvents:
 // Store domain operations.
 let queueProcessedBatch: (t, ~batch: Batch.t) => unit
 let drainBatchRun: t => Batch.t
+let pendingRollback: t => option<Persistence.rollback>
 let takeRollback: t => option<Persistence.rollback>
 let markCommitted: (t, ~upToCheckpointId: Internal.checkpointId) => unit
 let beginRollbackDiff: (
   t,
-  ~targetCheckpointId: Internal.checkpointId,
   ~diffCheckpointId: Internal.checkpointId,
-  ~progressBlockNumberByChainId: dict<int>,
+  ~floors: RollbackFloors.t,
+  ~progressedChains: array<InternalTable.Chains.progressedChain>,
   ~rolledBackAddresses: array<AddressRows.key>,
 ) => unit
 let recordWriteFailure: (t, exn) => unit

package/src/Internal.res

@@ -573,15 +573,6 @@ type svmInstructionEventConfig = {
   programId: SvmTypes.Pubkey.t,
   /** Hex-encoded discriminator. `None` matches every instruction in the program. */
   discriminator: option<string>,
-  /** Length of the discriminator in bytes (0 / 1 / 2 / 4 / 8). Drives the
-   `dN` selector at query time and the dispatch-key precomputation in the
-   router. */
-  discriminatorByteLen: int,
-  /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
-   AND across positions. Empty outer array means "no account filter". */
-  accountFilters: array<svmAccountFilterGroup>,
-  /** `None` matches both outer and inner (CPI-invoked) instructions. */
-  isInner: option<bool>,
   /** Positional account names from the Borsh schema, in declared order.
    `[]` means no schema is attached for this instruction. */
   accounts: array<string>,
@@ -597,10 +588,11 @@ type svmInstructionEventConfig = {
 // Per-(event, chain) registration produced when user handler code registers an
 // event (`onEvent`) or a dynamic contract registers. References its definition
 // by value as `.eventConfig` and adds the handler binding plus the
-// registration/`where`-derived fetch state. Not `private`: Fuel/SVM
-// registrations add no ecosystem-specific fields (so they're bare aliases that
-// must stay directly constructable), and the evm→base cast in sources is sound
-// by ecosystem homogeneity — an EVM chain only ever holds `evmOnEventRegistration`s.
+// registration/`where`-derived fetch state. Not `private`: Fuel registrations
+// add no ecosystem-specific fields (so the alias must stay directly
+// constructable), and the ecosystem→base casts in sources are sound by
+// ecosystem homogeneity — an EVM chain only ever holds
+// `evmOnEventRegistration`s.
 type onEventRegistration = {
   // Chain-scoped sequential index — the registration's position in the
   // chain's onEventRegistrations array, assigned when registration finishes
@@ -639,11 +631,18 @@ type evmOnEventRegistration = {
   resolvedWhere: resolvedWhere,
 }
 
-// Fuel and SVM registrations add no ecosystem-specific fetch state (their
-// filters are config-derived and live on the definition), so they're bare
-// aliases of the base registration.
+// Fuel registrations add no ecosystem-specific fetch state, so it's a bare
+// alias of the base registration.
 type fuelOnEventRegistration = onEventRegistration
-type svmOnEventRegistration = onEventRegistration
+
+type svmOnEventRegistration = {
+  ...onEventRegistration,
+  /** Disjunctive normal form: outer array is OR of AND-groups, inner array is
+   AND across positions. Empty outer array means "no account filter". */
+  accountFilters: array<svmAccountFilterGroup>,
+  /** `None` matches both outer and inner (CPI-invoked) instructions. */
+  isInner: option<bool>,
+}
 
 type svmProgramConfig = {
   name: string,

package/src/Metrics.res

@@ -98,6 +98,13 @@ type sourceHeightMetrics = {
   height: int,
 }
 
+type sourceHeightStreamMetrics = {
+  source: string,
+  chainId: ChainId.t,
+  connectCount: int,
+  disconnectsByReason: array<(string, int)>,
+}
+
 type t = {
   startTime: Date.t,
   // Wall clock when this snapshot was built, so a scrape can be dated.
@@ -124,6 +131,7 @@ type t = {
   historyPrunes: array<historyPruneMetrics>,
   sourceRequests: array<sourceRequestMetrics>,
   sourceHeights: array<sourceHeightMetrics>,
+  sourceHeightStreams: array<sourceHeightStreamMetrics>,
 }
 
 // Prometheus floats keep at most 3 decimals; integral values render without a
@@ -220,13 +228,23 @@ let renderMetrics = (b: builder, metrics: t) => {
     metrics.storageWrites->Array.map(s => (`{storage="${s.storage->escapeLabelValue}"}`, s))
   let historyPrunes =
     metrics.historyPrunes->Array.map(s => (`{entity="${s.entity->escapeLabelValue}"}`, s))
+  // Every per-source series shares this label set: a scrape whose labels
+  // disagree between two of them is one nothing can join on.
+  let sourceLabels = (~source, ~chainId, ~extra: option<(string, string)>=?) => {
+    let pair = `{source="${source->escapeLabelValue}",chainId="${chainId->ChainId.toString}"`
+    switch extra {
+    | Some((name, value)) => `${pair},${name}="${value->escapeLabelValue}"}`
+    | None => pair ++ "}"
+    }
+  }
+
   // Two sources can share a name (e.g. primary and fallback RPC urls on the
   // same host), so aggregate by label set — duplicate samples would make
   // Prometheus reject the scrape.
   let sourceRequests = {
     let byLabels: dict<sourceRequestMetrics> = Dict.make()
     metrics.sourceRequests->Array.forEach(s => {
-      let labels = `{source="${s.source->escapeLabelValue}",chainId="${s.chainId->ChainId.toString}",method="${s.method->escapeLabelValue}"}`
+      let labels = sourceLabels(~source=s.source, ~chainId=s.chainId, ~extra=("method", s.method))
       switch byLabels->Utils.Dict.dangerouslyGetNonOption(labels) {
       | Some(existing) =>
         byLabels->Dict.set(
@@ -241,7 +259,7 @@ let renderMetrics = (b: builder, metrics: t) => {
   let sources = {
     let byLabels: dict<int> = Dict.make()
     metrics.sourceHeights->Array.forEach(s => {
-      let labels = `{source="${s.source->escapeLabelValue}",chainId="${s.chainId->ChainId.toString}"}`
+      let labels = sourceLabels(~source=s.source, ~chainId=s.chainId)
       switch byLabels->Utils.Dict.dangerouslyGetNonOption(labels) {
       | Some(existing) if existing >= s.height => ()
       | _ => byLabels->Dict.set(labels, s.height)
@@ -250,6 +268,34 @@ let renderMetrics = (b: builder, metrics: t) => {
     byLabels->Dict.toArray
   }
 
+  // Zero connects is the one count worth rendering flat: it is a stream that
+  // has never come up, which the disconnects say nothing about — retries at a
+  // connection that never opened are not disconnections — and which is
+  // otherwise indistinguishable from a chain that was never configured to
+  // stream at all.
+  let heightStreamConnects = {
+    let byLabels: dict<int> = Dict.make()
+    metrics.sourceHeightStreams->Array.forEach(s =>
+      byLabels->Utils.Dict.incrementBy(
+        sourceLabels(~source=s.source, ~chainId=s.chainId),
+        s.connectCount,
+      )
+    )
+    byLabels->Dict.toArray
+  }
+  let heightStreamDisconnects = {
+    let byLabels: dict<int> = Dict.make()
+    metrics.sourceHeightStreams->Array.forEach(s =>
+      s.disconnectsByReason->Array.forEach(((reason, count)) =>
+        byLabels->Utils.Dict.incrementBy(
+          sourceLabels(~source=s.source, ~chainId=s.chainId, ~extra=("reason", reason)),
+          count,
+        )
+      )
+    )
+    byLabels->Dict.toArray
+  }
+
   b->single(
     ~name="envio_process_start_time_seconds",
     ~help="Start time of the process since unix epoch in seconds.",
@@ -463,6 +509,24 @@ let renderMetrics = (b: builder, metrics: t) => {
     ~entries=sourceRequests,
     ~value=s => s.seconds !== 0. ? Some(s.seconds) : None,
   )
+  if heightStreamConnects->Array.length > 0 {
+    b->series(
+      ~name="envio_source_height_stream_connects_total",
+      ~help="The number of times a source's height subscription connected. Compare against the disconnects total, which is absent until the first disconnect and counts as zero while it is: one more connect than disconnects means the stream is up, and equal counts mean it is down and the indexer is polling instead. Zero connects means the stream has not come up, which is the normal reading for a chain that is still backfilling: subscriptions are only opened once a chain reaches the head.",
+      ~kind="counter",
+      ~entries=heightStreamConnects,
+      ~value=count => count->Int.toFloat,
+    )
+  }
+  if heightStreamDisconnects->Array.length > 0 {
+    b->series(
+      ~name="envio_source_height_stream_disconnects_total",
+      ~help="The number of times a source's height subscription lost a connection, by reason. Failed retries are not counted, so this is outages rather than their length. A rotated disconnect is a connection that served its time; unsubscribed is the source being benched; every other reason ended a connection early.",
+      ~kind="counter",
+      ~entries=heightStreamDisconnects,
+      ~value=count => count->Int.toFloat,
+    )
+  }
   b->series(
     ~name="envio_source_known_height",
     ~help="The latest known block number reported by the source. This value may lag behind the actual chain height, as it is updated only when queried.",
@@ -706,10 +770,12 @@ let renderMetrics = (b: builder, metrics: t) => {
     ~help="The number of address registrations per contract on chain, static and dynamic. An address shared by N contracts counts N times.",
     ~kind="gauge",
     ~entries=metrics.chains->Array.flatMap(m =>
-      m.addressesByContract->Array.map(((contract, count)) => (
-        `{chainId="${m.chainId->ChainId.toString}",contract="${contract->escapeLabelValue}"}`,
-        count,
-      ))
+      m.addressesByContract->Array.map(
+        ((contract, count)) => (
+          `{chainId="${m.chainId->ChainId.toString}",contract="${contract->escapeLabelValue}"}`,
+          count,
+        ),
+      )
     ),
     ~value=count => count->Int.toFloat,
   )