apollo_infra: extract MetricsConfig from MonitoringEndpointConfig

Author: nadin-Starkware

crates/apollo_dashboard/Cargo.toml

@@ -31,7 +31,6 @@ apollo_l1_provider.workspace = true
 apollo_mempool.workspace = true
 apollo_mempool_p2p.workspace = true
 apollo_metrics.workspace = true
-apollo_monitoring_endpoint.workspace = true
 apollo_network.workspace = true
 apollo_state_sync_metrics.workspace = true
 apollo_storage.workspace = true

crates/apollo_deployments/resources/app_configs/monitoring_endpoint_config.json

@@ -1,6 +1,4 @@
 {
-  "monitoring_endpoint_config.collect_metrics": true,
-  "monitoring_endpoint_config.collect_profiling_metrics": true,
   "monitoring_endpoint_config.ip": "0.0.0.0",
   "monitoring_config.collect_metrics": true,
   "monitoring_config.collect_profiling_metrics": true

crates/apollo_deployments/resources/app_configs/replacer_monitoring_endpoint_config.json

@@ -1,6 +1,4 @@
 {
-  "monitoring_config.collect_metrics": true,
-  "monitoring_config.collect_profiling_metrics": true,
   "monitoring_endpoint_config.collect_metrics": true,
   "monitoring_endpoint_config.collect_profiling_metrics": true,
   "monitoring_endpoint_config.ip": "0.0.0.0"

crates/apollo_infra/src/metrics.rs

@@ -4,9 +4,28 @@ use apollo_metrics::metrics::{
     MetricGauge,
     MetricHistogram,
 };
+use serde::{Deserialize, Serialize};
 
 use crate::requests::LABEL_NAME_REQUEST_VARIANT;
 
+/// Configuration for metrics collection.
+/// This controls whether metrics are collected across the entire application.
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, PartialEq)]
+pub struct MetricsConfig {
+    /// Whether to collect metrics at all.
+    pub collect_metrics: bool,
+    /// Whether to collect profiling metrics (more detailed metrics that may have performance
+    /// impact).
+    pub collect_profiling_metrics: bool,
+}
+
+impl MetricsConfig {
+    /// Returns a config with all metrics collection enabled.
+    pub const fn enabled() -> Self {
+        Self { collect_metrics: true, collect_profiling_metrics: true }
+    }
+}
+
 /// Metrics of a local client.
 #[derive(Clone)]
 pub struct LocalClientMetrics {

crates/apollo_integration_tests/src/flow_test_setup.rs

@@ -6,6 +6,7 @@ use apollo_base_layer_tests::anvil_base_layer::AnvilBaseLayer;
 use apollo_consensus_manager_config::config::ConsensusManagerConfig;
 use apollo_http_server::test_utils::HttpTestClient;
 use apollo_http_server_config::config::HttpServerConfig;
+use apollo_infra::metrics::MetricsConfig;
 use apollo_infra_utils::test_utils::AvailablePorts;
 use apollo_l1_gas_price_provider_config::config::EthToStrkOracleConfig;
 use apollo_mempool_p2p_config::config::MempoolP2pConfig;
@@ -259,12 +260,8 @@ impl FlowSequencerSetup {
 
         let component_config = ComponentConfig::default();
 
-        // Explicitly avoid collecting metrics in the monitoring endpoint; metrics are collected
-        // using a global recorder, which fails when being set multiple times in the same
-        // process, as in this test.
         let monitoring_endpoint_config = MonitoringEndpointConfig {
             port: available_ports.get_next_port(),
-            collect_metrics: false,
             ..Default::default()
         };
 
@@ -292,7 +289,10 @@ impl FlowSequencerSetup {
             num_l1_txs;
 
         debug!("Sequencer config: {:#?}", node_config);
-        let (clients, servers) = create_node_modules(&node_config, vec![]).await;
+        // Pass MetricsConfig::default() (disabled) to avoid conflicts when running multiple
+        // sequencers in the same process (metrics recorder can only be installed once globally).
+        let (clients, servers) =
+            create_node_modules(&node_config, MetricsConfig::default(), vec![]).await;
 
         let MonitoringEndpointConfig { ip, port, .. } =
             node_config.monitoring_endpoint_config.as_ref().unwrap().to_owned();

crates/apollo_integration_tests/src/integration_test_manager.rs

@@ -930,7 +930,6 @@ async fn get_sequencer_setup_configs(
             // Set a monitoring endpoint for each executable.
             let monitoring_endpoint_config = MonitoringEndpointConfig {
                 port: config_available_ports.get_next_port(),
-                collect_metrics: true,
                 ..Default::default()
             };
 

crates/apollo_monitoring_endpoint/src/monitoring_endpoint.rs

@@ -1,6 +1,7 @@
 use std::net::SocketAddr;
 
 use apollo_infra::component_definitions::ComponentStarter;
+use apollo_infra::metrics::MetricsConfig;
 use apollo_infra::tokio_metrics::setup_tokio_metrics;
 use apollo_infra::trace_util::{configure_tracing, get_log_directives, set_log_level};
 use apollo_infra_utils::type_name::short_type_name;
@@ -50,15 +51,16 @@ impl MonitoringEndpoint {
     pub fn new(
         config: MonitoringEndpointConfig,
         version: &'static str,
+        metrics_config: MetricsConfig,
         mempool_client: Option<SharedMempoolClient>,
         l1_provider_client: Option<SharedL1ProviderClient>,
     ) -> Self {
         // TODO(Tsabary): consider error handling
-        let prometheus_handle = if config.collect_metrics {
+        let prometheus_handle = if metrics_config.collect_metrics {
             // TODO(Lev): add tests that show the metrics are collected / not collected based on the
             // config value.
             COLLECT_SEQUENCER_PROFILING_METRICS
-                .set(config.collect_profiling_metrics)
+                .set(metrics_config.collect_profiling_metrics)
                 .expect("Should be able to set profiling metrics collection.");
 
             Some(
@@ -144,10 +146,17 @@ impl MonitoringEndpoint {
 pub fn create_monitoring_endpoint(
     config: MonitoringEndpointConfig,
     version: &'static str,
+    metrics_config: MetricsConfig,
     mempool_client: Option<SharedMempoolClient>,
     l1_provider_client: Option<SharedL1ProviderClient>,
 ) -> MonitoringEndpoint {
-    let result = MonitoringEndpoint::new(config, version, mempool_client, l1_provider_client);
+    let result = MonitoringEndpoint::new(
+        config,
+        version,
+        metrics_config,
+        mempool_client,
+        l1_provider_client,
+    );
     setup_tokio_metrics();
     result
 }

crates/apollo_monitoring_endpoint/src/monitoring_endpoint_test.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::net::IpAddr;
 use std::sync::Arc;
 
+use apollo_infra::metrics::MetricsConfig;
 use apollo_infra::tokio_metrics::{
     TOKIO_GLOBAL_QUEUE_DEPTH,
     TOKIO_MAX_BUSY_DURATION_MICROS,
@@ -59,13 +60,14 @@ const TEST_VERSION: &str = "1.2.3-dev";
 const CONFIG_WITHOUT_METRICS: MonitoringEndpointConfig = MonitoringEndpointConfig {
     ip: MONITORING_ENDPOINT_DEFAULT_IP,
     port: MONITORING_ENDPOINT_DEFAULT_PORT,
-    collect_metrics: false,
-    collect_profiling_metrics: false,
 };
 
+const METRICS_CONFIG_DISABLED: MetricsConfig =
+    MetricsConfig { collect_metrics: false, collect_profiling_metrics: false };
+
 fn setup_monitoring_endpoint(config: Option<MonitoringEndpointConfig>) -> MonitoringEndpoint {
     let config = config.unwrap_or(CONFIG_WITHOUT_METRICS);
-    create_monitoring_endpoint(config, TEST_VERSION, None, None)
+    create_monitoring_endpoint(config, TEST_VERSION, METRICS_CONFIG_DISABLED, None, None)
 }
 
 async fn request_app(app: Router, method: &str) -> Response {
@@ -119,8 +121,9 @@ async fn set_log_level_invalid_level() {
 
 #[tokio::test]
 async fn with_metrics() {
-    let config = MonitoringEndpointConfig { collect_metrics: true, ..Default::default() };
-    let app = setup_monitoring_endpoint(Some(config)).app();
+    let config = MonitoringEndpointConfig::default();
+    let metrics_config = MetricsConfig { collect_metrics: true, collect_profiling_metrics: false };
+    let app = create_monitoring_endpoint(config, TEST_VERSION, metrics_config, None, None).app();
 
     // Register a metric.
     let metric_name = "metric_name";
@@ -173,6 +176,7 @@ fn setup_monitoring_endpoint_with_mempool_client() -> MonitoringEndpoint {
     create_monitoring_endpoint(
         CONFIG_WITHOUT_METRICS,
         TEST_VERSION,
+        METRICS_CONFIG_DISABLED,
         Some(shared_mock_mempool_client),
         None,
     )
@@ -235,6 +239,7 @@ fn setup_monitoring_endpoint_with_l1_provider_client() -> MonitoringEndpoint {
     create_monitoring_endpoint(
         CONFIG_WITHOUT_METRICS,
         TEST_VERSION,
+        METRICS_CONFIG_DISABLED,
         None,
         Some(shared_mock_l1_provider_client),
     )

crates/apollo_monitoring_endpoint_config/src/config.rs

@@ -14,18 +14,11 @@ pub const MONITORING_ENDPOINT_DEFAULT_PORT: u16 = 8082;
 pub struct MonitoringEndpointConfig {
     pub ip: IpAddr,
     pub port: u16,
-    pub collect_metrics: bool,
-    pub collect_profiling_metrics: bool,
 }
 
 impl MonitoringEndpointConfig {
     pub fn deployment() -> Self {
-        Self {
-            ip: MONITORING_ENDPOINT_DEFAULT_IP,
-            port: MONITORING_ENDPOINT_DEFAULT_PORT,
-            collect_metrics: true,
-            collect_profiling_metrics: true,
-        }
+        Self { ip: MONITORING_ENDPOINT_DEFAULT_IP, port: MONITORING_ENDPOINT_DEFAULT_PORT }
     }
 }
 
@@ -50,18 +43,6 @@ impl SerializeConfig for MonitoringEndpointConfig {
                 "The monitoring endpoint port.",
                 ParamPrivacyInput::Public,
             ),
-            ser_param(
-                "collect_metrics",
-                &self.collect_metrics,
-                "If true, collect and return metrics in the monitoring endpoint.",
-                ParamPrivacyInput::Public,
-            ),
-            ser_param(
-                "collect_profiling_metrics",
-                &self.collect_profiling_metrics,
-                "If true, collect and return profiling metrics in the monitoring endpoint.",
-                ParamPrivacyInput::Public,
-            ),
         ])
     }
 }

crates/apollo_node/resources/config_schema.json

@@ -2609,16 +2609,6 @@
     "privacy": "TemporaryValue",
     "value": false
   },
-  "monitoring_endpoint_config.collect_metrics": {
-    "description": "If true, collect and return metrics in the monitoring endpoint.",
-    "privacy": "Public",
-    "value": true
-  },
-  "monitoring_endpoint_config.collect_profiling_metrics": {
-    "description": "If true, collect and return profiling metrics in the monitoring endpoint.",
-    "privacy": "Public",
-    "value": true
-  },
   "monitoring_endpoint_config.ip": {
     "description": "The monitoring endpoint ip address.",
     "privacy": "Public",