envio 3.12.1 → 3.13.0-alpha.0

package/src/Metrics.res.mjs

@@ -6,6 +6,7 @@ import * as ChainId from "./ChainId.res.mjs";
 import * as Process from "process";
 import * as Perf_hooks from "perf_hooks";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
@@ -18,6 +19,94 @@ function hasProcessedToEndblock(m) {
   }
 }
 
+function sumByKey(items, key, add) {
+  let byKey = {};
+  let order = [];
+  items.forEach(item => {
+    let k = key(item);
+    let existing = byKey[k];
+    if (existing !== undefined) {
+      byKey[k] = add(Primitive_option.valFromOption(existing), item);
+    } else {
+      byKey[k] = item;
+      order.push(k);
+    }
+  });
+  return order.map(k => byKey[k]);
+}
+
+function merge(snapshots, startTime, metricTime, elapsedSeconds) {
+  let sumInt = select => Stdlib_Array.reduce(snapshots, 0, (acc, snapshot) => acc + select(snapshot) | 0);
+  let sumFloat = select => Stdlib_Array.reduce(snapshots, 0, (acc, snapshot) => acc + select(snapshot));
+  return {
+    startTime: startTime,
+    metricTime: metricTime,
+    elapsedSeconds: elapsedSeconds,
+    targetBufferSize: sumInt(s => s.targetBufferSize),
+    isInReorgThreshold: snapshots.some(s => s.isInReorgThreshold),
+    hasArrivedAtHead: Utils.$$Array.notEmpty(snapshots) && snapshots.every(s => s.hasArrivedAtHead),
+    rollbackEnabled: snapshots.some(s => s.rollbackEnabled),
+    maxBatchSize: Stdlib_Array.reduce(snapshots, 0, (acc, s) => Primitive_int.max(acc, s.maxBatchSize)),
+    preloadSeconds: sumFloat(s => s.preloadSeconds),
+    processingSeconds: sumFloat(s => s.processingSeconds),
+    processingStalledOnFetchSeconds: sumFloat(s => s.processingStalledOnFetchSeconds),
+    processingStalledOnStorageWriteSeconds: sumFloat(s => s.processingStalledOnStorageWriteSeconds),
+    rollbackSeconds: sumFloat(s => s.rollbackSeconds),
+    rollbackCount: sumInt(s => s.rollbackCount),
+    rollbackEventsCount: sumFloat(s => s.rollbackEventsCount),
+    chains: snapshots.flatMap(s => s.chains),
+    handlers: sumByKey(snapshots.flatMap(s => s.handlers), h => h.contract + `.` + h.event, (a, b) => ({
+      contract: a.contract,
+      event: a.event,
+      processingSeconds: a.processingSeconds + b.processingSeconds,
+      processingCount: a.processingCount + b.processingCount,
+      preloadSeconds: a.preloadSeconds + b.preloadSeconds,
+      preloadCount: a.preloadCount + b.preloadCount,
+      preloadSecondsTotal: a.preloadSecondsTotal + b.preloadSecondsTotal
+    })),
+    effects: sumByKey(snapshots.flatMap(s => s.effects), e => e.effect + `.` + e.scope, (a, b) => {
+      let match = a.cacheCount;
+      let match$1 = b.cacheCount;
+      return {
+        effect: a.effect,
+        scope: a.scope,
+        callSeconds: a.callSeconds + b.callSeconds,
+        callSecondsTotal: a.callSecondsTotal + b.callSecondsTotal,
+        callCount: a.callCount + b.callCount,
+        activeCallsCount: a.activeCallsCount + b.activeCallsCount | 0,
+        queueCount: a.queueCount + b.queueCount | 0,
+        queueWaitSeconds: a.queueWaitSeconds + b.queueWaitSeconds,
+        invalidationsCount: a.invalidationsCount + b.invalidationsCount,
+        cacheCount: match !== undefined ? (
+            match$1 !== undefined ? match + match$1 | 0 : match
+          ) : match$1
+      };
+    }),
+    storageLoads: sumByKey(snapshots.flatMap(s => s.storageLoads), l => l.storage + `.` + l.operation, (a, b) => ({
+      operation: a.operation,
+      storage: a.storage,
+      seconds: a.seconds + b.seconds,
+      secondsTotal: a.secondsTotal + b.secondsTotal,
+      count: a.count + b.count,
+      whereSize: a.whereSize + b.whereSize,
+      size: a.size + b.size
+    })),
+    storageWrites: sumByKey(snapshots.flatMap(s => s.storageWrites), w => w.storage, (a, b) => ({
+      storage: a.storage,
+      seconds: a.seconds + b.seconds,
+      count: a.count + b.count | 0
+    })),
+    historyPrunes: sumByKey(snapshots.flatMap(s => s.historyPrunes), p => p.entity, (a, b) => ({
+      entity: a.entity,
+      seconds: a.seconds + b.seconds,
+      count: a.count + b.count | 0
+    })),
+    sourceRequests: snapshots.flatMap(s => s.sourceRequests),
+    sourceHeights: snapshots.flatMap(s => s.sourceHeights),
+    sourceHeightStreams: snapshots.flatMap(s => s.sourceHeightStreams)
+  };
+}
+
 function formatValue(value) {
   return (Math.round(value * 1000) / 1000).toString();
 }
