envio 3.13.0-alpha.0 → 3.13.0

package/src/CrossChainState.res.mjs

@@ -125,9 +125,13 @@ function isReadyToEnterReorgThreshold(crossChainState, batch) {
 }
 
 function enterReorgThreshold(crossChainState) {
-  Logging.info("Reorg threshold reached");
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
-    ChainState.enterReorgThreshold(crossChainState.chainStates[crossChainState.chainIds[i]]);
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    let liftsCeiling = ChainState.reorgThresholdLiftsCeiling(cs);
+    ChainState.enterReorgThreshold(cs);
+    if (liftsCeiling) {
+      Logging.childInfo(ChainState.logger(cs), ChainState.reorgThresholdEntryMessage);
+    }
   }
 }
 
@@ -137,7 +141,7 @@ function applyBatchProgress(crossChainState, batch, blockTimestampName) {
   for (let i = 0, i_finish = chainIds.length; i < i_finish; ++i) {
     let cs = crossChainState.chainStates[chainIds[i]];
     ChainState.applyBatchProgress(cs, batch, blockTimestampName);
-    if (!(ChainState.hasProcessedToEndblock(cs) || ChainState.isProgressAtHead(cs))) {
+    if (!ChainState.hasCaughtUp(cs)) {
       everyChainCaughtUp = false;
     }
   }
@@ -165,7 +169,7 @@ function markCaughtUpOnResume(crossChainState) {
   let everyChainCaughtUp = crossChainState.chainIds.length !== 0;
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
     let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
-    if (!ChainState.isDurablyCaughtUp(cs)) {
+    if (!ChainState.hasCaughtUp(cs)) {
       everyChainCaughtUp = false;
     }
   }
@@ -177,11 +181,49 @@ function markCaughtUpOnResume(crossChainState) {
 
 function markReady(crossChainState, readyAt) {
   for (let i = 0, i_finish = crossChainState.chainIds.length; i < i_finish; ++i) {
-    ChainState.markReady(crossChainState.chainStates[crossChainState.chainIds[i]], readyAt);
+    let cs = crossChainState.chainStates[crossChainState.chainIds[i]];
+    let wasReady = ChainState.isReady(cs);
+    ChainState.markReady(cs, readyAt);
+    if (!wasReady) {
+      Logging.childInfo(ChainState.logger(cs), "Ready. Fully indexed for queries.");
+    }
   }
   crossChainState.isRealtime = true;
 }
 
+function isWaitingOnOthers(crossChainState, cs) {
+  if (crossChainState.holdRealtime) {
+    return true;
+  } else {
+    return Object.values(crossChainState.chainStates).some(other => {
+      if (other !== cs) {
+        return !ChainState.hasCaughtUp(other);
+      } else {
+        return false;
+      }
+    });
+  }
+}
+
+function reportFinished(crossChainState) {
+  Object.values(crossChainState.chainStates).forEach(cs => {
+    let match = ChainState.takeFinished(cs);
+    if (match !== undefined) {
+      if (match.TAG === "EndBlock") {
+        return Logging.childInfo(ChainState.logger(cs), {
+          msg: "Indexed to the end block. This chain is done.",
+          block: match._0
+        });
+      } else {
+        return Logging.childInfo(ChainState.logger(cs), {
+          msg: isWaitingOnOthers(crossChainState, cs) ? "Finished backfill. Waiting for the other chains." : "Finished backfill.",
+          block: match._0
+        });
+      }
+    }
+  });
+}
+
 function priorityOrder(crossChainState) {
   return Object.values(crossChainState.chainStates).toSorted((a, b) => Primitive_float.compare(ChainState.frontierProgress(a), ChainState.frontierProgress(b)));
 }
@@ -296,6 +338,7 @@ export {
   markCaughtUpIfSettled,
   markCaughtUpOnResume,
   markReady,
+  reportFinished,
   priorityOrder,
   checkAndFetch,
 }

package/src/CrossChainState.resi

@@ -40,6 +40,7 @@ let applyBatchProgress: (t, ~batch: Batch.t, ~blockTimestampName: string) => uni
 let markCaughtUpIfSettled: t => unit
 let markCaughtUpOnResume: t => unit
 let markReady: (t, ~readyAt: Date.t) => unit
+let reportFinished: t => unit
 
 // Fetch control.
 let priorityOrder: t => array<ChainState.t>

package/src/Env.res

@@ -129,8 +129,8 @@ module Db = {
   )
   // The budget for the whole run, not for one process: a run that splits across
   // workers divides it among them, and each caps its own pool to its share.
-  // The default buys a single worker, so a run splits only once the operator
-  // raises the budget it may spend.
+  // Splitting takes two workers and a worker takes two connections, so a budget
+  // under 4 — the default among them — keeps the run in one process.
   let maxConnections = envSafe->EnvSafe.get("ENVIO_PG_MAX_CONNECTIONS", S.int, ~fallback=2)
 }
 

package/src/ErrorHandling.res

@@ -11,14 +11,25 @@ let log = (self: t) => {
   }
 }
 
+// The exception to hand to whoever is outside the indexer. A failure raised
+// from a message alone carries no exception of its own, so rethrowing or
+// rejecting with `exn` would hand over a bare `null` and the reason would live
+// only in the logs. Fall back to the message, which is the whole of what such a
+// failure knows.
+let toExn = (self: t) =>
+  switch self.exn->(Utils.magic: exn => Nullable.t<exn>)->Nullable.toOption {
+  | Some(exn) => exn->Utils.prettifyExn
+  | None => Utils.Error.make(self.msg->Option.getOr("Indexer has failed with an unexpected error"))
+  }
+
 let raiseExn = (self: t) => {
-  self.exn->Utils.prettifyExn->throw
+  self->toExn->throw
 }
 
 let mkLogAndRaise = (~logger=?, ~msg=?, exn) => {
-  let exn = exn->Utils.prettifyExn
-  exn->make(~logger?, ~msg?)->log
-  exn->throw
+  let self = exn->Utils.prettifyExn->make(~logger?, ~msg?)
+  self->log
+  self->raiseExn
 }
 
 let unwrapLogAndRaise = (~logger=?, ~msg=?, result) => {

package/src/ErrorHandling.res.mjs

@@ -2,6 +2,7 @@
 
 import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 function make(exn, loggerOpt, msg) {
   let logger = loggerOpt !== undefined ? loggerOpt : Logging.getLogger();
@@ -23,14 +24,23 @@ function log(self) {
   }
 }
 
+function toExn(self) {
+  let exn = self.exn;
+  if (exn == null) {
+    return new Error(Stdlib_Option.getOr(self.msg, "Indexer has failed with an unexpected error"));
+  } else {
+    return Utils.prettifyExn(exn);
+  }
+}
+
 function raiseExn(self) {
-  throw Utils.prettifyExn(self.exn);
+  throw toExn(self);
 }
 
 function mkLogAndRaise(logger, msg, exn) {
-  let exn$1 = Utils.prettifyExn(exn);
-  log(make(exn$1, logger, msg));
-  throw exn$1;
+  let self = make(Utils.prettifyExn(exn), logger, msg);
+  log(self);
+  throw toExn(self);
 }
 
 function unwrapLogAndRaise(logger, msg, result) {
@@ -43,12 +53,13 @@ function unwrapLogAndRaise(logger, msg, result) {
 
 function logAndRaise(self) {
   log(self);
-  throw Utils.prettifyExn(self.exn);
+  throw toExn(self);
 }
 
 export {
   make,
   log,
+  toExn,
   raiseExn,
   mkLogAndRaise,
   unwrapLogAndRaise,

package/src/FinalizeBackfill.res

@@ -11,9 +11,25 @@
 // `envio start --chain` process is indexing and never waits on one.
 
 let runOnce = async (state: IndexerState.t) => {
-  Logging.info(
-    "All chains are caught up. Finalizing the indexer before switching to realtime: flushing pending writes, then creating the indexes the schema promises.",
-  )
+  let chainIds = state->IndexerState.crossChainState->CrossChainState.chainIds
+
+  // Whatever brought the process here — a batch, a tick that progressed
+  // nothing, a supervisor's release — its chains say where they finished
+  // before it says what it does about that. Said here rather than left to each
+  // caller to order: a chain that has already spoken says nothing again.
+  state->IndexerState.reportFinished
+
+  // Said by the process rather than by each of its chains: the indexes are one
+  // build over the tables, and the pause is the whole process's. A chain has
+  // already said it caught up, and says it is ready once this commits. The
+  // chains are named because the pause is theirs, and a split run has a process
+  // saying this for each part of it — one of them, for a process driving a
+  // single chain.
+  let msg = "Building database indexes. Indexing is paused until they are ready, which can take a while on a large database."
+  switch chainIds {
+  | [chainId] => Logging.info({"msg": msg, "chainId": chainId})
+  | chainIds => Logging.info({"msg": msg, "chainIds": chainIds})
+  }
 
   await Writing.flush(state)
 
@@ -24,16 +40,12 @@ let runOnce = async (state: IndexerState.t) => {
     let storage = persistence->Persistence.getInitializedStorageOrThrow
     let readyAt = Date.make()
 
-    await storage.finalizeBackfill(
-      ~entities=persistence.allEntities,
-      ~chainIds=state->IndexerState.crossChainState->CrossChainState.chainIds,
-      ~readyAt,
-    )
+    await storage.finalizeBackfill(~entities=persistence.allEntities, ~chainIds, ~readyAt)
 
     // Only after the commit: in-memory readiness must never run ahead of the
     // `ready_at` a restart would read back.
+    // Says so per chain, which is the grain `ready_at` is committed at.
     state->IndexerState.markReady(~readyAt)
-    Logging.info("The indexer is ready. Switching to realtime indexing.")
   }
 }
 

package/src/FinalizeBackfill.res.mjs

@@ -7,7 +7,21 @@ import * as IndexerState from "./IndexerState.res.mjs";
 import * as CrossChainState from "./CrossChainState.res.mjs";
 
 async function runOnce(state) {
-  Logging.info("All chains are caught up. Finalizing the indexer before switching to realtime: flushing pending writes, then creating the indexes the schema promises.");
+  let chainIds = CrossChainState.chainIds(IndexerState.crossChainState(state));
+  IndexerState.reportFinished(state);
+  let msg = "Building database indexes. Indexing is paused until they are ready, which can take a while on a large database.";
+  if (chainIds.length !== 1) {
+    Logging.info({
+      msg: msg,
+      chainIds: chainIds
+    });
+  } else {
+    let chainId = chainIds[0];
+    Logging.info({
+      msg: msg,
+      chainId: chainId
+    });
+  }
   await Writing.flush(state);
   if (IndexerState.hasFailedWrite(state)) {
     return;
@@ -15,9 +29,8 @@ async function runOnce(state) {
   let persistence = IndexerState.persistence(state);
   let storage = Persistence.getInitializedStorageOrThrow(persistence);
   let readyAt = new Date();
-  await storage.finalizeBackfill(persistence.allEntities, CrossChainState.chainIds(IndexerState.crossChainState(state)), readyAt);
-  IndexerState.markReady(state, readyAt);
-  return Logging.info("The indexer is ready. Switching to realtime indexing.");
+  await storage.finalizeBackfill(persistence.allEntities, chainIds, readyAt);
+  return IndexerState.markReady(state, readyAt);
 }
 
 function run(state) {

package/src/HandlerRegister.res

@@ -493,41 +493,6 @@ let getSimulateOnEventRegistrations = (
   }
 }
 
-// An RPC source can only deliver the fields it knows how to parse; the rest are
-// silently skipped at materialisation. Every RPC on the chain counts, whatever
-// it's for — a fallback or realtime source runs the same parsers as a sync one,
-// so a field it can't deliver would go missing for whichever blocks it served.
-// The selection can come from either `config.yaml` or the inline `fields`
-// option, so the message names neither. Runs on the registrations a chain
-// actually keeps, so a handler whose `where` opts out of this chain isn't held
-// to its limits.
-//
-// The `config.yaml` half of this is also rejected at codegen, by the
-// `RpcTransactionField` subenum in `system_config.rs`. That one reports every
-// offending field at once and before the project builds; this one is the only
-// check an inline selection reaches. `RpcFieldSelection_test.res` pins the two
-// to the same field set.
-let validateRpcFieldSelection = (
-  chainConfig: Config.chain,
-  registrations: array<Internal.onEventRegistration>,
-) => {
-  let hasRpc = switch chainConfig.sourceConfig {
-  | EvmSourceConfig({rpcs}) => !(rpcs->Utils.Array.isEmpty)
-  | _ => false
-  }
-  if hasRpc {
-    registrations->Array.forEach(reg =>
-      reg.fieldSelection.transactionFields->Utils.Set.forEach(name =>
-        if !RpcSource.isRpcTransactionField(name) {
-          JsError.throwWithMessage(
-            `The "${name}" transaction field selected for the "${reg.eventConfig.name}" event on contract "${reg.eventConfig.contractName}" is unavailable for indexing via RPC. Remove it from the field selection, or remove chain ${chainConfig.id->ChainId.toString}'s RPC source — even an RPC the chain only falls back to has to deliver the selection.`,
-          )
-        }
-      )
-    )
-  }
-}
-
 let finishRegistration = (~config: Config.t): registrationsByChainId => {
   switch getActiveRegistration() {
   | Some(r) => {
@@ -614,8 +579,6 @@ let finishRegistration = (~config: Config.t): registrationsByChainId => {
           }
         })
 
-        validateRpcFieldSelection(chainConfig, onEventRegistrations)
-
         registrationsByChainId->Dict.set(
           key,
           {

package/src/HandlerRegister.res.mjs

@@ -5,7 +5,6 @@ import * as ChainId from "./ChainId.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as Internal from "./Internal.res.mjs";
-import * as RpcSource from "./sources/RpcSource.res.mjs";
 import * as EnvioGlobal from "./EnvioGlobal.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
@@ -327,22 +326,6 @@ function getSimulateOnEventRegistrations(config, chainId, eventConfig) {
   }
 }
 
-function validateRpcFieldSelection(chainConfig, registrations) {
-  let match = chainConfig.sourceConfig;
-  let hasRpc;
-  hasRpc = match.TAG === "EvmSourceConfig" ? !Utils.$$Array.isEmpty(match.rpcs) : false;
-  if (hasRpc) {
-    registrations.forEach(reg => {
-      reg.fieldSelection.transactionFields.forEach(name => {
-        if (!RpcSource.isRpcTransactionField(name)) {
-          return Stdlib_JsError.throwWithMessage(`The "` + name + `" transaction field selected for the "` + reg.eventConfig.name + `" event on contract "` + reg.eventConfig.contractName + `" is unavailable for indexing via RPC. Remove it from the field selection, or remove chain ` + ChainId.toString(chainConfig.id) + `'s RPC source — even an RPC the chain only falls back to has to deliver the selection.`);
-        }
-      });
-    });
-    return;
-  }
-}
-
 function finishRegistration(config) {
   let r = EnvioGlobal.value.activeRegistration;
   if (r === undefined) {
@@ -389,7 +372,6 @@ function finishRegistration(config) {
       let newrecord = {...reg};
       onEventRegistrations.push((newrecord.index = onEventRegistrations.length, newrecord));
     });
-    validateRpcFieldSelection(chainConfig, onEventRegistrations);
     let chainRegs = r.registrationsByChainId[key];
     registrationsByChainId[key] = {
       onEventRegistrations: onEventRegistrations,

package/src/IndexerState.res

@@ -544,6 +544,8 @@ let releaseRealtime = (state: t) => {
 
 let markReady = (state: t, ~readyAt) => state.crossChainState->CrossChainState.markReady(~readyAt)
 
+let reportFinished = (state: t) => state.crossChainState->CrossChainState.reportFinished
+
 let rollbackState = (state: t) => state.rollbackState
 let indexerStartTime = (state: t) => state.indexerStartTime
 let loadManager = (state: t) => state.loadManager

package/src/IndexerState.res.mjs

@@ -390,6 +390,10 @@ function markReady(state, readyAt) {
   CrossChainState.markReady(state.crossChainState, readyAt);
 }
 
+function reportFinished(state) {
+  CrossChainState.reportFinished(state.crossChainState);
+}
+
 function rollbackState(state) {
   return state.rollbackState;
 }
@@ -884,6 +888,7 @@ export {
   hasArrivedAtHead,
   releaseRealtime,
   markReady,
+  reportFinished,
   rollbackState,
   indexerStartTime,
   loadManager,

package/src/IndexerState.resi

@@ -104,6 +104,7 @@ let hasArrivedAtHead: t => bool
 // The supervisor's go-ahead for a process driving part of a split run.
 let releaseRealtime: t => unit
 let markReady: (t, ~readyAt: Date.t) => unit
+let reportFinished: t => unit
 let rollbackState: t => rollbackState
 let indexerStartTime: t => Date.t
 let loadManager: t => LoadManager.t

package/src/Logging.res

@@ -26,30 +26,6 @@ let logLevels = [
 
 %%private(let logger = ref(None))
 
-// Fields every line this process logs carries. Merged into each line rather
-// than bound to a child logger: pino writes a child's bindings and the line's
-// own fields side by side, so a line that names the same key would carry it
-// twice. A fresh object per line, since pino merges the line's fields into
-// whatever this returns.
-%%private(let context: ref<dict<JSON.t>> = ref(Dict.make()))
-%%private(let mixin = () => JSON.Object(context.contents->Dict.copy))
-
-// A child logger that binds a field the process already carries would have pino
-// write it twice: a child's bindings and the context are concatenated into the
-// line, not merged. The context is the one place a line names it, which it can
-// be because a process only takes one when its every line is about that chain.
-%%private(
-  let withoutContext = (params: 'a) =>
-    switch context.contents->Dict.keysToArray {
-    | [] => params
-    | keys => {
-        let narrowed = params->(Utils.magic: 'a => dict<JSON.t>)->Dict.copy
-        keys->Array.forEach(key => narrowed->Dict.delete(key))
-        narrowed->(Utils.magic: dict<JSON.t> => 'a)
-      }
-    }
-)
-
 let makeLogger = (~logStrategy, ~logFilePath, ~defaultFileLogLevel, ~userLogLevel) => {
   // Currently unused - useful if using multiple transports.
   // let pinoRaw = {"target": "pino/file", "level": Config.userLogLevel}
@@ -80,19 +56,17 @@ let makeLogger = (~logStrategy, ~logFilePath, ~defaultFileLogLevel, ~userLogLeve
         ...Pino.ECS.make(),
         customLevels: logLevels,
         base,
-        mixin,
       },
       Transport.make(pinoFile),
     )
   | EcsConsoleMultistream =>
-    makeMultiStreamLogger(~logFile=None, ~options=Some({...Pino.ECS.make(), base, mixin}))
+    makeMultiStreamLogger(~logFile=None, ~options=Some({...Pino.ECS.make(), base}))
   | EcsConsole =>
     make({
       ...Pino.ECS.make(),
       level: userLogLevel,
       customLevels: logLevels,
       base,
-      mixin,
     })
   | FileOnly =>
     makeWithOptionsAndTransport(
@@ -100,13 +74,12 @@ let makeLogger = (~logStrategy, ~logFilePath, ~defaultFileLogLevel, ~userLogLeve
         customLevels: logLevels,
         level: defaultFileLogLevel,
         base,
-        mixin,
       },
       Transport.make(pinoFile),
     )
-  | ConsoleRaw => makeMultiStreamLogger(~logFile=None, ~options=Some({base, mixin}))
-  | ConsolePretty => makeMultiStreamLogger(~logFile=None, ~options=Some({base, mixin}))
-  | Both => makeMultiStreamLogger(~logFile=Some(logFilePath), ~options=Some({base, mixin}))
+  | ConsoleRaw => makeMultiStreamLogger(~logFile=None, ~options=Some({base: base}))
+  | ConsolePretty => makeMultiStreamLogger(~logFile=None, ~options=Some({base: base}))
+  | Both => makeMultiStreamLogger(~logFile=Some(logFilePath), ~options=Some({base: base}))
   }
 }
 
@@ -176,15 +149,10 @@ let childFatal = (logger, params: 'a) => {
 }
 
 let createChild = (~params: 'a) => {
-  getLogger()->child(params->withoutContext->createChildParams)
+  getLogger()->child(params->createChildParams)
 }
-
-// What belongs on every line is the run's to decide; the logger only carries
-// what it is handed. A line that names one of these fields itself wins.
-let setContext = (fields: dict<JSON.t>) => context := fields
-
 let createChildFrom = (~logger: t, ~params: 'a) => {
-  logger->child(params->withoutContext->createChildParams)
+  logger->child(params->createChildParams)
 }
 
 @inline

package/src/Logging.res.mjs

@@ -3,7 +3,6 @@
 import * as Pino from "./bindings/Pino.res.mjs";
 import * as Pino$1 from "pino";
 import * as Utils from "./Utils.res.mjs";
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
@@ -54,24 +53,6 @@ let logger = {
   contents: undefined
 };
 
-let context = {
-  contents: {}
-};
-
-function mixin() {
-  return Object.assign({}, context.contents);
-}
-
-function withoutContext(params) {
-  let keys = Object.keys(context.contents);
-  if (keys.length === 0) {
-    return params;
-  }
-  let narrowed = Object.assign({}, params);
-  keys.forEach(key => Stdlib_Dict.$$delete(narrowed, key));
-  return narrowed;
-}
-
 function makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel) {
   let pinoFile_target = "pino/file";
   let pinoFile_options = Primitive_option.some(Pino.Transport.makeTransportOptions({
@@ -90,18 +71,17 @@ function makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel)
   switch (logStrategy) {
     case "ecs-file" :
       let newrecord = {...Pino.ECS.make()};
-      return Pino$1.pino((newrecord.base = base, newrecord.mixin = mixin, newrecord.customLevels = logLevels, newrecord), Pino$1.transport(pinoFile));
+      return Pino$1.pino((newrecord.base = base, newrecord.customLevels = logLevels, newrecord), Pino$1.transport(pinoFile));
     case "ecs-console" :
       let newrecord$1 = {...Pino.ECS.make()};
-      return Pino$1.pino((newrecord$1.base = base, newrecord$1.mixin = mixin, newrecord$1.customLevels = logLevels, newrecord$1.level = userLogLevel, newrecord$1));
+      return Pino$1.pino((newrecord$1.base = base, newrecord$1.customLevels = logLevels, newrecord$1.level = userLogLevel, newrecord$1));
     case "ecs-console-multistream" :
       let newrecord$2 = {...Pino.ECS.make()};
-      return makeMultiStreamLogger(undefined, (newrecord$2.base = base, newrecord$2.mixin = mixin, newrecord$2));
+      return makeMultiStreamLogger(undefined, (newrecord$2.base = base, newrecord$2));
     case "file-only" :
       return Pino$1.pino({
         level: defaultFileLogLevel,
         customLevels: logLevels,
-        mixin: mixin,
         base: base
       }, Pino$1.transport(pinoFile));
     case "console-raw" :
@@ -109,12 +89,10 @@ function makeLogger(logStrategy, logFilePath, defaultFileLogLevel, userLogLevel)
       break;
     case "both-prettyconsole" :
       return makeMultiStreamLogger(logFilePath, {
-        mixin: mixin,
         base: base
       });
   }
   return makeMultiStreamLogger(undefined, {
-    mixin: mixin,
     base: base
   });
 }
@@ -193,15 +171,11 @@ function childFatal(logger, params) {
 }
 
 function createChild(params) {
-  return getLogger().child(Pino.createChildParams(withoutContext(params)));
-}
-
-function setContext(fields) {
-  context.contents = fields;
+  return getLogger().child(Pino.createChildParams(params));
 }
 
 function createChildFrom(logger, params) {
-  return logger.child(Pino.createChildParams(withoutContext(params)));
+  return logger.child(Pino.createChildParams(params));
 }
 
 function logAtLevel(logger, level, message, params) {
@@ -272,7 +246,6 @@ export {
   childErrorWithExn,
   childFatal,
   createChild,
-  setContext,
   createChildFrom,
   logAtLevel,
   noopLogger,

package/src/Main.res

@@ -453,9 +453,6 @@ exception FatalError(exn)
   ) => {
     // A worker reports to its supervisor, which draws for the whole run.
     let shouldUseTui = Tui.shouldUse(~suppressed=isTest || Worker.isEnabled)
-    // In per-chain mode every line this process writes belongs to the chains it
-    // drives, whether or not a supervisor split the run across processes.
-    config->Config.logContext->Option.forEach(Logging.setContext)
     // isDevelopmentMode controls whether the indexer stays alive after all
     // chains finish (keepProcessAlive) and whether the console API is exposed.
     // Set by `envio dev` via the public config's `isDev` field; `envio start`
@@ -561,12 +558,12 @@ let start = async (
   ~exitAfterFirstEventBlock=false,
   ~patchConfig: option<(Config.t, HandlerRegister.registrationsByChainId) => Config.t>=?,
 ) => {
-  // A worker parses the same config its supervisor did and narrows it to the
-  // chains it was handed, rather than being told what to index: the storage it
-  // resumes refuses a config that disagrees with the one the run was created
-  // from, which is a stronger guarantee than a handover could give.
-  Worker.config->Option.forEach(({chainIds}) =>
-    Config.prime(Config.getPublicConfigJson()->Config.withIsolatedChains(~chainIds))
+  // A worker parses the project's files itself rather than being handed the
+  // config: a public config carries every contract's ABI, which is far more
+  // than a spawn environment should. What the command decided rides along
+  // instead, and re-applying it is what makes the two configs the same one.
+  Worker.config->Option.forEach(({chainIds, isDev}) =>
+    Config.prime(Config.getPublicConfigJson()->Config.withCommandFields(~chainIds, ~isDev))
   )
   let config = Config.load()
   switch isTest ? None : Supervisor.planForRun(~config) {

package/src/Main.res.mjs

@@ -6,7 +6,6 @@ import * as Config from "./Config.res.mjs";
 import * as Server from "./Server.res.mjs";
 import * as Worker from "./Worker.res.mjs";
 import * as ChainId from "./ChainId.res.mjs";
-import * as Logging from "./Logging.res.mjs";
 import * as Metrics from "./Metrics.res.mjs";
 import * as ChainMap from "./ChainMap.res.mjs";
 import * as PgStorage from "./PgStorage.res.mjs";
@@ -352,7 +351,7 @@ function getGlobalIndexer() {
 async function migrate(reset) {
   let config = Config.load();
   let persistence = PgStorage.makePersistenceFromConfig(config, undefined);
-  await Persistence.init(persistence, ChainMap.values(config.chainMap), config.contractMapping, Config.envioInfo(), "envio local db-migrate setup", undefined, reset, config.lowercaseAddresses, undefined, "Once");
+  await Persistence.init(persistence, ChainMap.values(config.chainMap), config.contractMapping, Config.envioInfo(), "envio local db-migrate setup", undefined, reset, config.lowercaseAddresses, undefined, undefined, "Once");
   return await persistence.storage.close();
 }
 
@@ -369,8 +368,7 @@ async function startIndexer(config, persistence, resetOpt, isTestOpt, exitAfterF
   let reset = resetOpt !== undefined ? resetOpt : false;
   let isTest = isTestOpt !== undefined ? isTestOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
-  let shouldUseTui = Tui.shouldUse(isTest || Worker.isEnabled);
-  Stdlib_Option.forEach(Config.logContext(config), Logging.setContext);
+  let shouldUseTui = Tui.shouldUse(isTest || Worker.isEnabled, undefined);
   let isDevelopmentMode = !isTest && config.isDev;
   let persistence$1 = persistence !== undefined ? persistence : PgStorage.makePersistenceFromConfig(config, undefined);
   EnvioGlobal.value.persistence = Primitive_option.some(persistence$1);
@@ -418,7 +416,7 @@ async function start(persistence, resetOpt, isTestOpt, exitAfterFirstEventBlockO
   let reset = resetOpt !== undefined ? resetOpt : false;
   let isTest = isTestOpt !== undefined ? isTestOpt : false;
   let exitAfterFirstEventBlock = exitAfterFirstEventBlockOpt !== undefined ? exitAfterFirstEventBlockOpt : false;
-  Stdlib_Option.forEach(Worker.config, param => Config.prime(Config.withIsolatedChains(Config.getPublicConfigJson(), param.chainIds)));
+  Stdlib_Option.forEach(Worker.config, param => Config.prime(Config.withCommandFields(Config.getPublicConfigJson(), param.chainIds, param.isDev)));
   let config = Config.load();
   let workers = isTest ? undefined : Supervisor.planForRun(config, undefined);
   if (workers !== undefined) {