envio 3.3.0 → 3.3.1

package/src/Metrics.res.mjs

@@ -1,75 +1,392 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as V8 from "v8";
 import * as Utils from "./Utils.res.mjs";
-import * as ChainState from "./ChainState.res.mjs";
-import * as PromClient from "prom-client";
-import * as IndexerState from "./IndexerState.res.mjs";
-import * as SourceManager from "./sources/SourceManager.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 Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 
-let indexingAddressesName = "envio_indexing_addresses";
+function formatValue(value) {
+  return (Math.round(value * 1000) / 1000).toString();
+}
+
+function escapeLabelValue(value) {
+  if (value.includes("\\") || value.includes("\"") || value.includes("\n")) {
+    return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n");
+  } else {
+    return value;
+  }
+}
+
+function block(b, name, help, kind) {
+  let header = `# HELP ` + name + ` ` + help + `\n# TYPE ` + name + ` ` + kind;
+  b.out = b.out === "" ? header : b.out + "\n\n" + header;
+}
+
+function sample(b, name, labelsOpt, value) {
+  let labels = labelsOpt !== undefined ? labelsOpt : "";
+  b.out = b.out + "\n" + name + labels + " " + (Math.round(value * 1000) / 1000).toString();
+}
+
+function series(b, name, help, kind, entries, value) {
+  block(b, name, help, kind);
+  for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
+    let match = entries[i];
+    sample(b, name, match[0], value(match[1]));
+  }
+}
+
+function seriesOpt(b, name, help, kind, entries, value) {
+  block(b, name, help, kind);
+  for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
+    let match = entries[i];
+    let value$1 = value(match[1]);
+    if (value$1 !== undefined) {
+      sample(b, name, match[0], value$1);
+    }
+  }
+}
 
-let indexingAddressesHelp = "The number of addresses indexed on chain. Includes both static and dynamic addresses.";
+function single(b, name, help, kind, value) {
+  block(b, name, help, kind);
+  sample(b, name, undefined, value);
+}
 
