apollo_infra: extract MetricsConfig from MonitoringEndpointConfig

Author: nadin-Starkware

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_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/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;
@@ -324,6 +325,7 @@ pub async fn create_node_components(
             Some(create_monitoring_endpoint(
                 monitoring_endpoint_config.clone(),
                 VERSION_FULL,
+                MetricsConfig::enabled(),
                 mempool_client,
                 l1_provider_client,
             ))