apollo_infra: extract MetricsConfig from MonitoringEndpointConfig

Author: nadin-Starkware

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,7 +1,5 @@
 {
   "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,31 @@ use apollo_metrics::metrics::{
     MetricGauge,
     MetricHistogram,
 };
+use serde::{Deserialize, Serialize};
 
 use crate::requests::LABEL_NAME_REQUEST_VARIANT;
 
+/// Configuration for metrics collection.
+#[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.
+    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 }
+    }
+
+    /// Returns a config with all metrics collection disabled.
+    pub const fn disabled() -> Self {
+        Self { collect_metrics: false, collect_profiling_metrics: false }
+    }
+}
+
 /// 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::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::disabled(), 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

@@ -1132,7 +1132,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_l1_provider_types::{L1ProviderSnapshot, MockL1ProviderClient};
 use apollo_mempool_types::communication::MockMempoolClient;
 use apollo_mempool_types::mempool_types::{
@@ -49,13 +50,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 {
@@ -109,8 +111,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";
@@ -163,6 +166,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,
     )
@@ -225,6 +229,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

@@ -2784,16 +2784,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",

crates/apollo_node/src/components.rs

@@ -10,6 +10,7 @@ use apollo_config_manager::config_manager_runner::ConfigManagerRunner;
 use apollo_consensus_manager::consensus_manager::{ConsensusManager, ConsensusManagerArgs};
 use apollo_gateway::gateway::{create_gateway, Gateway};
 use apollo_http_server::http_server::{create_http_server, HttpServer};
+use apollo_infra::metrics::MetricsConfig;
 use apollo_l1_endpoint_monitor::monitor::L1EndpointMonitor;
 use apollo_l1_gas_price::l1_gas_price_provider::L1GasPriceProvider;
 use apollo_l1_gas_price::l1_gas_price_scraper::L1GasPriceScraper;
@@ -62,9 +63,12 @@ pub struct SequencerNodeComponents {
     pub state_sync_runner: Option<StateSyncRunner>,
 }
 
+// TODO(Nadin): metrics_config is a temporary parameter until metrics initialization is moved to
+// main.rs
 pub async fn create_node_components(
     config: &SequencerNodeConfig,
     clients: &SequencerNodeClients,
+    metrics_config: MetricsConfig,
     cli_args: Vec<String>,
 ) -> SequencerNodeComponents {
     // TODO(tsabary): consider moving ownership of component configs to the components themselves
@@ -324,6 +328,7 @@ pub async fn create_node_components(
             Some(create_monitoring_endpoint(
                 monitoring_endpoint_config.clone(),
                 VERSION_FULL,
+                metrics_config,
                 mempool_client,
                 l1_provider_client,
             ))