-function renderGauge(name, help, chains, value) {
-  let out = {
-    contents: `# HELP ` + name + ` ` + help + `\n# TYPE ` + name + ` gauge`
+function renderMetrics(b, metrics) {
+  let chains = metrics.chains.map(m => [
+    `{chainId="` + m.chainId.toString() + `"}`,
+    m
+  ]);
+  let handlers = metrics.handlers.map(s => [
+    `{contract="` + escapeLabelValue(s.contract) + `",event="` + escapeLabelValue(s.event) + `"}`,
+    s
+  ]);
+  let effects = metrics.effects.map(s => [
+    `{effect="` + escapeLabelValue(s.effect) + `",scope="` + escapeLabelValue(s.scope) + `"}`,
+    s
+  ]);
+  let storageLoads = metrics.storageLoads.map(s => [
+    `{operation="` + escapeLabelValue(s.operation) + `",storage="` + escapeLabelValue(s.storage) + `"}`,
+    s
+  ]);
+  let storageWrites = metrics.storageWrites.map(s => [
+    `{storage="` + escapeLabelValue(s.storage) + `"}`,
+    s
+  ]);
+  let historyPrunes = metrics.historyPrunes.map(s => [
+    `{entity="` + escapeLabelValue(s.entity) + `"}`,
+    s
+  ]);
+  let byLabels = {};
+  metrics.sourceRequests.forEach(s => {
+    let labels = `{source="` + escapeLabelValue(s.source) + `",chainId="` + s.chainId.toString() + `",method="` + escapeLabelValue(s.method) + `"}`;
+    let existing = byLabels[labels];
+    if (existing !== undefined) {
+      byLabels[labels] = {
+        source: existing.source,
+        chainId: existing.chainId,
+        method: existing.method,
+        count: existing.count + s.count | 0,
+        seconds: existing.seconds + s.seconds
+      };
+    } else {
+      byLabels[labels] = s;
+    }
+  });
+  let sourceRequests = Object.entries(byLabels);
+  let byLabels$1 = {};
+  metrics.sourceHeights.forEach(s => {
+    let labels = `{source="` + escapeLabelValue(s.source) + `",chainId="` + s.chainId.toString() + `"}`;
+    let existing = byLabels$1[labels];
+    if (existing !== undefined && existing >= s.height) {
+      return;
+    } else {
+      byLabels$1[labels] = s.height;
+      return;
+    }
+  });
+  let sources = Object.entries(byLabels$1);
+  single(b, "envio_preload_seconds", "Cumulative time spent on preloading entities during batch processing.", "counter", metrics.preloadSeconds);
+  single(b, "envio_processing_seconds", "Cumulative time spent executing event handlers during batch processing.", "counter", metrics.processingSeconds);
+  series(b, "envio_progress_ready", "Whether the chain is fully synced to the head.", "gauge", chains, m => {
+    if (m.isReady) {
+      return 1;
+    } else {
+      return 0;
+    }
+  });
+  single(b, "hyperindex_synced_to_head", "All chains fully synced", "gauge", Utils.$$Array.notEmpty(metrics.chains) && metrics.chains.every(m => m.isReady) ? 1 : 0);
+  series(b, "envio_processing_handler_seconds", "Cumulative time spent inside individual event handler executions.", "counter", handlers, s => s.processingSeconds);
+  series(b, "envio_processing_handler_total", "Total number of individual event handler executions.", "counter", handlers, s => s.processingCount);
+  series(b, "envio_preload_handler_seconds", "Wall-clock time spent inside individual preload handler executions.", "counter", handlers, s => s.preloadSeconds);
+  series(b, "envio_preload_handler_total", "Total number of individual preload handler executions.", "counter", handlers, s => s.preloadCount);
+  series(b, "envio_preload_handler_seconds_total", "Cumulative time spent inside individual preload handler executions. Can exceed wall-clock time due to parallel execution.", "counter", handlers, s => s.preloadSecondsTotal);
+  series(b, "envio_fetching_block_range_seconds", "Cumulative time spent fetching block ranges.", "counter", chains, m => m.blockRangeFetchSeconds);
+  series(b, "envio_fetching_block_range_parse_seconds", "Cumulative time spent parsing block range fetch responses.", "counter", chains, m => m.blockRangeParseSeconds);
+  series(b, "envio_fetching_block_range_total", "Total number of block range fetch operations.", "counter", chains, m => m.blockRangeFetchCount);
+  series(b, "envio_fetching_block_range_events_total", "Cumulative number of events fetched across all block range operations.", "counter", chains, m => m.blockRangeFetchedEvents);
+  series(b, "envio_fetching_block_range_size", "Cumulative number of blocks covered across all block range fetch operations.", "counter", chains, m => m.blockRangeFetchedBlocks);
+  series(b, "envio_indexing_known_height", "The latest known block number reported by the active indexing source. This value may lag behind the actual chain height, as it is updated only when needed.", "gauge", chains, m => m.sourceBlockNumber);
+  single(b, "envio_process_start_time_seconds", "Start time of the process since unix epoch in seconds.", "gauge", metrics.startTime.getTime() / 1000);
+  series(b, "envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", "gauge", chains, m => m.concurrency);
+  series(b, "envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", "gauge", chains, m => m.partitionsCount);
+  series(b, "envio_indexing_idle_seconds", "The time the indexer source syncing has been idle. A high value may indicate the source sync is a bottleneck.", "counter", chains, m => m.idleSeconds);
+  series(b, "envio_indexing_source_waiting_seconds", "The time the indexer has been waiting for new blocks.", "counter", chains, m => m.waitingForNewBlockSeconds);
+  series(b, "envio_indexing_source_querying_seconds", "The time spent performing queries to the chain data-source.", "counter", chains, m => m.queryingSeconds);
+  series(b, "envio_indexing_buffer_size", "The current number of items in the indexing buffer.", "gauge", chains, m => m.bufferSize);
+  single(b, "envio_indexing_target_buffer_size", "The indexer-wide target buffer size shared across all chains. The actual number of items in the queue may exceed this value, but the indexer always tries to keep the buffer filled up to this target.", "gauge", metrics.targetBufferSize);
+  series(b, "envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", "gauge", chains, m => m.bufferBlockNumber);
+  seriesOpt(b, "envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", "gauge", chains, m => Stdlib_Option.map(m.endBlock, prim => prim));
+  series(b, "envio_source_request_total", "The number of requests made to data sources.", "counter", sourceRequests, s => s.count);
+  seriesOpt(b, "envio_source_request_seconds_total", "Cumulative time spent on data source requests.", "counter", sourceRequests, s => {
+    if (s.seconds !== 0) {
+      return s.seconds;
+    }
+  });
+  series(b, "envio_source_known_height", "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.", "gauge", sources, height => height);
+  seriesOpt(b, "envio_reorg_detected_total", "Total number of reorgs detected", "counter", chains, m => {
+    if (m.reorgCount > 0) {
+      return m.reorgCount;
+    }
+  });
+  seriesOpt(b, "envio_reorg_detected_block", "The block number where reorg was detected the last time. This doesn't mean that the block was reorged, this is simply where we found block hash to be different.", "gauge", chains, m => Stdlib_Option.map(m.reorgDetectedBlock, prim => prim));
+  single(b, "envio_reorg_threshold", "Whether indexing is currently within the reorg threshold", "gauge", metrics.isInReorgThreshold ? 1 : 0);
+  single(b, "envio_rollback_enabled", "Whether rollback on reorg is enabled", "gauge", metrics.rollbackEnabled ? 1 : 0);
+  single(b, "envio_rollback_seconds", "Rollback on reorg total time.", "counter", metrics.rollbackSeconds);
+  single(b, "envio_rollback_total", "Number of successful rollbacks on reorg", "counter", metrics.rollbackCount);
+  single(b, "envio_rollback_events", "Number of events rollbacked on reorg", "counter", metrics.rollbackEventsCount);
+  series(b, "envio_rollback_history_prune_seconds", "The total time spent pruning entity history which is not in the reorg threshold.", "counter", historyPrunes, s => s.seconds);
+  series(b, "envio_rollback_history_prune_total", "Number of successful entity history prunes", "counter", historyPrunes, s => s.count);
+  seriesOpt(b, "envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", "gauge", chains, m => Stdlib_Option.map(m.rollbackTargetBlock, prim => prim));
+  single(b, "envio_processing_max_batch_size", "The maximum number of items to process in a single batch.", "gauge", metrics.maxBatchSize);
+  series(b, "envio_progress_block", "The block number of the latest block processed and stored in the database.", "gauge", chains, m => m.progressBlockNumber);
+  series(b, "envio_progress_events", "The number of events processed and reflected in the database.", "gauge", chains, m => m.numEventsProcessed);
+  seriesOpt(b, "envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", "gauge", chains, m => Stdlib_Option.map(m.progressLatencyMs, prim => prim));
+  let ifCalled = (s, value) => {
+    if (s.callCount > 0 || s.activeCallsCount > 0) {
+      return Primitive_option.some(value);
+    }
   };
-  let prefix = `\n` + name + `{chainId="`;
-  Utils.Dict.forEachWithKey(chains, (chain, chainId) => {
-    out.contents = out.contents + prefix + chainId + `"} ` + value(chain).toString();
+  seriesOpt(b, "envio_effect_call_seconds", "Processing time taken to call the Effect function.", "counter", effects, s => ifCalled(s, s.callSeconds));
+  seriesOpt(b, "envio_effect_call_seconds_total", "Cumulative time spent calling the Effect function during the indexing process.", "counter", effects, s => ifCalled(s, s.callSecondsTotal));
+  seriesOpt(b, "envio_effect_call_total", "Cumulative number of resolved Effect function calls during the indexing process.", "counter", effects, s => ifCalled(s, s.callCount));
+  seriesOpt(b, "envio_effect_active_calls", "The number of Effect function calls that are currently running.", "gauge", effects, s => ifCalled(s, s.activeCallsCount));
+  seriesOpt(b, "envio_effect_cache", "The number of items in the effect cache.", "gauge", effects, s => Stdlib_Option.map(s.cacheCount, prim => prim));
+  let byEffect = {};
+  metrics.effects.forEach(s => {
+    let match = byEffect[s.effect];
+    if (match !== undefined) {
+      byEffect[s.effect] = [
+        match[0] + s.invalidationsCount,
+        match[1] + s.queueWaitSeconds
+      ];
+    } else {
+      byEffect[s.effect] = [
+        s.invalidationsCount,
+        s.queueWaitSeconds
+      ];
+    }
+  });
+  let entries = [];
+  Utils.Dict.forEachWithKey(byEffect, (totals, effect) => {
+    entries.push([
+      `{effect="` + escapeLabelValue(effect) + `"}`,
+      totals
+    ]);
+  });
+  seriesOpt(b, "envio_effect_cache_invalidations", "The number of effect cache invalidations.", "counter", entries, param => {
+    let invalidations = param[0];
+    if (invalidations > 0) {
+      return invalidations;
+    }
+  });
+  seriesOpt(b, "envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", "gauge", effects, s => {
+    if (s.queueCount > 0 || s.queueWaitSeconds > 0) {
+      return s.queueCount;
+    }
   });
-  return out.contents;
+  seriesOpt(b, "envio_effect_queue_wait_seconds", "The time spent waiting in the rate limit queue.", "counter", entries, param => {
+    let queueWaitSeconds = param[1];
+    if (queueWaitSeconds !== 0) {
+      return queueWaitSeconds;
+    }
+  });
+  series(b, "envio_storage_load_seconds", "Processing time taken to load data from storage.", "counter", storageLoads, s => s.seconds);
+  series(b, "envio_storage_load_seconds_total", "Cumulative time spent loading data from storage during the indexing process.", "counter", storageLoads, s => s.secondsTotal);
+  series(b, "envio_storage_load_total", "Cumulative number of successful storage load operations during the indexing process.", "counter", storageLoads, s => s.count);
+  series(b, "envio_storage_load_where_size", "Cumulative number of filter conditions ('where' items) used in storage load operations during the indexing process.", "counter", storageLoads, s => s.whereSize);
+  series(b, "envio_storage_load_size", "Cumulative number of records loaded from storage during the indexing process.", "counter", storageLoads, s => s.size);
+  series(b, "envio_storage_write_seconds", "Cumulative time spent writing batch data to storage.", "counter", storageWrites, s => s.seconds);
+  series(b, "envio_storage_write_total", "Cumulative number of successful storage write operations during the indexing process.", "counter", storageWrites, s => s.count);
+  series(b, "envio_indexing_addresses", "The number of addresses indexed on chain. Includes both static and dynamic addresses.", "gauge", chains, m => m.numAddresses);
 }
 
-let sourceRequestTotalName = "envio_source_request_total";
-
-let sourceRequestTotalHelp = "The number of requests made to data sources.";
+function collect(metrics) {
+  let b = {
+    out: ""
+  };
+  series(b, "envio_info", "Information about the indexer", "gauge", [[
+      `{version="` + escapeLabelValue(Utils.EnvioPackage.value.version) + `"}`,
+      undefined
+    ]], () => 1);
+  if (metrics !== undefined) {
+    renderMetrics(b, metrics);
+  }
+  return b.out + "\n";
+}
 
-let sourceRequestSecondsTotalName = "envio_source_request_seconds_total";
+function gcKindName(kind) {
+  switch (kind) {
+    case 1 :
+      return "minor";
+    case 4 :
+      return "major";
+    case 8 :
+      return "incremental";
+    case 16 :
+      return "weakcb";
+    default:
+      return "unknown";
+  }
+}
 
-let sourceRequestSecondsTotalHelp = "Cumulative time spent on data source requests.";
+let runtimeCollectors = {
+  contents: undefined
+};
 
-function renderSourceRequests(samples) {
-  if (Utils.$$Array.isEmpty(samples)) {
-    return "";
+function getRuntimeCollectors() {
+  let collectors = runtimeCollectors.contents;
+  if (collectors !== undefined) {
+    return collectors;
   }
-  let countOut = {
-    contents: `\n# HELP ` + sourceRequestTotalName + ` ` + sourceRequestTotalHelp + `\n# TYPE ` + sourceRequestTotalName + ` counter`
+  let eventLoopDelay = Perf_hooks.monitorEventLoopDelay({
+    resolution: 10
+  });
+  eventLoopDelay.enable();
+  let gcStats = {};
+  let observer = new Perf_hooks.PerformanceObserver(list => {
+    list.getEntries().forEach(entry => {
+      let kind = gcKindName(entry.detail.kind);
+      let stat = gcStats[kind];
+      let stat$1;
+      if (stat !== undefined) {
+        stat$1 = stat;
+      } else {
+        let stat$2 = {
+          count: 0,
+          seconds: 0
+        };
+        gcStats[kind] = stat$2;
+        stat$1 = stat$2;
+      }
+      stat$1.count = stat$1.count + 1;
+      stat$1.seconds = stat$1.seconds + entry.duration / 1000;
+    });
+  });
+  observer.observe({
+    entryTypes: ["gc"]
+  });
+  let collectors_processStartTimeSeconds = Date.now() / 1000 - Process.uptime();
+  let collectors$1 = {
+    eventLoopDelay: eventLoopDelay,
+    gcStats: gcStats,
+    processStartTimeSeconds: collectors_processStartTimeSeconds
   };
-  let secondsOut = {
-    contents: `\n# HELP ` + sourceRequestSecondsTotalName + ` ` + sourceRequestSecondsTotalHelp + `\n# TYPE ` + sourceRequestSecondsTotalName + ` counter`
+  runtimeCollectors.contents = collectors$1;
+  return collectors$1;
+}
+
+function startRuntimeCollectors() {
+  getRuntimeCollectors();
+}
+
+function collectRuntime() {
+  let b = {
+    out: ""
   };
-  samples.forEach(sample => {
-    let labels = `{source="` + sample.sourceName + `",chainId="` + sample.chainId.toString() + `",method="` + sample.method + `"}`;
-    countOut.contents = countOut.contents + (`\n` + sourceRequestTotalName + labels + ` ` + sample.count.toString());
-    if (sample.seconds !== 0) {
-      secondsOut.contents = secondsOut.contents + (`\n` + sourceRequestSecondsTotalName + labels + ` ` + sample.seconds.toFixed(3));
-      return;
+  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)) {
+      return ns / 1000000000;
+    } else {
+      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;
   });
-  return countOut.contents + secondsOut.contents;
+  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
+    ]);
+  });
+  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);
+  return b.out + "\n";
 }
 
-async function collect(state) {
-  let base = await PromClient.register.metrics();
-  if (state === undefined) {
-    return base;
-  }
-  let chainStates = IndexerState.chainStates(Primitive_option.valFromOption(state));
-  let sourceRequestSamples = Object.values(chainStates).flatMap(cs => SourceManager.getRequestStatSamples(ChainState.sourceManager(cs)));
-  return base + renderGauge(indexingAddressesName, indexingAddressesHelp, chainStates, cs => ChainState.toChainData(cs).numAddresses) + renderSourceRequests(sourceRequestSamples) + `\n`;
-}
+let contentType = "text/plain; version=0.0.4; charset=utf-8";
 
 export {
-  indexingAddressesName,
-  indexingAddressesHelp,
-  renderGauge,
-  sourceRequestTotalName,
-  sourceRequestTotalHelp,
-  sourceRequestSecondsTotalName,
-  sourceRequestSecondsTotalHelp,
-  renderSourceRequests,
+  formatValue,
+  escapeLabelValue,
+  block,
+  sample,
+  series,
+  seriesOpt,
+  single,
+  renderMetrics,
+  contentType,
   collect,
+  gcKindName,
+  runtimeCollectors,
+  getRuntimeCollectors,
+  startRuntimeCollectors,
+  collectRuntime,
 }
-/* Utils Not a pure module */
+/* v8 Not a pure module */

package/src/Persistence.res

@@ -134,6 +134,9 @@ type storage = {
     // Chain metadata stale since the last write, persisted in the same
     // transaction so it never races the batch write.
     ~chainMetaData: option<dict<InternalTable.Chains.metaFields>>,
+    // Reports each underlying storage's write duration (e.g. postgres and a
+    // configured sink separately), accumulated into the write metrics.
+    ~onWrite: (~storage: string, ~timeSeconds: float) => unit,
   ) => promise<unit>,
   // Release any long-lived resources (e.g. the postgres connection pool) so
   // short-lived CLI commands like `db-migrate setup` can exit cleanly.

package/src/PgStorage.res

@@ -1763,6 +1763,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     ~updatedEffectsCache,
     ~updatedEntities,
     ~chainMetaData,
+    ~onWrite,
   ) => {
     let pgUpdates = []
     let chUpdates = []
@@ -1784,10 +1785,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
         Some(
           sink.writeBatch(~batch, ~updatedEntities=chUpdates)
           ->Promise.thenResolve(_ => {
-            Prometheus.StorageWrite.increment(
-              ~storage=sink.name,
-              ~timeSeconds=timerRef->Performance.secondsSince,
-            )
+            onWrite(~storage=sink.name, ~timeSeconds=timerRef->Performance.secondsSince)
             None
           })
           // Otherwise it fails with unhandled exception
@@ -1812,10 +1810,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       ~sinkPromise,
       ~chainMetaData,
     )
-    Prometheus.StorageWrite.increment(
-      ~storage="postgres",
-      ~timeSeconds=primaryTimerRef->Performance.secondsSince,
-    )
+    onWrite(~storage="postgres", ~timeSeconds=primaryTimerRef->Performance.secondsSince)
   }
 
   let close = () => sql->Postgres.endSql

package/src/PgStorage.res.mjs

@@ -13,7 +13,6 @@ import * as Logging from "./Logging.res.mjs";
 import * as Internal from "./Internal.res.mjs";
 import Postgres from "postgres";
 import * as ChainState from "./ChainState.res.mjs";
-import * as Prometheus from "./Prometheus.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as Persistence from "./Persistence.res.mjs";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -1154,7 +1153,7 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
       restoredEntitiesResult
     ];
   };
