feat(l1,l2): enable log levels update in runtime (#4324)

**Motivation**

<!-- Why does this pull request exist? What are its goals? -->
Sometimes we want to change the log level, primarly for debugging, and
restarting the node would break the case of study.

**Description**

<!-- A clear and concise general description of the changes this PR
introduces -->
Add a custom `admin_setLogLevel` endpoint that enables the node operator
to specify a new log filter, just like with `RUST_LOG`.

How to test:
1. Run a node (e.g. `ethrex --dev`)
2. Change the log levels:
    ```
curl localhost:8545 -H 'content-type: application/json' -d '{"jsonrpc":
"2.0", "id": "1", "method": "admin_setLogLevel", "params":
["ethrex_dev::block_producer=info"]}'
     ```
3. You should now only see `ethrex_dev::block_producer` logs

> [!WARNING]
> The `admin` namespace is currently unauthenticated and cannot be
turned off. Be aware of this in public nodes

<!-- Link to issues: Resolves #111, Resolves #222 -->

Closes #4299

Author: ManuelBilbao

Cargo.lock

@@ -313,7 +313,9 @@ impl Subcommand {
         // L2 has its own init_tracing because of the ethrex monitor
         match self {
             Self::L2(_) => {}
-            _ => init_tracing(opts),
+            _ => {
+                init_tracing(opts);
+            }
         }
         match self {
             Subcommand::RemoveDB { datadir, force } => {

cmd/ethrex/cli.rs

@@ -37,9 +37,10 @@ async fn main() -> eyre::Result<()> {
         return subcommand.run(&opts).await;
     }
 
-    init_tracing(&opts);
+    let log_filter_handler = init_tracing(&opts);
 
-    let (data_dir, cancel_token, peer_table, local_node_record) = init_l1(opts).await?;
+    let (data_dir, cancel_token, peer_table, local_node_record) =
+        init_l1(opts, Some(log_filter_handler)).await?;
 
     let mut signal_terminate = signal(SignalKind::terminate())?;
 

cmd/ethrex/ethrex.rs

@@ -37,16 +37,18 @@ use tokio::sync::Mutex;
 use tokio_util::{sync::CancellationToken, task::TaskTracker};
 use tracing::{debug, error, info, warn};
 use tracing_subscriber::{
-    EnvFilter, Layer, Registry, filter::Directive, fmt, layer::SubscriberExt,
+    EnvFilter, Layer, Registry, filter::Directive, fmt, layer::SubscriberExt, reload,
 };
 
-pub fn init_tracing(opts: &Options) {
+pub fn init_tracing(opts: &Options) -> reload::Handle<EnvFilter, Registry> {
     let log_filter = EnvFilter::builder()
         .with_default_directive(Directive::from(opts.log_level))
         .from_env_lossy()
         .add_directive(Directive::from(opts.log_level));
 
-    let fmt_layer = fmt::layer().with_filter(log_filter);
+    let (filter, filter_handle) = reload::Layer::new(log_filter);
+
+    let fmt_layer = fmt::layer().with_filter(filter);
     let subscriber: Box<dyn tracing::Subscriber + Send + Sync> = if opts.metrics_enabled {
         let profiling_layer = FunctionProfilingLayer::default();
         Box::new(Registry::default().with(fmt_layer).with(profiling_layer))
@@ -55,6 +57,8 @@ pub fn init_tracing(opts: &Options) {
     };
 
     tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
+
+    filter_handle
 }
 
 pub fn init_metrics(opts: &Options, tracker: TaskTracker) {
@@ -131,6 +135,7 @@ pub async fn init_rpc_api(
     blockchain: Arc<Blockchain>,
     cancel_token: CancellationToken,
     tracker: TaskTracker,
+    log_filter_handler: Option<reload::Handle<EnvFilter, Registry>>,
 ) {
     let peer_handler = PeerHandler::new(peer_table);
 
@@ -156,6 +161,7 @@ pub async fn init_rpc_api(
         syncer,
         peer_handler,
         get_client_version(),
+        log_filter_handler,
     );
 
     tracker.spawn(rpc_api);
@@ -366,6 +372,7 @@ async fn set_sync_block(store: &Store) {
 
 pub async fn init_l1(
     opts: Options,
+    log_filter_handler: Option<reload::Handle<EnvFilter, Registry>>,
 ) -> eyre::Result<(String, CancellationToken, Kademlia, Arc<Mutex<NodeRecord>>)> {
     let data_dir = init_datadir(&opts.datadir);
 
@@ -406,6 +413,7 @@ pub async fn init_l1(
         blockchain.clone(),
         cancel_token.clone(),
         tracker.clone(),
+        log_filter_handler,
     )
     .await;
 

cmd/ethrex/initializers.rs

@@ -64,15 +64,19 @@ impl L2Command {
 
         let matches = app.try_get_matches_from(args_with_program)?;
         let init_options = Options::from_arg_matches(&matches)?;
-        l2::init_tracing(&init_options);
+        let log_filter_handler = l2::init_tracing(&init_options);
         let mut l2_options = init_options;
 
         if l2_options.node_opts.dev {
             println!("Removing L1 and L2 databases...");
             remove_db(DB_ETHREX_DEV_L1, true);
             remove_db(DB_ETHREX_DEV_L2, true);
             println!("Initializing L1");
-            init_l1(crate::cli::Options::default_l1()).await?;
+            init_l1(
+                crate::cli::Options::default_l1(),
+                log_filter_handler.clone(),
+            )
+            .await?;
             println!("Deploying contracts...");
             let contract_addresses =
                 l2::deployer::deploy_l1_contracts(l2::deployer::DeployerOptions::default()).await?;
@@ -89,7 +93,7 @@ impl L2Command {
                 Some(contract_addresses.bridge_address);
             println!("Initializing L2");
         }
-        l2::init_l2(l2_options).await?;
+        l2::init_l2(l2_options, log_filter_handler).await?;
         Ok(())
     }
 }
@@ -268,7 +272,7 @@ impl Command {
                 ..Default::default()
             }),
             _ => init_tracing(&crate::cli::Options::default()),
-        }
+        };
 
         match self {
             Command::Prover {

cmd/ethrex/l2/command.rs

@@ -21,8 +21,8 @@ use tokio::task::JoinSet;
 use tokio_util::sync::CancellationToken;
 use tokio_util::task::TaskTracker;
 use tracing::{error, info, warn};
-use tracing_subscriber::EnvFilter;
 use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::{EnvFilter, Registry, reload};
 use tui_logger::{LevelFilter, TuiTracingSubscriberLayer};
 
 use crate::cli::Options as L1Options;
@@ -47,6 +47,7 @@ async fn init_rpc_api(
     cancel_token: CancellationToken,
     tracker: TaskTracker,
     rollup_store: StoreRollup,
+    log_filter_handler: Option<reload::Handle<EnvFilter, Registry>>,
 ) {
     let peer_handler = PeerHandler::new(peer_table);
 
@@ -75,6 +76,7 @@ async fn init_rpc_api(
         get_valid_delegation_addresses(l2_opts),
         l2_opts.sponsor_private_key,
         rollup_store,
+        log_filter_handler,
     );
 
     tracker.spawn(rpc_api);
@@ -129,7 +131,7 @@ fn init_metrics(opts: &L1Options, tracker: TaskTracker) {
     tracker.spawn(metrics_api);
 }
 
-pub fn init_tracing(opts: &L2Options) {
+pub fn init_tracing(opts: &L2Options) -> Option<reload::Handle<EnvFilter, Registry>> {
     if !opts.sequencer_opts.no_monitor {
         let level_filter = EnvFilter::builder()
             .parse_lossy("debug,tower_http::trace=debug,reqwest_tracing=off,hyper=off,libsql=off,ethrex::initializers=off,ethrex::l2::initializers=off,ethrex::l2::command=off");
@@ -139,12 +141,18 @@ pub fn init_tracing(opts: &L2Options) {
         tracing::subscriber::set_global_default(subscriber)
             .expect("setting default subscriber failed");
         tui_logger::init_logger(LevelFilter::max()).expect("Failed to initialize tui_logger");
+
+        // Monitor already registers all log levels
+        None
     } else {
-        initializers::init_tracing(&opts.node_opts);
+        Some(initializers::init_tracing(&opts.node_opts))
     }
 }
 
-pub async fn init_l2(opts: L2Options) -> eyre::Result<()> {
+pub async fn init_l2(
+    opts: L2Options,
+    log_filter_handler: Option<reload::Handle<EnvFilter, Registry>>,
+) -> eyre::Result<()> {
     if opts.node_opts.evm == EvmEngine::REVM {
         panic!("L2 Doesn't support REVM, use LEVM instead.");
     }
@@ -189,6 +197,7 @@ pub async fn init_l2(opts: L2Options) -> eyre::Result<()> {
         cancel_token.clone(),
         tracker.clone(),
         rollup_store.clone(),
+        log_filter_handler,
     )
     .await;
 

cmd/ethrex/l2/initializers.rs

@@ -22,6 +22,7 @@ serde_json = "1.0.117"
 tokio = { workspace = true, features = ["full"] }
 bytes.workspace = true
 tracing.workspace = true
+tracing-subscriber.workspace = true
 thiserror.workspace = true
 secp256k1.workspace = true
 keccak-hash.workspace = true

crates/l2/networking/rpc/Cargo.toml

@@ -28,6 +28,7 @@ use std::{
 use tokio::{net::TcpListener, sync::Mutex as TokioMutex};
 use tower_http::cors::CorsLayer;
 use tracing::{debug, info};
+use tracing_subscriber::{EnvFilter, Registry, reload};
 
 use crate::l2::transaction::SponsoredTx;
 use ethrex_common::Address;
@@ -76,6 +77,7 @@ pub async fn start_api(
     valid_delegation_addresses: Vec<Address>,
     sponsor_pk: SecretKey,
     rollup_store: StoreRollup,
+    log_filter_handler: Option<reload::Handle<EnvFilter, Registry>>,
 ) -> Result<(), RpcErr> {
     // TODO: Refactor how filters are handled,
     // filters are used by the filters endpoints (eth_newFilter, eth_getFilterChanges, ...etc)
@@ -94,6 +96,7 @@ pub async fn start_api(
                 client_version,
             },
             gas_tip_estimator: Arc::new(TokioMutex::new(GasTipEstimator::new())),
+            log_filter_handler,
         },
         valid_delegation_addresses,
         sponsor_pk,

crates/l2/networking/rpc/rpc.rs

@@ -3,8 +3,12 @@ use ethrex_storage::Store;
 use serde::Serialize;
 use serde_json::Value;
 use std::collections::HashMap;
+use tracing_subscriber::{EnvFilter, Registry, reload};
 
-use crate::{rpc::NodeData, utils::RpcErr};
+use crate::{
+    rpc::NodeData,
+    utils::{RpcErr, RpcRequest},
+};
 mod peers;
 pub use peers::peers;
 
@@ -58,3 +62,32 @@ pub fn node_info(storage: Store, node_data: &NodeData) -> Result<Value, RpcErr>
     };
     serde_json::to_value(node_info).map_err(|error| RpcErr::Internal(error.to_string()))
 }
+
+pub async fn set_log_level(
+    req: &RpcRequest,
+    log_filter_handler: &Option<reload::Handle<EnvFilter, Registry>>,
+) -> Result<Value, RpcErr> {
+    let params = req
+        .params
+        .clone()
+        .ok_or(RpcErr::MissingParam("log level".to_string()))?;
+    let log_level = params
+        .first()
+        .ok_or(RpcErr::MissingParam("log level".to_string()))?
+        .as_str()
+        .ok_or(RpcErr::WrongParam("Expected string".to_string()))?;
+
+    let filter = EnvFilter::try_new(log_level)
+        .map_err(|_| RpcErr::BadParams(format!("Cannot parse {log_level} as a log directive")))?;
+
+    if let Some(handle) = log_filter_handler {
+        handle
+            .reload(filter)
+            .map_err(|e| RpcErr::Internal(format!("Failed to reload log filter: {}", e)))?;
+        Ok(Value::Bool(true))
+    } else {
+        Err(RpcErr::Internal(
+            "Log filter handler not available".to_string(),
+        ))
+    }
+}

crates/networking/rpc/admin/mod.rs

@@ -66,6 +66,7 @@ use std::{
 use tokio::{net::TcpListener, sync::Mutex as TokioMutex};
 use tower_http::cors::CorsLayer;
 use tracing::{error, info};
+use tracing_subscriber::{EnvFilter, Registry, reload};
 
 #[derive(Deserialize)]
 #[serde(untagged)]
@@ -83,6 +84,7 @@ pub struct RpcApiContext {
     pub peer_handler: PeerHandler,
     pub node_data: NodeData,
     pub gas_tip_estimator: Arc<TokioMutex<GasTipEstimator>>,
+    pub log_filter_handler: Option<reload::Handle<EnvFilter, Registry>>,
 }
 
 #[derive(Debug, Clone)]
@@ -125,6 +127,7 @@ pub async fn start_api(
     syncer: SyncManager,
     peer_handler: PeerHandler,
     client_version: String,
+    log_filter_handler: Option<reload::Handle<EnvFilter, Registry>>,
 ) -> Result<(), RpcErr> {
     // TODO: Refactor how filters are handled,
     // filters are used by the filters endpoints (eth_newFilter, eth_getFilterChanges, ...etc)
@@ -142,6 +145,7 @@ pub async fn start_api(
             client_version,
         },
         gas_tip_estimator: Arc::new(TokioMutex::new(GasTipEstimator::new())),
+        log_filter_handler,
     };
 
     // Periodically clean up the active filters for the filters endpoints.
@@ -386,6 +390,7 @@ pub async fn map_admin_requests(req: &RpcRequest, context: RpcApiContext) -> Res
     match req.method.as_str() {
         "admin_nodeInfo" => admin::node_info(context.storage, &context.node_data),
         "admin_peers" => admin::peers(&context).await,
+        "admin_setLogLevel" => admin::set_log_level(req, &context.log_filter_handler).await,
         unknown_admin_method => Err(RpcErr::MethodNotFound(unknown_admin_method.to_owned())),
     }
 }