apollo_monitoring_endpoint: add route to set log level (#10184)

* apollo_infra: add set_log_level function

* apollo_monitoring_endpoint: add route to set log level

Author: nadin-Starkware

crates/apollo_monitoring_endpoint/src/monitoring_endpoint.rs

@@ -1,18 +1,21 @@
 use std::net::SocketAddr;
 
 use apollo_infra::component_definitions::ComponentStarter;
+use apollo_infra::trace_util::{configure_tracing, set_log_level};
 use apollo_infra_utils::type_name::short_type_name;
 use apollo_l1_provider_types::{L1ProviderSnapshot, SharedL1ProviderClient};
 use apollo_mempool_types::communication::SharedMempoolClient;
 use apollo_mempool_types::mempool_types::MempoolSnapshot;
 use apollo_metrics::metrics::COLLECT_SEQUENCER_PROFILING_METRICS;
 use apollo_monitoring_endpoint_config::config::MonitoringEndpointConfig;
+use axum::extract::Path;
 use axum::http::StatusCode;
 use axum::response::{IntoResponse, Response};
-use axum::routing::get;
+use axum::routing::{get, post};
 use axum::{async_trait, Json, Router, Server};
 use hyper::Error;
 use metrics_exporter_prometheus::{PrometheusBuilder, PrometheusHandle};
+use tracing::level_filters::LevelFilter;
 use tracing::{error, info, instrument};
 
 use crate::tokio_metrics::setup_tokio_metrics;
@@ -28,6 +31,7 @@ pub(crate) const VERSION: &str = "nodeVersion";
 pub(crate) const METRICS: &str = "metrics";
 pub(crate) const MEMPOOL_SNAPSHOT: &str = "mempoolSnapshot";
 pub(crate) const L1_PROVIDER_SNAPSHOT: &str = "l1ProviderSnapshot";
+pub(crate) const SET_LOG_LEVEL: &str = "setLogLevel";
 
 pub const HISTOGRAM_BUCKETS: &[f64] =
     &[0.001, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0, 25.0, 50.0];
@@ -122,6 +126,10 @@ impl MonitoringEndpoint {
                 format!("/{MONITORING_PREFIX}/{L1_PROVIDER_SNAPSHOT}").as_str(),
                 get(move || get_l1_provider_snapshot(l1_provider_client)),
             )
+            .route(
+                format!("/{MONITORING_PREFIX}/{SET_LOG_LEVEL}/:crate/:level").as_str(),
+                post(set_log_level_endpoint),
+            )
     }
 }
 
@@ -211,3 +219,12 @@ async fn get_l1_provider_snapshot(
         None => Err(StatusCode::METHOD_NOT_ALLOWED),
     }
 }
+
+async fn set_log_level_endpoint(
+    Path((crate_name, level)): Path<(String, String)>,
+) -> Result<StatusCode, StatusCode> {
+    let level_filter = level.parse::<LevelFilter>().map_err(|_| StatusCode::BAD_REQUEST)?;
+    let handle = configure_tracing().await;
+    set_log_level(&handle, &crate_name, level_filter);
+    Ok(StatusCode::OK)
+}

crates/apollo_monitoring_endpoint/src/monitoring_endpoint_test.rs

@@ -37,9 +37,10 @@ use crate::monitoring_endpoint::{
     MEMPOOL_SNAPSHOT,
     METRICS,
     READY,
+    SET_LOG_LEVEL,
     VERSION,
 };
-use crate::test_utils::build_request;
+use crate::test_utils::{build_post_request, build_request};
 use crate::tokio_metrics::{
     TOKIO_GLOBAL_QUEUE_DEPTH,
     TOKIO_MAX_BUSY_DURATION_MICROS,
@@ -71,6 +72,10 @@ async fn request_app(app: Router, method: &str) -> Response {
     app.oneshot(build_request(&IpAddr::from([0, 0, 0, 0]), 0, method)).await.unwrap()
 }
 
+async fn request_post_app(app: Router, method: &str) -> Response {
+    app.oneshot(build_post_request(&IpAddr::from([0, 0, 0, 0]), 0, method)).await.unwrap()
+}
+
 #[tokio::test]
 async fn node_version() {
     let response = request_app(setup_monitoring_endpoint(None).app(), VERSION).await;
@@ -92,6 +97,26 @@ async fn ready_endpoint() {
     assert_eq!(response.status(), StatusCode::OK);
 }
 
+#[tokio::test]
+async fn set_log_level_valid() {
+    let app = setup_monitoring_endpoint(None).app();
+    let crate_name = "apollo_monitoring_endpoint";
+    let level = "debug";
+    let method = format!("{SET_LOG_LEVEL}/{crate_name}/{level}");
+    let response = request_post_app(app, &method).await;
+    assert_eq!(response.status(), StatusCode::OK);
+}
+
+#[tokio::test]
+async fn set_log_level_invalid_level() {
+    let app = setup_monitoring_endpoint(None).app();
+    let crate_name = "apollo_monitoring_endpoint";
+    let invalid_level = "foobar";
+    let method = format!("{SET_LOG_LEVEL}/{crate_name}/{invalid_level}");
+    let response = request_post_app(app, &method).await;
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+}
+
 #[tokio::test]
 async fn with_metrics() {
     let config = MonitoringEndpointConfig { collect_metrics: true, ..Default::default() };

crates/apollo_monitoring_endpoint/src/test_utils.rs

@@ -120,3 +120,11 @@ pub(crate) fn build_request(ip: &IpAddr, port: u16, method: &str) -> Request<Bod
         .body(Body::empty())
         .unwrap()
 }
+
+pub fn build_post_request(ip: &IpAddr, port: u16, method: &str) -> Request<Body> {
+    Request::builder()
+        .method("POST")
+        .uri(format!("http://{ip}:{port}/{MONITORING_PREFIX}/{method}").as_str())
+        .body(Body::empty())
+        .unwrap()
+}