-  let writeBatchMethod = async (batch, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities, chainMetaData) => {
+  let writeBatchMethod = async (batch, rollback, isInReorgThreshold, config, allEntities, updatedEffectsCache, updatedEntities, chainMetaData, onWrite) => {
     let pgUpdates = [];
     let chUpdates = [];
     for (let i = 0, i_finish = updatedEntities.length; i < i_finish; ++i) {
@@ -1171,14 +1170,14 @@ SELECT id, chain_id, -1, -1, contract_name FROM unnest($1::text[],$2::int[],$3::
     if (sink !== undefined) {
       let timerRef = Performance.now();
       sinkPromise = sink.writeBatch(batch, chUpdates).then(() => {
-        Prometheus.StorageWrite.increment(sink.name, Performance.secondsSince(timerRef));
+        onWrite(sink.name, Performance.secondsSince(timerRef));
       }).catch(exn => exn);
     } else {
       sinkPromise = undefined;
     }
     let primaryTimerRef = Performance.now();
     await writeBatch(sql, batch, pgSchema, rollback, isInReorgThreshold, config, allEntities, setEffectCacheOrThrow, updatedEffectsCache, pgUpdates, sinkPromise, chainMetaData, undefined);
-    return Prometheus.StorageWrite.increment("postgres", Performance.secondsSince(primaryTimerRef));
+    return onWrite("postgres", Performance.secondsSince(primaryTimerRef));
   };
   let close = () => sql.end();
   return {

package/src/PruneStaleHistory.res

@@ -106,7 +106,7 @@ let pruneEntities = async (state: IndexerState.t, ~entities, ~safeCheckpointId)
       ~safeCheckpointId,
     ) {
     | () =>
-      Prometheus.RollbackHistoryPrune.increment(
+      state->IndexerState.recordHistoryPrune(
         ~timeSeconds=Performance.secondsSince(timeRef),
         ~entityName=entityConfig.name,
       )

package/src/PruneStaleHistory.res.mjs

@@ -4,7 +4,6 @@ import * as Env from "./Env.res.mjs";
 import * as Utils from "./Utils.res.mjs";
 import * as Config from "./Config.res.mjs";
 import * as Logging from "./Logging.res.mjs";
-import * as Prometheus from "./Prometheus.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
@@ -80,7 +79,7 @@ async function pruneEntities(state, entities, safeCheckpointId) {
       }), Utils.prettifyExn(exn), `Failed to prune stale entity history`);
     }
     if (exit === 1) {
-      Prometheus.RollbackHistoryPrune.increment(Performance.secondsSince(timeRef), entityConfig.name);
+      IndexerState.recordHistoryPrune(state, entityConfig.name, Performance.secondsSince(timeRef));
     }
   }
 }