@@ -365,24 +454,12 @@ function startRuntimeCollectors() {
   getRuntimeCollectors();
 }
 
-function collectRuntime() {
-  let b = {
-    out: ""
-  };
+function sampleRuntime() {
   let memory = Process.memoryUsage();
   let cpu = Process.cpuUsage();
   let elu = Perf_hooks.performance.eventLoopUtilization();
   let match = getRuntimeCollectors();
   let eventLoopDelay = match.eventLoopDelay;
-  single(b, "process_cpu_user_seconds_total", "Total user CPU time spent in seconds.", "counter", cpu.user / 1000000);
-  single(b, "process_cpu_system_seconds_total", "Total system CPU time spent in seconds.", "counter", cpu.system / 1000000);
-  single(b, "process_cpu_seconds_total", "Total user and system CPU time spent in seconds.", "counter", (cpu.user + cpu.system) / 1000000);
-  single(b, "process_start_time_seconds", "Start time of the process since unix epoch in seconds.", "gauge", match.processStartTimeSeconds);
-  single(b, "process_resident_memory_bytes", "Resident memory size in bytes.", "gauge", memory.rss);
-  single(b, "nodejs_heap_size_total_bytes", "Process heap size from Node.js in bytes.", "gauge", memory.heapTotal);
-  single(b, "nodejs_heap_size_used_bytes", "Process heap size used from Node.js in bytes.", "gauge", memory.heapUsed);
-  single(b, "nodejs_external_memory_bytes", "Node.js external memory size in bytes.", "gauge", memory.external);
-  single(b, "nodejs_eventloop_utilization", "Ratio of time the event loop is active, since process start.", "gauge", elu.utilization);
   let hasLagSamples = eventLoopDelay.max > 0;
   let nsToSeconds = ns => {
     if (hasLagSamples && !Number.isNaN(ns)) {
@@ -391,52 +468,152 @@ function collectRuntime() {
       return 0;
     }
   };
-  single(b, "nodejs_eventloop_lag_mean_seconds", "The mean of the recorded event loop delays.", "gauge", nsToSeconds(eventLoopDelay.mean));
-  single(b, "nodejs_eventloop_lag_min_seconds", "The minimum recorded event loop delay.", "gauge", nsToSeconds(eventLoopDelay.min));
-  single(b, "nodejs_eventloop_lag_max_seconds", "The maximum recorded event loop delay.", "gauge", nsToSeconds(eventLoopDelay.max));
-  single(b, "nodejs_eventloop_lag_stddev_seconds", "The standard deviation of the recorded event loop delays.", "gauge", nsToSeconds(eventLoopDelay.stddev));
-  single(b, "nodejs_eventloop_lag_p50_seconds", "The 50th percentile of the recorded event loop delays.", "gauge", nsToSeconds(eventLoopDelay.percentile(50)));
-  single(b, "nodejs_eventloop_lag_p90_seconds", "The 90th percentile of the recorded event loop delays.", "gauge", nsToSeconds(eventLoopDelay.percentile(90)));
-  single(b, "nodejs_eventloop_lag_p99_seconds", "The 99th percentile of the recorded event loop delays.", "gauge", nsToSeconds(eventLoopDelay.percentile(99)));
-  eventLoopDelay.reset();
-  let heapSpaces = V8.getHeapSpaceStatistics().map(s => [
-    `{space="` + s.space_name.replace("_space", "") + `"}`,
-    s
-  ]);
-  series(b, "nodejs_heap_space_size_total_bytes", "Process heap space size total from Node.js in bytes.", "gauge", heapSpaces, s => s.space_size);
-  series(b, "nodejs_heap_space_size_used_bytes", "Process heap space size used from Node.js in bytes.", "gauge", heapSpaces, s => s.space_used_size);
-  series(b, "nodejs_heap_space_size_available_bytes", "Process heap space size available from Node.js in bytes.", "gauge", heapSpaces, s => s.space_available_size);
   let byType = {};
-  Process.getActiveResourcesInfo().forEach(resource => {
-    let label = `{type="` + escapeLabelValue(resource) + `"}`;
-    byType[label] = Stdlib_Option.getOr(byType[label], 0) + 1;
+  let sample_cpuUserSeconds = cpu.user / 1000000;
+  let sample_cpuSystemSeconds = cpu.system / 1000000;
+  let sample_processStartTimeSeconds = match.processStartTimeSeconds;
+  let sample_residentMemoryBytes = memory.rss;
+  let sample_heapTotalBytes = memory.heapTotal;
+  let sample_heapUsedBytes = memory.heapUsed;
+  let sample_externalMemoryBytes = memory.external;
+  let sample_eventLoopUtilization = elu.utilization;
+  let sample_eventLoopLagMeanSeconds = nsToSeconds(eventLoopDelay.mean);
+  let sample_eventLoopLagMinSeconds = nsToSeconds(eventLoopDelay.min);
+  let sample_eventLoopLagMaxSeconds = nsToSeconds(eventLoopDelay.max);
+  let sample_eventLoopLagStddevSeconds = nsToSeconds(eventLoopDelay.stddev);
+  let sample_eventLoopLagP50Seconds = nsToSeconds(eventLoopDelay.percentile(50));
+  let sample_eventLoopLagP90Seconds = nsToSeconds(eventLoopDelay.percentile(90));
+  let sample_eventLoopLagP99Seconds = nsToSeconds(eventLoopDelay.percentile(99));
+  let sample_heapSpaces = V8.getHeapSpaceStatistics().map(s => ({
+    space: s.space_name.replace("_space", ""),
+    size: s.space_size,
+    used: s.space_used_size,
+    available: s.space_available_size
+  }));
+  let sample_activeResources = (Process.getActiveResourcesInfo().forEach(resource => {
+    byType[resource] = Stdlib_Option.getOr(byType[resource], 0) + 1;
+  }), Object.entries(byType));
+  let sample_gc = Object.entries(match.gcStats).map(param => {
+    let stat = param[1];
+    return {
+      kind: param[0],
+      count: stat.count,
+      seconds: stat.seconds
+    };
   });
-  let activeResources = Object.entries(byType);
-  series(b, "nodejs_active_resources", "Number of active resources that are currently keeping the event loop alive, grouped by async resource type.", "gauge", activeResources, count => count);
-  single(b, "nodejs_active_resources_total", "Total number of active resources.", "gauge", Stdlib_Array.reduce(activeResources, 0, (acc, param) => acc + param[1]));
-  let gcEntries = [];
-  Utils.Dict.forEachWithKey(match.gcStats, (stat, kind) => {
-    gcEntries.push([
-      `{kind="` + kind + `"}`,
-      stat
+  let sample = {
+    cpuUserSeconds: sample_cpuUserSeconds,
+    cpuSystemSeconds: sample_cpuSystemSeconds,
+    processStartTimeSeconds: sample_processStartTimeSeconds,
+    residentMemoryBytes: sample_residentMemoryBytes,
+    heapTotalBytes: sample_heapTotalBytes,
+    heapUsedBytes: sample_heapUsedBytes,
+    externalMemoryBytes: sample_externalMemoryBytes,
+    eventLoopUtilization: sample_eventLoopUtilization,
+    eventLoopLagMeanSeconds: sample_eventLoopLagMeanSeconds,
+    eventLoopLagMinSeconds: sample_eventLoopLagMinSeconds,
+    eventLoopLagMaxSeconds: sample_eventLoopLagMaxSeconds,
+    eventLoopLagStddevSeconds: sample_eventLoopLagStddevSeconds,
+    eventLoopLagP50Seconds: sample_eventLoopLagP50Seconds,
+    eventLoopLagP90Seconds: sample_eventLoopLagP90Seconds,
+    eventLoopLagP99Seconds: sample_eventLoopLagP99Seconds,
+    heapSpaces: sample_heapSpaces,
+    activeResources: sample_activeResources,
+    gc: sample_gc,
+    nodeVersion: Process.version
+  };
+  eventLoopDelay.reset();
+  return sample;
+}
+
+function renderRuntime(samples) {
+  let b = {
+    out: ""
+  };
+  let labels = (scope, own) => {
+    if (scope === "") {
+      if (own === "") {
+        return "";
+      } else {
+        return `{` + own + `}`;
+      }
+    } else if (own === "") {
+      return `{` + scope + `}`;
+    } else {
+      return `{` + scope + `,` + own + `}`;
+    }
+  };
+  let scoped = samples.map(param => [
+    labels(param[0], ""),
+    param[1]
+  ]);
+  let each = select => samples.flatMap(param => {
+    let scope = param[0];
+    return select(param[1]).map(param => [
+      labels(scope, param[0]),
+      param[1]
     ]);
   });
-  series(b, "nodejs_gc_duration_seconds_sum", "Cumulative garbage collection pause time by kind, one of major, minor, incremental or weakcb.", "counter", gcEntries, s => s.seconds);
-  series(b, "nodejs_gc_duration_seconds_count", "Number of garbage collection pauses by kind, one of major, minor, incremental or weakcb.", "counter", gcEntries, s => s.count);
-  let version = Process.version;
-  let versionParts = version.replace("v", "").split(".");
-  let versionPart = i => Stdlib_Option.getOr(versionParts[i], "0");
-  series(b, "nodejs_version_info", "Node.js version info.", "gauge", [[
-      `{version="` + version + `",major="` + versionPart(0) + `",minor="` + versionPart(1) + `",patch="` + versionPart(2) + `"}`,
-      undefined
-    ]], () => 1);
+  let gauge = (name, help, value) => series(b, name, help, "gauge", scoped, value);
+  let counter = (name, help, value) => series(b, name, help, "counter", scoped, value);
+  counter("process_cpu_user_seconds_total", "Total user CPU time spent in seconds.", s => s.cpuUserSeconds);
+  counter("process_cpu_system_seconds_total", "Total system CPU time spent in seconds.", s => s.cpuSystemSeconds);
+  counter("process_cpu_seconds_total", "Total user and system CPU time spent in seconds.", s => s.cpuUserSeconds + s.cpuSystemSeconds);
+  gauge("process_start_time_seconds", "Start time of the process since unix epoch in seconds.", s => s.processStartTimeSeconds);
+  gauge("process_resident_memory_bytes", "Resident memory size in bytes.", s => s.residentMemoryBytes);
+  gauge("nodejs_heap_size_total_bytes", "Process heap size from Node.js in bytes.", s => s.heapTotalBytes);
+  gauge("nodejs_heap_size_used_bytes", "Process heap size used from Node.js in bytes.", s => s.heapUsedBytes);
+  gauge("nodejs_external_memory_bytes", "Node.js external memory size in bytes.", s => s.externalMemoryBytes);
+  gauge("nodejs_eventloop_utilization", "Ratio of time the event loop is active, since process start.", s => s.eventLoopUtilization);
+  gauge("nodejs_eventloop_lag_mean_seconds", "The mean of the recorded event loop delays.", s => s.eventLoopLagMeanSeconds);
+  gauge("nodejs_eventloop_lag_min_seconds", "The minimum recorded event loop delay.", s => s.eventLoopLagMinSeconds);
+  gauge("nodejs_eventloop_lag_max_seconds", "The maximum recorded event loop delay.", s => s.eventLoopLagMaxSeconds);
+  gauge("nodejs_eventloop_lag_stddev_seconds", "The standard deviation of the recorded event loop delays.", s => s.eventLoopLagStddevSeconds);
+  gauge("nodejs_eventloop_lag_p50_seconds", "The 50th percentile of the recorded event loop delays.", s => s.eventLoopLagP50Seconds);
+  gauge("nodejs_eventloop_lag_p90_seconds", "The 90th percentile of the recorded event loop delays.", s => s.eventLoopLagP90Seconds);
+  gauge("nodejs_eventloop_lag_p99_seconds", "The 99th percentile of the recorded event loop delays.", s => s.eventLoopLagP99Seconds);
+  let heapSpaces = each(s => s.heapSpaces.map(h => [
+    `space="` + h.space + `"`,
+    h
+  ]));
+  series(b, "nodejs_heap_space_size_total_bytes", "Process heap space size total from Node.js in bytes.", "gauge", heapSpaces, h => h.size);
+  series(b, "nodejs_heap_space_size_used_bytes", "Process heap space size used from Node.js in bytes.", "gauge", heapSpaces, h => h.used);
+  series(b, "nodejs_heap_space_size_available_bytes", "Process heap space size available from Node.js in bytes.", "gauge", heapSpaces, h => h.available);
+  series(b, "nodejs_active_resources", "Number of active resources that are currently keeping the event loop alive, grouped by async resource type.", "gauge", each(s => s.activeResources.map(param => [
+    `type="` + escapeLabelValue(param[0]) + `"`,
+    param[1]
+  ])), count => count);
+  gauge("nodejs_active_resources_total", "Total number of active resources.", s => Stdlib_Array.reduce(s.activeResources, 0, (acc, param) => acc + param[1]));
+  let gc = each(s => s.gc.map(g => [
+    `kind="` + g.kind + `"`,
+    g
+  ]));
+  series(b, "nodejs_gc_duration_seconds_sum", "Cumulative garbage collection pause time by kind, one of major, minor, incremental or weakcb.", "counter", gc, g => g.seconds);
+  series(b, "nodejs_gc_duration_seconds_count", "Number of garbage collection pauses by kind, one of major, minor, incremental or weakcb.", "counter", gc, g => g.count);
+  series(b, "nodejs_version_info", "Node.js version info.", "gauge", each(s => {
+    let parts = s.nodeVersion.replace("v", "").split(".");
+    let part = i => Stdlib_Option.getOr(parts[i], "0");
+    return [[
+        `version="` + s.nodeVersion + `",major="` + part(0) + `",minor="` + part(1) + `",patch="` + part(2) + `"`,
+        undefined
+      ]];
+  }), () => 1);
   return b.out + "\n";
 }
 
+function collectRuntime() {
+  return renderRuntime([[
+      "",
+      sampleRuntime()
+    ]]);
+}
+
 let contentType = "text/plain; version=0.0.4; charset=utf-8";
 
 export {
   hasProcessedToEndblock,
+  sumByKey,
+  merge,
   formatValue,
   escapeLabelValue,
   block,
@@ -451,6 +628,8 @@ export {
   runtimeCollectors,
   getRuntimeCollectors,
   startRuntimeCollectors,
+  sampleRuntime,
+  renderRuntime,
   collectRuntime,
 }
 /* v8 Not a pure module */

package/src/Persistence.res

@@ -324,7 +324,10 @@ let init = {
           | _ => false
           }
         ) {
-          Logging.info(`Found existing indexer storage. Resuming indexing state...`)
+          // An isolated process resumes state its supervisor already announced
+          // for the whole run, so it says so only to its own log file.
+          let logResume = requireInitialized ? Logging.debug : Logging.info
+          logResume(`Found existing indexer storage. Resuming indexing state...`)
           let initialState = await persistence.storage.resumeInitialState(
             ~entities=persistence.allEntities,
             ~chainIds=chainConfigs->Array.map(chain => chain.id),
@@ -343,7 +346,7 @@ let init = {
           initialState.chains->Array.forEach(c => {
             progress->ChainId.Dict.set(c.id, c.progressBlockNumber)
           })
-          Logging.info({
+          logResume({
             "msg": `Successfully resumed indexing state! Continuing from the last checkpoint.`,
             "progress": progress,
           })
@@ -356,6 +359,28 @@ let init = {
   }
 }
 
+// Brings the schema up to date for a run that is about to start, as opposed to
+// a migration command: what a config change prints names the command the
+// operator ran, and an unreachable chain is waited on rather than reported,
+// since somebody is watching the run come up.
+let initForRun = (
+  persistence,
+  ~config: Config.t,
+  ~reset,
+  ~isDevelopmentMode,
+  ~requireInitialized,
+) =>
+  persistence->init(
+    ~reset,
+    ~chainConfigs=config.chainMap->ChainMap.values,
+    ~contractMapping=config.contractMapping,
+    ~envioInfo=Config.envioInfo(),
+    ~resetCommand=isDevelopmentMode ? "envio dev -r" : "envio start -r",
+    ~runCommand=Some(isDevelopmentMode ? "envio dev" : "envio start"),
+    ~lowercaseAddresses=config.lowercaseAddresses,
+    ~requireInitialized,
+  )
+
 let getInitializedStorageOrThrow = persistence => {
   switch persistence.storageStatus {
   | Unknown

package/src/Persistence.res.mjs

@@ -3,6 +3,7 @@
 import * as Batch from "./Batch.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
+import * as ChainMap from "./ChainMap.res.mjs";
 import * as Frontier from "./db/Frontier.res.mjs";
 import * as EntityHistory from "./db/EntityHistory.res.mjs";
 import * as ErrorHandling from "./ErrorHandling.res.mjs";
@@ -77,7 +78,8 @@ async function init(persistence, chainConfigs, contractMapping, envioInfo, reset
       let tmp;
       tmp = typeof match !== "object" ? false : match.TAG === "Initializing";
       if (tmp) {
-        Logging.info(`Found existing indexer storage. Resuming indexing state...`);
+        let logResume = requireInitialized ? Logging.debug : Logging.info;
+        logResume(`Found existing indexer storage. Resuming indexing state...`);
         let initialState$1 = await persistence.storage.resumeInitialState(persistence.allEntities, chainConfigs.map(chain => chain.id), (storedEnvioInfo, storedContractMapping) => Config.throwIfResumeIncompatible(storedEnvioInfo, storedContractMapping, envioInfo, contractMapping, resetCommand, runCommand));
         persistence.storageStatus = {
           TAG: "Ready",
@@ -87,7 +89,7 @@ async function init(persistence, chainConfigs, contractMapping, envioInfo, reset
         initialState$1.chains.forEach(c => {
           progress[c.id] = c.progressBlockNumber;
         });
-        Logging.info({
+        logResume({
           msg: `Successfully resumed indexing state! Continuing from the last checkpoint.`,
           progress: progress
         });
@@ -100,6 +102,10 @@ async function init(persistence, chainConfigs, contractMapping, envioInfo, reset
   }
 }
 
+function initForRun(persistence, config, reset, isDevelopmentMode, requireInitialized) {
+  return init(persistence, ChainMap.values(config.chainMap), config.contractMapping, Config.envioInfo(), isDevelopmentMode ? "envio dev -r" : "envio start -r", isDevelopmentMode ? "envio dev" : "envio start", reset, config.lowercaseAddresses, requireInitialized, undefined);
+}
+
 function getInitializedStorageOrThrow(persistence) {
   let match = persistence.storageStatus;
   if (typeof match !== "object" || match.TAG === "Initializing") {
@@ -123,6 +129,7 @@ export {
   StorageError,
   make,
   init,
+  initForRun,
   getInitializedStorageOrThrow,
   getInitializedState,
 }

package/src/PgStorage.res

@@ -1,4 +1,4 @@
-let makeClient = () => {
+let makeClient = (~maxConnections=Env.Db.maxConnections) => {
   Postgres.makeSql(
     ~config={
       host: Env.Db.host,
@@ -14,7 +14,7 @@ let makeClient = () => {
           : Some(_str => ())
       ),
       transform: {undefined: Null},
-      max: Env.Db.maxConnections,
+      max: maxConnections,
       // debug: (~connection, ~query, ~params as _, ~types as _) => Js.log2(connection, query),
     },
   )
@@ -2264,13 +2264,17 @@ let make = (
     }
 
     switch missing {
-    | [] =>
+    // A schema that declares no indexes has nothing to say about them, and one
+    // whose indexes are all in place says it once. Either way the line that
+    // matters is the indexer reporting itself ready, which finalization logs.
+    | [] if schemaIndexes->Utils.Array.notEmpty =>
       Logging.info({
         "storage": storageName,
         "msg": `All ${schemaIndexes
           ->Array.length
           ->Int.toString} schema indexes are already in place. Marking the indexer ready.`,
       })
+    | [] => ()
     | _ =>
       Logging.info({
         "storage": storageName,
@@ -2318,12 +2322,16 @@ let make = (
       }
     })
 
-    Logging.info({
-      "storage": storageName,
-      "msg": `Committed ${missing
-        ->Array.length
-        ->Int.toString} schema indexes and the ready timestamp in ${timeRef->formatSeconds}s.`,
-    })
+    // Only when something was built: the wait this closes is the index build,
+    // and the stamp on its own is not one anybody waited through.
+    if missing->Utils.Array.notEmpty {
+      Logging.info({
+        "storage": storageName,
+        "msg": `Committed ${missing
+          ->Array.length
+          ->Int.toString} schema indexes and the ready timestamp in ${timeRef->formatSeconds}s.`,
+      })
+    }
   }
 
   let setOrThrow = (

package/src/PgStorage.res.mjs

@@ -38,7 +38,8 @@ import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 import * as CheckpointSequence from "./db/CheckpointSequence.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
-function makeClient() {
+function makeClient(maxConnectionsOpt) {
+  let maxConnections = maxConnectionsOpt !== undefined ? maxConnectionsOpt : Env.Db.maxConnections;
   return Postgres({
     host: Env.Db.host,
     port: Env.Db.port,
@@ -46,7 +47,7 @@ function makeClient() {
     username: Env.Db.user,
     password: Env.Db.password,
     ssl: Env.Db.ssl,
-    max: Env.Db.maxConnections,
+    max: maxConnections,
     onnotice: Primitive_object.equal(Env.userLogLevel, "warn") || Primitive_object.equal(Env.userLogLevel, "error") ? undefined : _str => {},
     transform: {
       undefined: null
@@ -1407,7 +1408,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         msg: `Creating the ` + missing.length.toString() + ` remaining schema indexes before the indexer reports ready. Writes are paused until they are committed. ` + slowOnLargeDatabaseNotice,
         indexes: missing.map(prepared => prepared.name)
       });
-    } else {
+    } else if (Utils.$$Array.notEmpty(schemaIndexes)) {
       Logging.info({
         storage: storageName,
         msg: `All ` + schemaIndexes.length.toString() + ` schema indexes are already in place. Marking the indexer ready.`
@@ -1438,10 +1439,12 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
         ], {prepare: true});
       }
     });
-    return Logging.info({
-      storage: storageName,
-      msg: `Committed ` + missing.length.toString() + ` schema indexes and the ready timestamp in ` + formatSeconds(timeRef) + `s.`
-    });
+    if (Utils.$$Array.notEmpty(missing)) {
+      return Logging.info({
+        storage: storageName,
+        msg: `Committed ` + missing.length.toString() + ` schema indexes and the ready timestamp in ` + formatSeconds(timeRef) + `s.`
+      });
+    }
   };
   let setOrThrow$1 = (items, table, itemSchema) => setOrThrow(sql, items, table, itemSchema, pgSchema, setQueryCache, chainIdMode);
   let setEffectCacheOrThrow = async (table, itemSchema, items, initialize) => {
@@ -1663,7 +1666,7 @@ function make(sql, pgHost, pgSchema, pgPort, pgUser, pgDatabase, pgPassword, isH
 }
 
 function makeStorageFromEnv(config, sqlOpt, pgSchemaOpt, isHasuraEnabledOpt) {
-  let sql = sqlOpt !== undefined ? Primitive_option.valFromOption(sqlOpt) : makeClient();
+  let sql = sqlOpt !== undefined ? Primitive_option.valFromOption(sqlOpt) : makeClient(undefined);
   let pgSchema = pgSchemaOpt !== undefined ? pgSchemaOpt : Env.Db.publicSchema;
   let isHasuraEnabled = isHasuraEnabledOpt !== undefined ? isHasuraEnabledOpt : Env.Hasura.enabled;
   let tmp;