envio 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/Prometheus.res.mjs

@@ -4,52 +4,9 @@ import * as Utils from "./Utils.res.mjs";
 import * as Hrtime from "./bindings/Hrtime.res.mjs";
 import * as Js_exn from "rescript/lib/es6/js_exn.js";
 import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
-import * as Belt_Result from "rescript/lib/es6/belt_Result.js";
 import * as PromClient from "prom-client";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
 
-var loadEntitiesDurationCounter = new PromClient.Counter({
-      name: "load_entities_processing_time_spent",
-      help: "Duration spend on loading entities",
-      labelNames: []
-    });
-
-var eventRouterDurationCounter = new PromClient.Counter({
-      name: "event_router_processing_time_spent",
-      help: "Duration spend on event routing",
-      labelNames: []
-    });
-
-var executeBatchDurationCounter = new PromClient.Counter({
-      name: "execute_batch_processing_time_spent",
-      help: "Duration spend on executing batch",
-      labelNames: []
-    });
-
-var storageWriteTimeCounter = new PromClient.Counter({
-      name: "envio_storage_write_time",
-      help: "Cumulative time spent writing batches to storage in milliseconds",
-      labelNames: []
-    });
-
-var storageWriteCounter = new PromClient.Counter({
-      name: "envio_storage_write_count",
-      help: "Total number of batch writes to storage",
-      labelNames: []
-    });
-
-var allChainsSyncedToHead = new PromClient.Gauge({
-      name: "hyperindex_synced_to_head",
-      help: "All chains fully synced",
-      labelNames: []
-    });
-
-var sourceChainHeight = new PromClient.Gauge({
-      name: "chain_block_height",
-      help: "Chain Height of Source Chain",
-      labelNames: ["chainId"]
-    });
-
 function schemaIsString(_schema) {
   while(true) {
     var schema = _schema;
@@ -249,127 +206,188 @@ var SafeGauge = {
   incrementMany: incrementMany$1
 };
 
-function makeSafeHistogramOrThrow(name, help, labelSchema, backets) {
-  var histogram = new PromClient.Histogram({
-        name: name,
-        help: help,
-        labelNames: Belt_Result.getExn(getLabelNames(labelSchema)),
-        buckets: backets
-      });
-  return function (labels) {
-    return histogram.labels(S$RescriptSchema.reverseConvertToJsonOrThrow(labels, labelSchema)).startTimer();
-  };
-}
+var loadTimeCounter = new PromClient.Counter({
+      name: "envio_preload_seconds",
+      help: "Cumulative time spent on preloading entities during batch processing."
+    });
 
-var labelSchema = S$RescriptSchema.schema(function (s) {
-      return {
-              group: s.m(S$RescriptSchema.string),
-              stat: s.m(S$RescriptSchema.string),
-              label: s.m(S$RescriptSchema.string)
-            };
+var handlerTimeCounter = new PromClient.Counter({
+      name: "envio_processing_seconds",
+      help: "Cumulative time spent executing event handlers during batch processing."
     });
 
-var gauge = makeOrThrow$1("benchmark_summary_data", "All data points collected during indexer benchmark", labelSchema);
-
-function set(group, label, n, mean, stdDev, min, max, sum) {
-  handleFloat$1(gauge, {
-        group: group,
-        stat: "n",
-        label: label
-      }, n);
-  handleFloat$1(gauge, {
-        group: group,
-        stat: "mean",
-        label: label
-      }, mean);
-  handleFloat$1(gauge, {
-        group: group,
-        stat: "min",
-        label: label
-      }, min);
-  handleFloat$1(gauge, {
-        group: group,
-        stat: "max",
-        label: label
-      }, max);
-  handleFloat$1(gauge, {
-        group: group,
-        stat: "sum",
-        label: label
-      }, sum);
-  if (stdDev !== undefined) {
-    return handleFloat$1(gauge, {
-                group: group,
-                stat: "stdDev",
-                label: label
-              }, stdDev);
-  }
-  
+var writeTimeCounter = new PromClient.Counter({
+      name: "envio_storage_write_seconds",
+      help: "Cumulative time spent writing batch data to storage."
+    });
+
+var writeCount = new PromClient.Counter({
+      name: "envio_storage_write_total",
+      help: "Total number of batch writes to storage."
+    });
+
+function registerMetrics(loadDuration, handlerDuration, dbWriteDuration) {
+  loadTimeCounter.inc(loadDuration);
+  handlerTimeCounter.inc(handlerDuration);
+  writeTimeCounter.inc(dbWriteDuration);
+  writeCount.inc();
 }
 
-var BenchmarkSummaryData = {
-  labelSchema: labelSchema,
-  gauge: gauge,
-  set: set
+var ProcessingBatch = {
+  loadTimeCounter: loadTimeCounter,
+  handlerTimeCounter: handlerTimeCounter,
+  writeTimeCounter: writeTimeCounter,
+  writeCount: writeCount,
+  registerMetrics: registerMetrics
 };
 
-function incrementLoadEntityDurationCounter(duration) {
-  loadEntitiesDurationCounter.inc(duration);
+var chainIdLabelsSchema = S$RescriptSchema.object(function (s) {
+      return s.f("chainId", S$RescriptSchema.coerce(S$RescriptSchema.string, S$RescriptSchema.$$int));
+    });
+
+var gauge = makeOrThrow$1("envio_progress_ready", "Whether the chain is fully synced to the head.", chainIdLabelsSchema);
+
+var legacyGauge = new PromClient.Gauge({
+      name: "hyperindex_synced_to_head",
+      help: "All chains fully synced"
+    });
+
+function init(chainId) {
+  handleInt$1(gauge, chainId, 0);
 }
 
-function incrementEventRouterDurationCounter(duration) {
-  eventRouterDurationCounter.inc(duration);
+function set(chainId) {
+  handleInt$1(gauge, chainId, 1);
 }
 
-function incrementExecuteBatchDurationCounter(duration) {
-  executeBatchDurationCounter.inc(duration);
+function setAllReady() {
+  legacyGauge.set(1);
 }
 
-function incrementStorageWriteTimeCounter(duration) {
-  storageWriteTimeCounter.inc(duration);
+var ProgressReady = {
+  gauge: gauge,
+  legacyGauge: legacyGauge,
+  init: init,
+  set: set,
+  setAllReady: setAllReady
+};
+
+var handlerLabelsSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              contract: s.m(S$RescriptSchema.string),
+              event: s.m(S$RescriptSchema.string)
+            };
+    });
+
+var timeCounter = makeOrThrow("envio_processing_handler_seconds", "Cumulative time spent inside individual event handler executions.", handlerLabelsSchema);
+
+var count = makeOrThrow("envio_processing_handler_total", "Total number of individual event handler executions.", handlerLabelsSchema);
+
+function increment$2(contract, $$event, duration) {
+  var labels = {
+    contract: contract,
+    event: $$event
+  };
+  handleFloat(timeCounter, labels, duration);
+  increment(count, labels);
 }
 
-function incrementStorageWriteCounter() {
-  storageWriteCounter.inc();
+var ProcessingHandler = {
+  timeCounter: timeCounter,
+  count: count,
+  increment: increment$2
+};
+
+var timeCounter$1 = makeOrThrow("envio_preload_handler_seconds", "Wall-clock time spent inside individual preload handler executions.", handlerLabelsSchema);
+
+var count$1 = makeOrThrow("envio_preload_handler_total", "Total number of individual preload handler executions.", handlerLabelsSchema);
+
+var sumTimeCounter = makeOrThrow("envio_preload_handler_seconds_total", "Cumulative time spent inside individual preload handler executions. Can exceed wall-clock time due to parallel execution.", handlerLabelsSchema);
+
+var operations = {};
+
+function makeKey(contract, $$event) {
+  return contract + ":" + $$event;
 }
 
-function setSourceChainHeight(blockNumber, chainId) {
-  sourceChainHeight.labels({
-          chainId: chainId
-        }).set(blockNumber);
+function startOperation(contract, $$event) {
+  var key = makeKey(contract, $$event);
+  var operationRef = operations[key];
+  if (operationRef !== undefined) {
+    operationRef.pendingCount = operationRef.pendingCount + 1 | 0;
+  } else {
+    operations[key] = {
+      pendingCount: 1,
+      timerRef: Hrtime.makeTimer()
+    };
+  }
+  return Hrtime.makeTimer();
 }
 
-function setAllChainsSyncedToHead() {
-  allChainsSyncedToHead.set(1);
+function endOperation(timerRef, contract, $$event) {
+  var key = makeKey(contract, $$event);
+  var labels = {
+    contract: contract,
+    event: $$event
+  };
+  var operationRef = operations[key];
+  operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
+  if (operationRef.pendingCount === 0) {
+    handleFloat(timeCounter$1, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(operationRef.timerRef)));
+    Utils.Dict.deleteInPlace(operations, key);
+  }
+  handleFloat(sumTimeCounter, labels, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+  increment(count$1, labels);
 }
 
-var labelSchema$1 = S$RescriptSchema.schema(function (s) {
-      return {
-              label: s.m(S$RescriptSchema.string)
-            };
-    });
+var PreloadHandler = {
+  timeCounter: timeCounter$1,
+  count: count$1,
+  sumTimeCounter: sumTimeCounter,
+  operations: operations,
+  makeKey: makeKey,
+  startOperation: startOperation,
+  endOperation: endOperation
+};
 
-var gauge$1 = makeOrThrow$1("benchmark_counters", "All counters collected during indexer benchmark", labelSchema$1);
+var timeCounter$2 = makeOrThrow("envio_fetching_block_range_seconds", "Cumulative time spent fetching block ranges.", chainIdLabelsSchema);
 
-function set$1(label, millis, totalRuntimeMillis) {
-  handleFloat$1(gauge$1, {
-        label: label
-      }, millis);
-  handleFloat$1(gauge$1, {
-        label: "Total Run Time (ms)"
-      }, totalRuntimeMillis);
+var parseTimeCounter = makeOrThrow("envio_fetching_block_range_parse_seconds", "Cumulative time spent parsing block range fetch responses.", chainIdLabelsSchema);
+
+var count$2 = makeOrThrow("envio_fetching_block_range_total", "Total number of block range fetch operations.", chainIdLabelsSchema);
+
+var eventsCount = makeOrThrow("envio_fetching_block_range_events_total", "Cumulative number of events fetched across all block range operations.", chainIdLabelsSchema);
+
+var sizeCounter = makeOrThrow("envio_fetching_block_range_size", "Cumulative number of blocks covered across all block range fetch operations.", chainIdLabelsSchema);
+
+function increment$3(chainId, totalTimeElapsed, parsingTimeElapsed, numEvents, blockRangeSize) {
+  handleFloat(timeCounter$2, chainId, totalTimeElapsed);
+  handleFloat(parseTimeCounter, chainId, parsingTimeElapsed);
+  increment(count$2, chainId);
+  handleInt(eventsCount, chainId, numEvents);
+  handleInt(sizeCounter, chainId, blockRangeSize);
 }
 
-var BenchmarkCounters = {
-  labelSchema: labelSchema$1,
+var FetchingBlockRange = {
+  timeCounter: timeCounter$2,
+  parseTimeCounter: parseTimeCounter,
+  count: count$2,
+  eventsCount: eventsCount,
+  sizeCounter: sizeCounter,
+  increment: increment$3
+};
+
+var gauge$1 = makeOrThrow$1("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.", chainIdLabelsSchema);
+
+function set$1(blockNumber, chainId) {
+  handleInt$1(gauge$1, chainId, blockNumber);
+}
+
+var IndexingKnownHeight = {
   gauge: gauge$1,
   set: set$1
 };
 
-var chainIdLabelsSchema = S$RescriptSchema.object(function (s) {
-      return s.f("chainId", S$RescriptSchema.coerce(S$RescriptSchema.string, S$RescriptSchema.$$int));
-    });
-
 var gauge$2 = makeOrThrow$1("envio_info", "Information about the indexer", S$RescriptSchema.schema(function (s) {
           return {
                   version: s.m(S$RescriptSchema.string)
@@ -387,123 +405,127 @@ var Info = {
   set: set$2
 };
 
-var gauge$3 = makeOrThrow$1("envio_indexing_addresses", "The number of addresses indexed on chain. Includes both static and dynamic addresses.", chainIdLabelsSchema);
+var gauge$3 = new PromClient.Gauge({
+      name: "envio_process_start_time_seconds",
+      help: "Start time of the process since unix epoch in seconds."
+    });
 
-function set$3(addressesCount, chainId) {
-  handleInt$1(gauge$3, chainId, addressesCount);
+function set$3() {
+  gauge$3.set(Date.now() / 1000.0);
 }
 
-var IndexingAddresses = {
+var ProcessStartTimeSeconds = {
   gauge: gauge$3,
   set: set$3
 };
 
-var gauge$4 = makeOrThrow$1("envio_indexing_max_concurrency", "The maximum number of concurrent queries to the chain data-source.", chainIdLabelsSchema);
+var gauge$4 = makeOrThrow$1("envio_indexing_addresses", "The number of addresses indexed on chain. Includes both static and dynamic addresses.", chainIdLabelsSchema);
 
-function set$4(maxConcurrency, chainId) {
-  handleInt$1(gauge$4, chainId, maxConcurrency);
+function set$4(addressesCount, chainId) {
+  handleInt$1(gauge$4, chainId, addressesCount);
 }
 
-var IndexingMaxConcurrency = {
+var IndexingAddresses = {
   gauge: gauge$4,
   set: set$4
 };
 
-var gauge$5 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
+var gauge$5 = makeOrThrow$1("envio_indexing_max_concurrency", "The maximum number of concurrent queries to the chain data-source.", chainIdLabelsSchema);
 
-function set$5(concurrency, chainId) {
-  handleInt$1(gauge$5, chainId, concurrency);
+function set$5(maxConcurrency, chainId) {
+  handleInt$1(gauge$5, chainId, maxConcurrency);
 }
 
-var IndexingConcurrency = {
+var IndexingMaxConcurrency = {
   gauge: gauge$5,
   set: set$5
 };
 
-var gauge$6 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
+var gauge$6 = makeOrThrow$1("envio_indexing_concurrency", "The number of executing concurrent queries to the chain data-source.", chainIdLabelsSchema);
 
-function set$6(partitionsCount, chainId) {
-  handleInt$1(gauge$6, chainId, partitionsCount);
+function set$6(concurrency, chainId) {
+  handleInt$1(gauge$6, chainId, concurrency);
 }
 
-var IndexingPartitions = {
+var IndexingConcurrency = {
   gauge: gauge$6,
   set: set$6
 };
 
-var counter = makeOrThrow("envio_indexing_idle_time", "The number of milliseconds the indexer source syncing has been idle. A high value may indicate the source sync is a bottleneck.", chainIdLabelsSchema);
+var gauge$7 = makeOrThrow$1("envio_indexing_partitions", "The number of partitions used to split fetching logic by addresses and block ranges.", chainIdLabelsSchema);
+
+function set$7(partitionsCount, chainId) {
+  handleInt$1(gauge$7, chainId, partitionsCount);
+}
+
+var IndexingPartitions = {
+  gauge: gauge$7,
+  set: set$7
+};
+
+var counter = makeOrThrow("envio_indexing_idle_seconds", "The time the indexer source syncing has been idle. A high value may indicate the source sync is a bottleneck.", chainIdLabelsSchema);
 
 var IndexingIdleTime = {
   counter: counter
 };
 
-var counter$1 = makeOrThrow("envio_indexing_source_waiting_time", "The number of milliseconds the indexer has been waiting for new blocks.", chainIdLabelsSchema);
+var counter$1 = makeOrThrow("envio_indexing_source_waiting_seconds", "The time the indexer has been waiting for new blocks.", chainIdLabelsSchema);
 
 var IndexingSourceWaitingTime = {
   counter: counter$1
 };
 
-var counter$2 = makeOrThrow("envio_indexing_query_time", "The number of milliseconds spent performing queries to the chain data-source.", chainIdLabelsSchema);
+var counter$2 = makeOrThrow("envio_indexing_source_querying_seconds", "The time spent performing queries to the chain data-source.", chainIdLabelsSchema);
 
 var IndexingQueryTime = {
   counter: counter$2
 };
 
-var gauge$7 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
+var gauge$8 = makeOrThrow$1("envio_indexing_buffer_size", "The current number of items in the indexing buffer.", chainIdLabelsSchema);
 
-function set$7(bufferSize, chainId) {
-  handleInt$1(gauge$7, chainId, bufferSize);
+function set$8(bufferSize, chainId) {
+  handleInt$1(gauge$8, chainId, bufferSize);
 }
 
 var IndexingBufferSize = {
-  gauge: gauge$7,
-  set: set$7
+  gauge: gauge$8,
+  set: set$8
 };
 
-var gauge$8 = new PromClient.Gauge({
+var gauge$9 = new PromClient.Gauge({
       name: "envio_indexing_target_buffer_size",
       help: "The target buffer size per chain for indexing. 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."
     });
 
-function set$8(targetBufferSize) {
-  gauge$8.set(targetBufferSize);
+function set$9(targetBufferSize) {
+  gauge$9.set(targetBufferSize);
 }
 
 var IndexingTargetBufferSize = {
-  gauge: gauge$8,
-  set: set$8
+  gauge: gauge$9,
+  set: set$9
 };
 
-var deprecatedGauge = new PromClient.Gauge({
-      name: "chain_block_height_fully_fetched",
-      help: "Block height fully fetched by indexer",
-      labelNames: ["chainId"]
-    });
-
-var gauge$9 = makeOrThrow$1("envio_indexing_buffer_block_number", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
+var gauge$10 = makeOrThrow$1("envio_indexing_buffer_block", "The highest block number that has been fully fetched by the indexer.", chainIdLabelsSchema);
 
-function set$9(blockNumber, chainId) {
-  deprecatedGauge.labels({
-          chainId: chainId
-        }).set(blockNumber);
-  handleInt$1(gauge$9, chainId, blockNumber);
+function set$10(blockNumber, chainId) {
+  handleInt$1(gauge$10, chainId, blockNumber);
 }
 
 var IndexingBufferBlockNumber = {
-  deprecatedGauge: deprecatedGauge,
-  gauge: gauge$9,
-  set: set$9
+  gauge: gauge$10,
+  set: set$10
 };
 
-var gauge$10 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
+var gauge$11 = makeOrThrow$1("envio_indexing_end_block", "The block number to stop indexing at. (inclusive)", chainIdLabelsSchema);
 
-function set$10(endBlock, chainId) {
-  handleInt$1(gauge$10, chainId, endBlock);
+function set$11(endBlock, chainId) {
+  handleInt$1(gauge$11, chainId, endBlock);
 }
 
 var IndexingEndBlock = {
-  gauge: gauge$10,
-  set: set$10
+  gauge: gauge$11,
+  set: set$11
 };
 
 var sourceLabelsSchema = S$RescriptSchema.schema(function (s) {
@@ -513,51 +535,75 @@ var sourceLabelsSchema = S$RescriptSchema.schema(function (s) {
             };
     });
 
-var gauge$11 = makeOrThrow$1("envio_source_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.", sourceLabelsSchema);
+var sourceRequestLabelsSchema = S$RescriptSchema.schema(function (s) {
+      return {
+              source: s.m(S$RescriptSchema.string),
+              chainId: s.m(S$RescriptSchema.coerce(S$RescriptSchema.string, S$RescriptSchema.$$int)),
+              method: s.m(S$RescriptSchema.string)
+            };
+    });
+
+var counter$3 = makeOrThrow("envio_source_request_total", "The number of requests made to data sources.", sourceRequestLabelsSchema);
 
-function set$11(sourceName, chainId, blockNumber) {
-  handleInt$1(gauge$11, {
+var sumTimeCounter$1 = makeOrThrow("envio_source_request_seconds_total", "Cumulative time spent on data source requests.", sourceRequestLabelsSchema);
+
+function increment$4(sourceName, chainId, method) {
+  increment(counter$3, {
         source: sourceName,
-        chainId: chainId
-      }, blockNumber);
+        chainId: chainId,
+        method: method
+      });
 }
 
-var SourceHeight = {
-  gauge: gauge$11,
-  set: set$11
+function addSeconds(sourceName, chainId, method, seconds) {
+  handleFloat(sumTimeCounter$1, {
+        source: sourceName,
+        chainId: chainId,
+        method: method
+      }, seconds);
+}
+
+var SourceRequestCount = {
+  counter: counter$3,
+  sumTimeCounter: sumTimeCounter$1,
+  increment: increment$4,
+  addSeconds: addSeconds
 };
 
-var startTimer = makeSafeHistogramOrThrow("envio_source_get_height_duration", "Duration of the source get height requests in seconds", sourceLabelsSchema, [
-      0.1,
-      0.5,
-      1,
-      10
-    ]);
+var gauge$12 = makeOrThrow$1("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.", sourceLabelsSchema);
+
+function set$12(sourceName, chainId, blockNumber) {
+  handleInt$1(gauge$12, {
+        source: sourceName,
+        chainId: chainId
+      }, blockNumber);
+}
 
-var SourceGetHeightDuration = {
-  startTimer: startTimer
+var SourceHeight = {
+  gauge: gauge$12,
+  set: set$12
 };
 
-var gauge$12 = makeOrThrow$1("envio_reorg_count", "Total number of reorgs detected", chainIdLabelsSchema);
+var counter$4 = makeOrThrow("envio_reorg_detected_total", "Total number of reorgs detected", chainIdLabelsSchema);
 
-function increment$2(chain) {
-  increment$1(gauge$12, chain);
+function increment$5(chain) {
+  increment(counter$4, chain);
 }
 
 var ReorgCount = {
-  gauge: gauge$12,
-  increment: increment$2
+  counter: counter$4,
+  increment: increment$5
 };
 
-var gauge$13 = makeOrThrow$1("envio_reorg_detection_block_number", "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.", chainIdLabelsSchema);
+var gauge$13 = makeOrThrow$1("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.", chainIdLabelsSchema);
 
-function set$12(blockNumber, chain) {
+function set$13(blockNumber, chain) {
   handleInt$1(gauge$13, chain, blockNumber);
 }
 
 var ReorgDetectionBlockNumber = {
   gauge: gauge$13,
-  set: set$12
+  set: set$13
 };
 
 var gauge$14 = new PromClient.Gauge({
@@ -565,13 +611,13 @@ var gauge$14 = new PromClient.Gauge({
       help: "Whether indexing is currently within the reorg threshold"
     });
 
-function set$13(isInReorgThreshold) {
+function set$14(isInReorgThreshold) {
   gauge$14.set(isInReorgThreshold ? 1 : 0);
 }
 
 var ReorgThreshold = {
   gauge: gauge$14,
-  set: set$13
+  set: set$14
 };
 
 var gauge$15 = new PromClient.Gauge({
@@ -579,72 +625,72 @@ var gauge$15 = new PromClient.Gauge({
       help: "Whether rollback on reorg is enabled"
     });
 
-function set$14(enabled) {
+function set$15(enabled) {
   gauge$15.set(enabled ? 1 : 0);
 }
 
 var RollbackEnabled = {
   gauge: gauge$15,
-  set: set$14
+  set: set$15
 };
 
-var timeCounter = new PromClient.Counter({
-      name: "envio_rollback_time",
-      help: "Rollback on reorg total time in milliseconds"
+var timeCounter$3 = new PromClient.Counter({
+      name: "envio_rollback_seconds",
+      help: "Rollback on reorg total time."
     });
 
-var counter$3 = new PromClient.Counter({
-      name: "envio_rollback_count",
+var counter$5 = new PromClient.Counter({
+      name: "envio_rollback_total",
       help: "Number of successful rollbacks on reorg"
     });
 
 var eventsCounter = new PromClient.Counter({
-      name: "envio_rollback_events_count",
+      name: "envio_rollback_events",
       help: "Number of events rollbacked on reorg"
     });
 
-function increment$3(timeMillis, rollbackedProcessedEvents) {
-  timeCounter.inc(Hrtime.intFromMillis(timeMillis));
-  counter$3.inc();
-  eventsCounter.inc(rollbackedProcessedEvents);
+function increment$6(timeSeconds, rollbackedProcessedEvents) {
+  timeCounter$3.inc(timeSeconds);
+  counter$5.inc();
+  eventsCounter.inc(Math.trunc(rollbackedProcessedEvents));
 }
 
 var RollbackSuccess = {
-  timeCounter: timeCounter,
-  counter: counter$3,
+  timeCounter: timeCounter$3,
+  counter: counter$5,
   eventsCounter: eventsCounter,
-  increment: increment$3
+  increment: increment$6
 };
 
 var entityNameLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("entity", S$RescriptSchema.string);
     });
 
-var timeCounter$1 = makeOrThrow("envio_rollback_history_prune_time", "The total time spent pruning entity history which is not in the reorg threshold. (milliseconds)", entityNameLabelsSchema);
+var timeCounter$4 = makeOrThrow("envio_rollback_history_prune_seconds", "The total time spent pruning entity history which is not in the reorg threshold.", entityNameLabelsSchema);
 
-var counter$4 = makeOrThrow("envio_rollback_history_prune_count", "Number of successful entity history prunes", entityNameLabelsSchema);
+var counter$6 = makeOrThrow("envio_rollback_history_prune_total", "Number of successful entity history prunes", entityNameLabelsSchema);
 
-function increment$4(timeMillis, entityName) {
-  handleInt(timeCounter$1, entityName, Hrtime.intFromMillis(timeMillis));
-  increment(counter$4, entityName);
+function increment$7(timeSeconds, entityName) {
+  handleFloat(timeCounter$4, entityName, timeSeconds);
+  increment(counter$6, entityName);
 }
 
 var RollbackHistoryPrune = {
   entityNameLabelsSchema: entityNameLabelsSchema,
-  timeCounter: timeCounter$1,
-  counter: counter$4,
-  increment: increment$4
+  timeCounter: timeCounter$4,
+  counter: counter$6,
+  increment: increment$7
 };
 
-var gauge$16 = makeOrThrow$1("envio_rollback_target_block_number", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
+var gauge$16 = makeOrThrow$1("envio_rollback_target_block", "The block number reorg was rollbacked to the last time.", chainIdLabelsSchema);
 
-function set$15(blockNumber, chain) {
+function set$16(blockNumber, chain) {
   handleInt$1(gauge$16, chain, blockNumber);
 }
 
 var RollbackTargetBlockNumber = {
   gauge: gauge$16,
-  set: set$15
+  set: set$16
 };
 
 var gauge$17 = new PromClient.Gauge({
@@ -652,149 +698,125 @@ var gauge$17 = new PromClient.Gauge({
       help: "The maximum number of items to process in a single batch."
     });
 
-function set$16(maxBatchSize) {
+function set$17(maxBatchSize) {
   gauge$17.set(maxBatchSize);
 }
 
 var ProcessingMaxBatchSize = {
   gauge: gauge$17,
-  set: set$16
+  set: set$17
 };
 
-var gauge$18 = makeOrThrow$1("envio_progress_block_number", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
+var gauge$18 = makeOrThrow$1("envio_progress_block", "The block number of the latest block processed and stored in the database.", chainIdLabelsSchema);
 
-function set$17(blockNumber, chainId) {
+function set$18(blockNumber, chainId) {
   handleInt$1(gauge$18, chainId, blockNumber);
 }
 
 var ProgressBlockNumber = {
   gauge: gauge$18,
-  set: set$17
+  set: set$18
 };
 
-var deprecatedGauge$1 = new PromClient.Gauge({
-      name: "events_processed",
-      help: "Total number of events processed",
-      labelNames: ["chainId"]
-    });
-
-var gauge$19 = makeOrThrow$1("envio_progress_events_count", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
+var gauge$19 = makeOrThrow$1("envio_progress_events", "The number of events processed and reflected in the database.", chainIdLabelsSchema);
 
-function set$18(processedCount, chainId) {
-  deprecatedGauge$1.labels({
-          chainId: chainId
-        }).set(processedCount);
-  handleInt$1(gauge$19, chainId, processedCount);
+function set$19(processedCount, chainId) {
+  handleFloat$1(gauge$19, chainId, processedCount);
 }
 
 var ProgressEventsCount = {
-  deprecatedGauge: deprecatedGauge$1,
   gauge: gauge$19,
-  set: set$18
-};
-
-var counter$5 = new PromClient.Counter({
-      name: "envio_progress_batches_count",
-      help: "The number of batches processed and reflected in the database."
-    });
-
-function increment$5() {
-  counter$5.inc();
-}
-
-var ProgressBatchCount = {
-  counter: counter$5,
-  increment: increment$5
+  set: set$19
 };
 
 var gauge$20 = makeOrThrow$1("envio_progress_latency", "The latency in milliseconds between the latest processed event creation and the time it was written to storage.", chainIdLabelsSchema);
 
-function set$19(latencyMs, chainId) {
+function set$20(latencyMs, chainId) {
   handleInt$1(gauge$20, chainId, latencyMs);
 }
 
 var ProgressLatency = {
   gauge: gauge$20,
-  set: set$19
+  set: set$20
 };
 
 var effectLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("effect", S$RescriptSchema.string);
     });
 
-var timeCounter$2 = makeOrThrow("envio_effect_calls_time", "Processing time taken to call the Effect function. (milliseconds)", effectLabelsSchema);
+var timeCounter$5 = makeOrThrow("envio_effect_call_seconds", "Processing time taken to call the Effect function.", effectLabelsSchema);
 
-var sumTimeCounter = makeOrThrow("envio_effect_calls_sum_time", "Cumulative time spent calling the Effect function during the indexing process. (milliseconds)", effectLabelsSchema);
+var sumTimeCounter$2 = makeOrThrow("envio_effect_call_seconds_total", "Cumulative time spent calling the Effect function during the indexing process.", effectLabelsSchema);
 
-var totalCallsCount = makeOrThrow("envio_effect_calls_count", "Cumulative number of resolved Effect function calls during the indexing process.", effectLabelsSchema);
+var totalCallsCount = makeOrThrow("envio_effect_call_total", "Cumulative number of resolved Effect function calls during the indexing process.", effectLabelsSchema);
 
-var activeCallsCount = makeOrThrow$1("envio_effect_active_calls_count", "The number of Effect function calls that are currently running.", effectLabelsSchema);
+var activeCallsCount = makeOrThrow$1("envio_effect_active_calls", "The number of Effect function calls that are currently running.", effectLabelsSchema);
 
 var EffectCalls = {
-  timeCounter: timeCounter$2,
-  sumTimeCounter: sumTimeCounter,
+  timeCounter: timeCounter$5,
+  sumTimeCounter: sumTimeCounter$2,
   totalCallsCount: totalCallsCount,
   activeCallsCount: activeCallsCount
 };
 
-var gauge$21 = makeOrThrow$1("envio_effect_cache_count", "The number of items in the effect cache.", effectLabelsSchema);
+var gauge$21 = makeOrThrow$1("envio_effect_cache", "The number of items in the effect cache.", effectLabelsSchema);
 
-function set$20(count, effectName) {
+function set$21(count, effectName) {
   handleInt$1(gauge$21, effectName, count);
 }
 
 var EffectCacheCount = {
   gauge: gauge$21,
-  set: set$20
+  set: set$21
 };
 
-var counter$6 = makeOrThrow("envio_effect_cache_invalidations_count", "The number of effect cache invalidations.", effectLabelsSchema);
+var counter$7 = makeOrThrow("envio_effect_cache_invalidations", "The number of effect cache invalidations.", effectLabelsSchema);
 
-function increment$6(effectName) {
-  increment(counter$6, effectName);
+function increment$8(effectName) {
+  increment(counter$7, effectName);
 }
 
 var EffectCacheInvalidationsCount = {
-  counter: counter$6,
-  increment: increment$6
+  counter: counter$7,
+  increment: increment$8
 };
 
-var gauge$22 = makeOrThrow$1("envio_effect_queue_count", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
+var gauge$22 = makeOrThrow$1("envio_effect_queue", "The number of effect calls waiting in the rate limit queue.", effectLabelsSchema);
 
-var timeCounter$3 = makeOrThrow("envio_effect_queue_time", "The time spent waiting in the rate limit queue. (milliseconds)", effectLabelsSchema);
+var timeCounter$6 = makeOrThrow("envio_effect_queue_wait_seconds", "The time spent waiting in the rate limit queue.", effectLabelsSchema);
 
-function set$21(count, effectName) {
+function set$22(count, effectName) {
   handleInt$1(gauge$22, effectName, count);
 }
 
 var EffectQueueCount = {
   gauge: gauge$22,
-  timeCounter: timeCounter$3,
-  set: set$21
+  timeCounter: timeCounter$6,
+  set: set$22
 };
 
 var operationLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("operation", S$RescriptSchema.string);
     });
 
-var timeCounter$4 = makeOrThrow("envio_storage_load_time", "Processing time taken to load data from storage. (milliseconds)", operationLabelsSchema);
+var timeCounter$7 = makeOrThrow("envio_storage_load_seconds", "Processing time taken to load data from storage.", operationLabelsSchema);
 
-var sumTimeCounter$1 = makeOrThrow("envio_storage_load_sum_time", "Cumulative time spent loading data from storage during the indexing process. (milliseconds)", operationLabelsSchema);
+var sumTimeCounter$3 = makeOrThrow("envio_storage_load_seconds_total", "Cumulative time spent loading data from storage during the indexing process.", operationLabelsSchema);
 
-var counter$7 = makeOrThrow("envio_storage_load_count", "Cumulative number of successful storage load operations during the indexing process.", operationLabelsSchema);
+var counter$8 = makeOrThrow("envio_storage_load_total", "Cumulative number of successful storage load operations during the indexing process.", operationLabelsSchema);
 
 var whereSizeCounter = makeOrThrow("envio_storage_load_where_size", "Cumulative number of filter conditions ('where' items) used in storage load operations during the indexing process.", operationLabelsSchema);
 
-var sizeCounter = makeOrThrow("envio_storage_load_size", "Cumulative number of records loaded from storage during the indexing process.", operationLabelsSchema);
+var sizeCounter$1 = makeOrThrow("envio_storage_load_size", "Cumulative number of records loaded from storage during the indexing process.", operationLabelsSchema);
 
-var operations = {};
+var operations$1 = {};
 
-function startOperation(operation) {
-  var operationRef = operations[operation];
+function startOperation$1(operation) {
+  var operationRef = operations$1[operation];
   if (operationRef !== undefined) {
     operationRef.pendingCount = operationRef.pendingCount + 1 | 0;
   } else {
-    operations[operation] = {
+    operations$1[operation] = {
       pendingCount: 1,
       timerRef: Hrtime.makeTimer()
     };
@@ -802,76 +824,67 @@ function startOperation(operation) {
   return Hrtime.makeTimer();
 }
 
-function endOperation(timerRef, operation, whereSize, size) {
-  var operationRef = operations[operation];
+function endOperation$1(timerRef, operation, whereSize, size) {
+  var operationRef = operations$1[operation];
   operationRef.pendingCount = operationRef.pendingCount - 1 | 0;
   if (operationRef.pendingCount === 0) {
-    handleInt(timeCounter$4, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(operationRef.timerRef))));
-    Utils.Dict.deleteInPlace(operations, operation);
+    handleFloat(timeCounter$7, operation, Hrtime.toSecondsFloat(Hrtime.timeSince(operationRef.timerRef)));
+    Utils.Dict.deleteInPlace(operations$1, operation);
   }
-  handleInt(sumTimeCounter$1, operation, Hrtime.intFromMillis(Hrtime.toMillis(Hrtime.timeSince(timerRef))));
-  increment(counter$7, operation);
+  handleFloat(sumTimeCounter$3, operation, Hrtime.toSecondsFloat(Hrtime.timeSince(timerRef)));
+  increment(counter$8, operation);
   handleInt(whereSizeCounter, operation, whereSize);
-  handleInt(sizeCounter, operation, size);
+  handleInt(sizeCounter$1, operation, size);
 }
 
 var StorageLoad = {
   operationLabelsSchema: operationLabelsSchema,
-  timeCounter: timeCounter$4,
-  sumTimeCounter: sumTimeCounter$1,
-  counter: counter$7,
+  timeCounter: timeCounter$7,
+  sumTimeCounter: sumTimeCounter$3,
+  counter: counter$8,
   whereSizeCounter: whereSizeCounter,
-  sizeCounter: sizeCounter,
-  operations: operations,
-  startOperation: startOperation,
-  endOperation: endOperation
+  sizeCounter: sizeCounter$1,
+  operations: operations$1,
+  startOperation: startOperation$1,
+  endOperation: endOperation$1
 };
 
 var sinkLabelsSchema = S$RescriptSchema.object(function (s) {
       return s.f("sink", S$RescriptSchema.string);
     });
 
-var timeCounter$5 = makeOrThrow("envio_sink_write_time", "Processing time taken to write data to sink. (milliseconds)", sinkLabelsSchema);
+var timeCounter$8 = makeOrThrow("envio_sink_write_seconds", "Processing time taken to write data to sink.", sinkLabelsSchema);
 
-var counter$8 = makeOrThrow("envio_sink_write_count", "Cumulative number of successful sink write operations during the indexing process.", sinkLabelsSchema);
+var counter$9 = makeOrThrow("envio_sink_write_total", "Cumulative number of successful sink write operations during the indexing process.", sinkLabelsSchema);
 
-function increment$7(sinkName, timeMillis) {
-  handleInt(timeCounter$5, sinkName, timeMillis);
-  increment(counter$8, sinkName);
+function increment$9(sinkName, timeSeconds) {
+  handleFloat(timeCounter$8, sinkName, timeSeconds);
+  increment(counter$9, sinkName);
 }
 
 var SinkWrite = {
   sinkLabelsSchema: sinkLabelsSchema,
-  timeCounter: timeCounter$5,
-  counter: counter$8,
-  increment: increment$7
+  timeCounter: timeCounter$8,
+  counter: counter$9,
+  increment: increment$9
 };
 
 export {
-  loadEntitiesDurationCounter ,
-  eventRouterDurationCounter ,
-  executeBatchDurationCounter ,
-  storageWriteTimeCounter ,
-  storageWriteCounter ,
-  allChainsSyncedToHead ,
-  sourceChainHeight ,
   Labels ,
   metricNames ,
   MakeSafePromMetric ,
   SafeCounter ,
   SafeGauge ,
-  makeSafeHistogramOrThrow ,
-  BenchmarkSummaryData ,
-  incrementLoadEntityDurationCounter ,
-  incrementEventRouterDurationCounter ,
-  incrementExecuteBatchDurationCounter ,
-  incrementStorageWriteTimeCounter ,
-  incrementStorageWriteCounter ,
-  setSourceChainHeight ,
-  setAllChainsSyncedToHead ,
-  BenchmarkCounters ,
+  ProcessingBatch ,
   chainIdLabelsSchema ,
+  ProgressReady ,
+  handlerLabelsSchema ,
+  ProcessingHandler ,
+  PreloadHandler ,
+  FetchingBlockRange ,
+  IndexingKnownHeight ,
   Info ,
+  ProcessStartTimeSeconds ,
   IndexingAddresses ,
   IndexingMaxConcurrency ,
   IndexingConcurrency ,
@@ -884,8 +897,9 @@ export {
   IndexingBufferBlockNumber ,
   IndexingEndBlock ,
   sourceLabelsSchema ,
+  sourceRequestLabelsSchema ,
+  SourceRequestCount ,
   SourceHeight ,
-  SourceGetHeightDuration ,
   ReorgCount ,
   ReorgDetectionBlockNumber ,
   ReorgThreshold ,
@@ -896,7 +910,6 @@ export {
   ProcessingMaxBatchSize ,
   ProgressBlockNumber ,
   ProgressEventsCount ,
-  ProgressBatchCount ,
   ProgressLatency ,
   effectLabelsSchema ,
   EffectCalls ,
@@ -906,4 +919,4 @@ export {
   StorageLoad ,
   SinkWrite ,
 }
-/* loadEntitiesDurationCounter Not a pure module */
+/* metricNames Not a pure module */