package/src/Rollback.res

@@ -107,10 +107,9 @@ and executeRollback = async (
     },
   )
   logger->Logging.childInfo("Started rollback on reorg")
-  Prometheus.RollbackTargetBlockNumber.set(
-    ~blockNumber=rollbackTargetBlockNumber,
-    ~chain=reorgChain,
-  )
+  state
+  ->IndexerState.getChainState(~chain=reorgChain)
+  ->ChainState.setRollbackTargetBlock(~blockNumber=rollbackTargetBlockNumber)
 
   let reorgChainId = reorgChain->ChainMap.Chain.toChainId
 
@@ -212,7 +211,7 @@ and executeRollback = async (
     "deleted": diff["deletedEntities"],
     "upserted": diff["setEntities"],
   })
-  Prometheus.RollbackSuccess.increment(
+  state->IndexerState.recordRollbackSuccess(
     ~timeSeconds=Performance.secondsSince(startTime),
     ~rollbackedProcessedEvents=rollbackedProcessedEvents.contents,
   )

package/src/Rollback.res.mjs

@@ -4,7 +4,6 @@ import * as Utils from "./Utils.res.mjs";
 import * as Logging from "./Logging.res.mjs";
 import * as Writing from "./Writing.res.mjs";
 import * as ChainState from "./ChainState.res.mjs";
-import * as Prometheus from "./Prometheus.res.mjs";
 import * as Performance from "./bindings/Performance.res.mjs";
 import * as IndexerState from "./IndexerState.res.mjs";
 import * as Stdlib_Float from "@rescript/runtime/lib/es6/Stdlib_Float.js";
@@ -39,7 +38,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     targetBlockNumber: rollbackTargetBlockNumber
   });
   Logging.childInfo(logger, "Started rollback on reorg");
