@mikeatlast/ponder 0.16.1-fork.1

package/dist/esm/internal/metrics.js

@@ -0,0 +1,1049 @@
+import { parentPort } from "node:worker_threads";
+import { promiseWithResolvers, } from '../utils/promiseWithResolvers.js';
+import { truncate } from '../utils/truncate.js';
+import { getTableName, isTable } from "drizzle-orm";
+import prometheus from "prom-client";
+const sometimesIODurationMs = [
+    0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10, 50, 100, 500, 1000, 5000,
+    10000, 50000, 100000,
+];
+const alwaysIODurationMs = [
+    1, 5, 10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000, 500000,
+];
+const httpRequestSizeBytes = [
+    10, 100, 1000, 5000, 10000, 50000, 100000, 500000, 1000000, 5000000,
+    10000000,
+];
+const GET_METRICS_REQ = "prom-client:getMetricsReq";
+const GET_METRICS_RES = "prom-client:getMetricsRes";
+export class MetricsService {
+    constructor() {
+        Object.defineProperty(this, "registry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "start_timestamp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "progressMetadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "hasError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "port", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "rps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_version_info", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_settings_info", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_concurrency_group_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_extract_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_transform_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_start_timestamp_seconds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_end_timestamp_seconds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_total_indexing_seconds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_cached_indexing_seconds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_completed_indexing_seconds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_timestamp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_completed_events", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_function_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_cache_requests_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_cache_query_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_rpc_action_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_rpc_prefetch_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_rpc_requests_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_store_queries_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_indexing_store_raw_sql_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_sync_block", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_sync_block_timestamp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_sync_is_realtime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_sync_is_complete", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_total_blocks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_cached_blocks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_historical_completed_blocks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_realtime_reorg_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_realtime_latency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_realtime_block_arrival_latency", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_database_method_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_database_method_error_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_http_server_active_requests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_http_server_request_duration_ms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_http_server_request_size_bytes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_http_server_response_size_bytes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_rpc_request_duration", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_rpc_request_error_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_postgres_query_total", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ponder_postgres_query_queue_size", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "ponder_postgres_pool_connections", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.registry = new prometheus.Registry();
+        this.start_timestamp = Date.now();
+        this.progressMetadata = {
+            general: {
+                batches: [{ elapsedSeconds: 0, completedSeconds: 0 }],
+                previousTimestamp: Date.now(),
+                previousCompletedSeconds: 0,
+                rate: 0,
+            },
+        };
+        this.port = undefined;
+        this.hasError = false;
+        this.rps = {};
+        this.ponder_version_info = new prometheus.Gauge({
+            name: "ponder_version_info",
+            help: "Ponder version information",
+            labelNames: ["version", "major", "minor", "patch"],
+            registers: [this.registry],
+            aggregator: "first",
+        });
+        this.ponder_settings_info = new prometheus.Gauge({
+            name: "ponder_settings_info",
+            help: "Ponder settings information",
+            labelNames: ["ordering", "database", "command"],
+            registers: [this.registry],
+            aggregator: "first",
+        });
+        this.ponder_historical_concurrency_group_duration = new prometheus.Gauge({
+            name: "ponder_historical_concurrency_group_duration",
+            help: "Duration of historical concurrency groups",
+            labelNames: ["group"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_historical_extract_duration = new prometheus.Gauge({
+            name: "ponder_historical_extract_duration",
+            help: "Duration of historical extract phase",
+            labelNames: ["step"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_historical_transform_duration = new prometheus.Gauge({
+            name: "ponder_historical_transform_duration",
+            help: "Duration of historical transform phase",
+            labelNames: ["step"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_historical_start_timestamp_seconds = new prometheus.Gauge({
+            name: "ponder_historical_start_timestamp_seconds",
+            help: "Timestamp at which historical indexing started",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "min",
+        });
+        this.ponder_historical_end_timestamp_seconds = new prometheus.Gauge({
+            name: "ponder_historical_end_timestamp_seconds",
+            help: "Timestamp at which historical indexing ended",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "max",
+        });
+        this.ponder_historical_total_indexing_seconds = new prometheus.Gauge({
+            name: "ponder_historical_total_indexing_seconds",
+            help: "Total number of seconds that are required",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_historical_cached_indexing_seconds = new prometheus.Gauge({
+            name: "ponder_historical_cached_indexing_seconds",
+            help: "Number of seconds that have been cached",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_historical_completed_indexing_seconds = new prometheus.Gauge({
+            name: "ponder_historical_completed_indexing_seconds",
+            help: "Number of seconds that have been completed",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_completed_events = new prometheus.Gauge({
+            name: "ponder_indexing_completed_events",
+            help: "Number of events that have been processed",
+            labelNames: ["chain", "event"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_timestamp = new prometheus.Gauge({
+            name: "ponder_indexing_timestamp",
+            help: "Timestamp through which all events have been completed",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "first",
+        });
+        this.ponder_indexing_function_duration = new prometheus.Histogram({
+            name: "ponder_indexing_function_duration",
+            help: "Duration of indexing function execution",
+            labelNames: ["chain", "event"],
+            buckets: sometimesIODurationMs,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_cache_query_duration = new prometheus.Histogram({
+            name: "ponder_indexing_cache_query_duration",
+            help: "Duration of cache operations",
+            labelNames: ["table", "method"],
+            buckets: alwaysIODurationMs,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_rpc_action_duration = new prometheus.Histogram({
+            name: "ponder_indexing_rpc_action_duration",
+            help: "Duration of RPC actions",
+            labelNames: ["action"],
+            buckets: sometimesIODurationMs,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_rpc_prefetch_total = new prometheus.Counter({
+            name: "ponder_indexing_rpc_prefetch_total",
+            help: "Number of RPC prefetches",
+            labelNames: ["chain", "method", "type"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_rpc_requests_total = new prometheus.Counter({
+            name: "ponder_indexing_rpc_requests_total",
+            help: "Number of RPC requests",
+            labelNames: ["chain", "method", "type"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_cache_requests_total = new prometheus.Counter({
+            name: "ponder_indexing_cache_requests_total",
+            help: "Number of cache accesses",
+            labelNames: ["table", "type"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_store_queries_total = new prometheus.Counter({
+            name: "ponder_indexing_store_queries_total",
+            help: "Number of indexing store operations",
+            labelNames: ["table", "method"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_indexing_store_raw_sql_duration = new prometheus.Histogram({
+            name: "ponder_indexing_store_raw_sql_duration",
+            help: "Duration of raw SQL store operations",
+            buckets: alwaysIODurationMs,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_sync_block = new prometheus.Gauge({
+            name: "ponder_sync_block",
+            help: "Closest-to-tip synced block number",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "max",
+        });
+        this.ponder_sync_block_timestamp = new prometheus.Gauge({
+            name: "ponder_sync_block_timestamp",
+            help: "Closest-to-tip synced block timestamp",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "max",
+        });
+        this.ponder_sync_is_realtime = new prometheus.Gauge({
+            name: "ponder_sync_is_realtime",
+            help: "Boolean (0 or 1) indicating if the sync is realtime mode",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "max",
+        });
+        this.ponder_sync_is_complete = new prometheus.Gauge({
+            name: "ponder_sync_is_complete",
+            help: "Boolean (0 or 1) indicating if the sync has synced all blocks",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "max",
+        });
+        this.ponder_historical_total_blocks = new prometheus.Gauge({
+            name: "ponder_historical_total_blocks",
+            help: "Number of blocks required for the historical sync",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "max",
+        });
+        this.ponder_historical_cached_blocks = new prometheus.Gauge({
+            name: "ponder_historical_cached_blocks",
+            help: "Number of blocks that were found in the cache for the historical sync",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "max",
+        });
+        this.ponder_historical_completed_blocks = new prometheus.Gauge({
+            name: "ponder_historical_completed_blocks",
+            help: "Number of blocks that have been processed for the historical sync",
+            labelNames: ["chain", "source", "type"],
+            registers: [this.registry],
+            aggregator: "max",
+        });
+        this.ponder_realtime_reorg_total = new prometheus.Counter({
+            name: "ponder_realtime_reorg_total",
+            help: "Count of how many re-orgs have occurred",
+            labelNames: ["chain"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_realtime_latency = new prometheus.Histogram({
+            name: "ponder_realtime_latency",
+            help: "Time elapsed between receiving a block and fully processing it",
+            labelNames: ["chain"],
+            buckets: [
+                1, 5, 10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000, 500000,
+                1000000,
+            ],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_realtime_block_arrival_latency = new prometheus.Histogram({
+            name: "ponder_realtime_block_arrival_latency",
+            help: "Time elapsed between mining a block and being received by the realtime sync",
+            labelNames: ["chain"],
+            buckets: [
+                1, 5, 10, 50, 100, 500, 1000, 5000, 10000, 50000, 100000, 500000,
+                1000000,
+            ],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_database_method_duration = new prometheus.Histogram({
+            name: "ponder_database_method_duration",
+            help: "Duration of database operations",
+            labelNames: ["service", "method"],
+            buckets: alwaysIODurationMs,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_database_method_error_total = new prometheus.Counter({
+            name: "ponder_database_method_error_total",
+            help: "Total number of errors encountered during database operations",
+            labelNames: ["service", "method"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_http_server_active_requests = new prometheus.Gauge({
+            name: "ponder_http_server_active_requests",
+            help: "Number of active HTTP server requests",
+            labelNames: ["method", "path"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_http_server_request_duration_ms = new prometheus.Histogram({
+            name: "ponder_http_server_request_duration_ms",
+            help: "Duration of HTTP responses served the server",
+            labelNames: ["method", "path", "status"],
+            buckets: alwaysIODurationMs,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_http_server_request_size_bytes = new prometheus.Histogram({
+            name: "ponder_http_server_request_size_bytes",
+            help: "Size of HTTP requests received by the server",
+            labelNames: ["method", "path", "status"],
+            buckets: httpRequestSizeBytes,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_http_server_response_size_bytes = new prometheus.Histogram({
+            name: "ponder_http_server_response_size_bytes",
+            help: "Size of HTTP responses served the server",
+            labelNames: ["method", "path", "status"],
+            buckets: httpRequestSizeBytes,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_rpc_request_duration = new prometheus.Histogram({
+            name: "ponder_rpc_request_duration",
+            help: "Duration of successful RPC requests",
+            labelNames: ["chain", "method"],
+            buckets: alwaysIODurationMs,
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_rpc_request_error_total = new prometheus.Counter({
+            name: "ponder_rpc_request_error_total",
+            help: "Total count of failed RPC requests",
+            labelNames: ["chain", "method"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        this.ponder_postgres_query_total = new prometheus.Counter({
+            name: "ponder_postgres_query_total",
+            help: "Total number of queries submitted to the database",
+            labelNames: ["pool"],
+            registers: [this.registry],
+            aggregator: "sum",
+        });
+        if (!("bun" in process.versions))
+            prometheus.collectDefaultMetrics({
+                register: this.registry,
+                eventLoopMonitoringPrecision: 1,
+                gcDurationBuckets: [
+                    0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10,
+                ],
+            });
+    }
+    /**
+     * Get string representation for all metrics.
+     * @returns Metrics encoded using Prometheus v0.0.4 format.
+     */
+    getMetrics() {
+        return this.registry.metrics();
+    }
+    async getRegistry() {
+        return this.registry;
+    }
+    initializeIndexingMetrics({ indexingBuild, schemaBuild, }) {
+        const tables = Object.values(schemaBuild.schema).filter(isTable);
+        for (const { name: eventName } of indexingBuild.indexingFunctions) {
+            this.ponder_indexing_completed_events.inc({ event: eventName }, 0);
+        }
+        for (const table of tables) {
+            for (const type of ["complete", "hit", "miss", "prefetch"]) {
+                this.ponder_indexing_cache_requests_total.inc({ table: getTableName(table), type }, 0);
+            }
+            for (const method of ["find", "insert", "update", "delete"]) {
+                this.ponder_indexing_store_queries_total.inc({ table: getTableName(table), method }, 0);
+            }
+        }
+    }
+    resetIndexingMetrics() {
+        this.start_timestamp = Date.now();
+        this.rps = {};
+        this.progressMetadata = {
+            general: {
+                batches: [{ elapsedSeconds: 0, completedSeconds: 0 }],
+                previousTimestamp: Date.now(),
+                previousCompletedSeconds: 0,
+                rate: 0,
+            },
+        };
+        this.hasError = false;
+        this.ponder_settings_info.reset();
+        this.ponder_historical_start_timestamp_seconds.reset();
+        this.ponder_historical_end_timestamp_seconds.reset();
+        this.ponder_historical_total_indexing_seconds.reset();
+        this.ponder_historical_cached_indexing_seconds.reset();
+        this.ponder_historical_completed_indexing_seconds.reset();
+        this.ponder_indexing_completed_events.reset();
+        this.ponder_indexing_timestamp.reset();
+        this.ponder_indexing_function_duration.reset();
+        this.ponder_sync_block.reset();
+        this.ponder_sync_is_realtime.reset();
+        this.ponder_sync_is_complete.reset();
+        this.ponder_historical_total_blocks.reset();
+        this.ponder_historical_cached_blocks.reset();
+        this.ponder_historical_completed_blocks.reset();
+        this.ponder_realtime_reorg_total.reset();
+        this.ponder_rpc_request_duration.reset();
+        this.ponder_rpc_request_error_total.reset();
+        // Note: These are used by both indexing and API services.
+        this.ponder_database_method_duration.reset();
+        this.ponder_database_method_error_total.reset();
+        this.ponder_postgres_pool_connections?.reset();
+        this.ponder_postgres_query_queue_size?.reset();
+        this.ponder_postgres_query_total?.reset();
+    }
+    resetApiMetrics() {
+        this.port = undefined;
+        // TODO: Create a separate metric for API build errors,
+        // or stop using metrics for the TUI error message.
+        this.hasError = false;
+        this.ponder_http_server_active_requests.reset();
+        this.ponder_http_server_request_duration_ms.reset();
+        this.ponder_http_server_request_size_bytes.reset();
+        this.ponder_http_server_response_size_bytes.reset();
+    }
+}
+export class AggregateMetricsService extends MetricsService {
+    constructor(mainThreadMetrics, workers) {
+        super();
+        Object.defineProperty(this, "workers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "requests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "requestId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "mainThreadMetrics", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.mainThreadMetrics = mainThreadMetrics;
+        this.workers = workers;
+        this.requests = new Map();
+        this.requestId = 0;
+        for (const worker of workers) {
+            worker.on("message", (message) => {
+                if (message.type === GET_METRICS_RES) {
+                    const request = this.requests.get(message.requestId);
+                    if (request === undefined)
+                        return;
+                    if (message.error) {
+                        request.pwr.reject(new Error(message.error));
+                        return;
+                    }
+                    request.responses.push(message.metrics);
+                    request.workerIds.push(worker.threadId);
+                    request.pending--;
+                    if (request.pending === 0) {
+                        request.pwr.resolve();
+                    }
+                }
+            });
+        }
+    }
+    async getMetrics() {
+        const requestId = this.requestId++;
+        const pwr = promiseWithResolvers();
+        this.requests.set(requestId, {
+            responses: [],
+            workerIds: [],
+            pending: this.workers.length,
+            pwr,
+        });
+        for (const worker of this.workers) {
+            worker.postMessage({
+                type: GET_METRICS_REQ,
+                requestId,
+            });
+        }
+        await pwr.promise;
+        const request = this.requests.get(requestId);
+        this.requests.delete(requestId);
+        // Sort response by worker id for consistent metrics
+        const responseIndexSort = new Array(this.workers.length)
+            .fill(0)
+            .map((_, index) => index)
+            .sort((a, b) => request.workerIds[a] - request.workerIds[b]);
+        return prometheus.AggregatorRegistry.aggregate([
+            ...responseIndexSort.map((index) => request.responses[index]),
+            await this.registry.getMetricsAsJSON(),
+            await this.mainThreadMetrics.registry.getMetricsAsJSON(),
+        ]).metrics();
+    }
+    async getRegistry() {
+        const requestId = this.requestId++;
+        const pwr = promiseWithResolvers();
+        this.requests.set(requestId, {
+            responses: [],
+            workerIds: [],
+            pending: this.workers.length,
+            pwr,
+        });
+        for (const worker of this.workers) {
+            worker.postMessage({
+                type: GET_METRICS_REQ,
+                requestId,
+            });
+        }
+        await pwr.promise;
+        const request = this.requests.get(requestId);
+        this.requests.delete(requestId);
+        // Sort response by worker id for consistent metrics
+        const responseIndexSort = new Array(this.workers.length)
+            .fill(0)
+            .map((_, index) => index)
+            .sort((a, b) => request.workerIds[a] - request.workerIds[b]);
+        return prometheus.AggregatorRegistry.aggregate([
+            ...responseIndexSort.map((index) => request.responses[index]),
+            await this.registry.getMetricsAsJSON(),
+            await this.mainThreadMetrics.registry.getMetricsAsJSON(),
+        ]);
+    }
+}
+export class IsolatedMetricsService extends MetricsService {
+    constructor() {
+        super();
+        if (parentPort) {
+            parentPort.on("message", (message) => {
+                if (message.type === GET_METRICS_REQ) {
+                    this.registry
+                        .getMetricsAsJSON()
+                        .then((metrics) => {
+                        parentPort.postMessage({
+                            type: GET_METRICS_RES,
+                            requestId: message.requestId,
+                            metrics,
+                        });
+                    })
+                        .catch((error) => {
+                        parentPort.postMessage({
+                            type: GET_METRICS_RES,
+                            requestId: message.requestId,
+                            error: error.message,
+                        });
+                    });
+                }
+            });
+        }
+    }
+}
+const extractMetric = (metric, chain) => {
+    return metric.values.find((m) => m.labels.chain === chain)?.value;
+};
+export async function getSyncProgress(metrics) {
+    const totalBlocksMetric = await metrics.ponder_historical_total_blocks.get();
+    const cachedBlocksMetric = await metrics.ponder_historical_cached_blocks.get();
+    const completedBlocksMetric = await metrics.ponder_historical_completed_blocks.get();
+    const syncBlockMetric = await metrics.ponder_sync_block.get();
+    const syncIsRealtimeMetrics = await metrics.ponder_sync_is_realtime.get();
+    const syncIsCompleteMetrics = await metrics.ponder_sync_is_complete.get();
+    const requestCount = {};
+    const rpcRequestMetrics = await metrics.ponder_rpc_request_duration.get();
+    for (const m of rpcRequestMetrics.values) {
+        const chain = m.labels.chain;
+        if (m.metricName === "ponder_rpc_request_duration_count") {
+            if (requestCount[chain] === undefined) {
+                requestCount[chain] = 0;
+            }
+            requestCount[m.labels.chain] += m.value;
+        }
+    }
+    for (const [chainName, count] of Object.entries(requestCount)) {
+        if (metrics.rps[chainName] === undefined) {
+            metrics.rps[chainName] = [{ count, timestamp: Date.now() }];
+        }
+        else {
+            metrics.rps[chainName].push({ count, timestamp: Date.now() });
+        }
+        if (metrics.rps[chainName].length > 100) {
+            metrics.rps[chainName].shift();
+        }
+    }
+    return totalBlocksMetric.values.map(({ value, labels }) => {
+        const chain = labels.chain;
+        const totalBlocks = value;
+        const cachedBlocks = extractMetric(cachedBlocksMetric, chain) ?? 0;
+        const completedBlocks = extractMetric(completedBlocksMetric, chain) ?? 0;
+        const syncBlock = extractMetric(syncBlockMetric, chain);
+        const isRealtime = extractMetric(syncIsRealtimeMetrics, chain);
+        const isComplete = extractMetric(syncIsCompleteMetrics, chain);
+        const progress = totalBlocks === 0 ? 1 : (completedBlocks + cachedBlocks) / totalBlocks;
+        const _length = metrics.rps[labels.chain].length;
+        const _firstRps = metrics.rps[labels.chain][0];
+        const _lastRps = metrics.rps[labels.chain][_length - 1];
+        const requests = _lastRps.count - (_length > 1 ? _firstRps.count : 0);
+        const seconds = _length === 1 ? 0.1 : (_lastRps.timestamp - _firstRps.timestamp) / 1000;
+        return {
+            chainName: chain,
+            block: syncBlock,
+            progress,
+            status: isComplete ? "complete" : isRealtime ? "live" : "backfill",
+            rps: requests / seconds,
+        };
+    });
+}
+export async function getIndexingProgress(metrics) {
+    const indexingCompletedEventsMetric = (await metrics.ponder_indexing_completed_events.get()).values;
+    const indexingFunctionDurationMetric = (await metrics.ponder_indexing_function_duration.get()).values;
+    const indexingDurationSum = {};
+    const indexingDurationCount = {};
+    for (const m of indexingFunctionDurationMetric) {
+        if (m.metricName === "ponder_indexing_function_duration_sum")
+            indexingDurationSum[m.labels.event] = m.value;
+        if (m.metricName === "ponder_indexing_function_duration_count")
+            indexingDurationCount[m.labels.event] = m.value;
+    }
+    const events = indexingCompletedEventsMetric.map((m) => {
+        const count = m.value;
+        const durationSum = indexingDurationSum[m.labels.event] ?? 0;
+        const durationCount = indexingDurationCount[m.labels.event] ?? 0;
+        const averageDuration = durationCount === 0 ? 0 : durationSum / durationCount;
+        const eventName = truncate(m.labels.event);
+        return { eventName, count, averageDuration };
+    });
+    return {
+        hasError: metrics.hasError,
+        events,
+    };
+}
+export async function getAppProgress(metrics) {
+    // Note: `getRegistry` must be used because this function is used with "experimental_isolated" ordering.
+    const registry = await metrics.getRegistry();
+    const totalSecondsMetric = await registry
+        .getSingleMetric("ponder_historical_total_indexing_seconds")
+        .get();
+    const cachedSecondsMetric = await registry
+        .getSingleMetric("ponder_historical_cached_indexing_seconds")
+        .get();
+    const completedSecondsMetric = await registry
+        .getSingleMetric("ponder_historical_completed_indexing_seconds")
+        .get();
+    const timestampMetric = await registry
+        .getSingleMetric("ponder_indexing_timestamp")
+        .get();
+    const settingsMetric = await registry
+        .getSingleMetric("ponder_settings_info")
+        .get();
+    const ordering = settingsMetric?.values[0]
+        ?.labels.ordering;
+    switch (ordering) {
+        case undefined:
+            return {
+                mode: "backfill",
+                progress: undefined,
+                eta: undefined,
+            };
+        case "omnichain": {
+            const totalSeconds = totalSecondsMetric?.values
+                .map(({ value }) => value)
+                .reduce((prev, curr) => prev + curr, 0);
+            const cachedSeconds = cachedSecondsMetric?.values
+                .map(({ value }) => value)
+                .reduce((prev, curr) => prev + curr, 0);
+            const completedSeconds = completedSecondsMetric?.values
+                .map(({ value }) => value)
+                .reduce((prev, curr) => prev + curr, 0);
+            const timestamp = timestampMetric?.values
+                .map(({ value }) => value)
+                .reduce((prev, curr) => Math.max(prev, curr), 0);
+            const progress = timestamp === 0
+                ? 0
+                : totalSeconds === 0
+                    ? 1
+                    : (completedSeconds + cachedSeconds) / totalSeconds;
+            return {
+                mode: progress === 1 ? "live" : "backfill",
+                progress: progress,
+                eta: calculateEta(metrics.progressMetadata.general, totalSeconds, cachedSeconds, completedSeconds),
+            };
+        }
+        case "multichain":
+        case "experimental_isolated": {
+            const perChainAppProgress = [];
+            for (const chainName of totalSecondsMetric?.values.map(({ labels }) => labels.chain) ?? []) {
+                const totalSeconds = extractMetric(totalSecondsMetric, chainName);
+                const cachedSeconds = extractMetric(cachedSecondsMetric, chainName);
+                const completedSeconds = extractMetric(completedSecondsMetric, chainName);
+                const timestamp = extractMetric(timestampMetric, chainName);
+                if (totalSeconds === undefined ||
+                    cachedSeconds === undefined ||
+                    completedSeconds === undefined ||
+                    timestamp === undefined) {
+                    continue;
+                }
+                const progress = timestamp === 0
+                    ? 0
+                    : totalSeconds === 0
+                        ? 1
+                        : (completedSeconds + cachedSeconds) / totalSeconds;
+                if (!metrics.progressMetadata[chainName]) {
+                    metrics.progressMetadata[chainName] = {
+                        batches: [{ elapsedSeconds: 0, completedSeconds: 0 }],
+                        previousTimestamp: Date.now(),
+                        previousCompletedSeconds: 0,
+                        rate: 0,
+                    };
+                }
+                const eta = calculateEta(metrics.progressMetadata[chainName], totalSeconds, cachedSeconds, completedSeconds);
+                perChainAppProgress.push({
+                    mode: progress === 1 ? "live" : "backfill",
+                    progress,
+                    eta,
+                });
+            }
+            return perChainAppProgress.reduce((prev, curr) => ({
+                mode: curr.mode === "backfill" ? curr.mode : prev.mode,
+                progress: prev.progress === undefined || curr.progress === undefined
+                    ? undefined
+                    : Math.min(prev.progress, curr.progress),
+                eta: curr.progress === 1
+                    ? prev.eta
+                    : prev.eta === undefined || curr.eta === undefined
+                        ? undefined
+                        : Math.max(prev.eta, curr.eta),
+            }), {
+                mode: "live",
+                progress: 1,
+                eta: 0,
+            });
+        }
+    }
+}
+function calculateEta(progressMetadata, totalSeconds, cachedSeconds, completedSeconds) {
+    const remainingSeconds = Math.max(totalSeconds - (completedSeconds + cachedSeconds), 0);
+    let eta = undefined;
+    if (completedSeconds > 0) {
+        const currentTimestamp = Date.now();
+        progressMetadata.batches.at(-1).elapsedSeconds =
+            Math.max(currentTimestamp - progressMetadata.previousTimestamp, 0) /
+                1000;
+        progressMetadata.batches.at(-1).completedSeconds = Math.max(completedSeconds - progressMetadata.previousCompletedSeconds, 0);
+        if (currentTimestamp - progressMetadata.previousTimestamp > 5000 &&
+            progressMetadata.batches.at(-1).completedSeconds > 0) {
+            progressMetadata.batches.push({
+                elapsedSeconds: 0,
+                completedSeconds: 0,
+            });
+            if (progressMetadata.batches.length > 10) {
+                progressMetadata.batches.shift();
+            }
+            progressMetadata.previousCompletedSeconds = completedSeconds;
+            progressMetadata.previousTimestamp = currentTimestamp;
+            const averages = [];
+            let count = 0;
+            // Note: Calculate ETA only after at least 3 batches were collected for stable eta.
+            if (progressMetadata.batches.length >= 3) {
+                for (let i = 0; i < progressMetadata.batches.length - 1; ++i) {
+                    const batch = progressMetadata.batches[i];
+                    if (batch.completedSeconds === 0)
+                        continue;
+                    const multiplier = 1 / 1.5 ** (9 - i);
+                    averages.push((multiplier * batch.elapsedSeconds) / batch.completedSeconds);
+                    count += multiplier;
+                }
+                progressMetadata.rate =
+                    count === 0
+                        ? 0
+                        : averages.reduce((prev, curr) => prev + curr, 0) / count;
+            }
+        }
+        if (progressMetadata.batches.length >= 3) {
+            eta = progressMetadata.rate * remainingSeconds;
+        }
+    }
+    return eta;
+}
+//# sourceMappingURL=metrics.js.map