-  Prometheus.RollbackTargetBlockNumber.set(rollbackTargetBlockNumber, reorgChain);
+  ChainState.setRollbackTargetBlock(IndexerState.getChainState(state, reorgChain), rollbackTargetBlockNumber);
   await Writing.flush(state);
   let checkpointId = await IndexerState.persistence(state).storage.getRollbackTargetCheckpoint(reorgChain, rollbackTargetBlockNumber);
   let rollbackTargetCheckpointId = checkpointId !== undefined ? checkpointId : 0n;
@@ -83,7 +82,7 @@ async function executeRollback(state, reorgChain, rollbackTargetBlockNumber, sch
     deleted: diff$1.deletedEntities,
     upserted: diff$1.setEntities
   });
-  Prometheus.RollbackSuccess.increment(Performance.secondsSince(startTime), rollbackedProcessedEvents);
+  IndexerState.recordRollbackSuccess(state, Performance.secondsSince(startTime), rollbackedProcessedEvents);
   IndexerState.completeRollback(state, eventsProcessedDiffByChain);
   scheduleFetch();
   return scheduleProcessing();

package/src/SimulateItems.res.mjs

@@ -323,27 +323,9 @@ function patchConfig(config, processConfig, registrationsByChainId) {
     };
     return newrecord$1;
   });
-  return {
-    name: config.name,
-    description: config.description,
-    handlers: config.handlers,
-    contractHandlers: config.contractHandlers,
-    shouldRollbackOnReorg: config.shouldRollbackOnReorg,
-    shouldSaveFullHistory: config.shouldSaveFullHistory,
-    storage: config.storage,
-    chainMap: newChainMap,
-    defaultChain: config.defaultChain,
-    ecosystem: config.ecosystem,
-    enableRawEvents: config.enableRawEvents,
-    maxAddrInPartition: config.maxAddrInPartition,
-    batchSize: config.batchSize,
-    lowercaseAddresses: config.lowercaseAddresses,
-    isDev: config.isDev,
-    userEntitiesByName: config.userEntitiesByName,
-    userEntities: config.userEntities,
-    allEntities: config.allEntities,
-    allEnums: config.allEnums
-  };
+  let newrecord = {...config};
+  newrecord.chainMap = newChainMap;
+  return newrecord;
 }
 
 export {