Use Config File to Drive Components Log Configuration

forest/src/cli/config.rs

@@ -5,11 +5,23 @@ use forest_chain_sync::SyncConfig;
 use forest_libp2p::Libp2pConfig;
 use forest_networks::ChainConfig;
 use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
 use std::path::PathBuf;
 use std::sync::Arc;
 
 use super::client::Client;
 
+#[derive(Serialize, Deserialize, Default, PartialEq)]
+pub struct LogConfig {
+    pub log_values: HashSet<LogValue>,
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct LogValue {
+    pub module: String,
+    pub level: String,
+}
+
 /// Structure that defines daemon configuration when process is detached
 #[derive(Deserialize, Serialize, PartialEq)]
 pub struct DaemonConfig {
@@ -45,6 +57,7 @@ pub struct Config {
     pub sync: SyncConfig,
     pub chain: Arc<ChainConfig>,
     pub daemon: DaemonConfig,
+    pub log: LogConfig,
 }
 
 #[cfg(test)]
@@ -77,6 +90,7 @@ mod test {
                 sync: val.sync,
                 chain: Arc::new(ChainConfig::default()),
                 daemon: DaemonConfig::default(),
+                log: Default::default(),
             }
         }
     }

forest/src/cli/mod.rs

@@ -19,6 +19,8 @@ pub(super) use self::chain_cmd::ChainCommands;
 pub use self::client::Client;
 pub use self::config::Config;
 pub use self::config::DaemonConfig;
+pub use self::config::LogConfig;
+pub use self::config::LogValue;
 pub(super) use self::fetch_params_cmd::FetchCommands;
 pub(super) use self::genesis_cmd::GenesisCommands;
 pub(super) use self::mpool_cmd::MpoolCommands;
@@ -183,6 +185,13 @@ pub struct CliOpts {
     /// Daemonize Forest process
     #[structopt(long)]
     pub detach: bool,
+    // env_logger-0.7 can only redirect to stderr or stdout. Version 0.9 can redirect to a file.
+    // However, we cannot upgrade to version 0.9 because pretty_env_logger depends on version 0.7
+    // and hasn't been updated in quite a while. See https://github.com/seanmonstar/pretty-env-logger/issues/52
+    // #[structopt(
+    //     help = "Specify a filename into which logging should be appended"
+    // )]
+    // pub log_file: Option<PathBuf>,
 }
 
 impl CliOpts {

forest/src/logger/mod.rs

@@ -1,9 +1,12 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
+use crate::cli::LogConfig;
+use crate::cli_error_and_die;
 use log::LevelFilter;
+use std::str::FromStr;
 
-pub(crate) fn setup_logger() {
+pub(crate) fn setup_logger(log_config: &LogConfig) {
     let mut logger_builder = pretty_env_logger::formatted_timed_builder();
 
     // Assign default log level settings
@@ -20,6 +23,12 @@ pub(crate) fn setup_logger() {
     logger_builder.filter(Some("rpc"), LevelFilter::Info);
     logger_builder.filter(None, LevelFilter::Info);
 
+    for item in &log_config.log_values {
+        let level = LevelFilter::from_str(item.level.as_str())
+            .unwrap_or_else(|_| cli_error_and_die("could not parse LevelFilter enum value", 1));
+        logger_builder.filter(Some(item.module.as_str()), level);
+    }
+
     // Override log level based on filters if set
     if let Ok(s) = ::std::env::var("RUST_LOG") {
         logger_builder.parse_filters(&s);

forest/src/main.rs

@@ -91,40 +91,47 @@ fn build_daemon<'a>(config: &DaemonConfig) -> anyhow::Result<Daemon<'a>> {
 }
 
 fn main() {
-    logger::setup_logger();
-
     // Capture Cli inputs
     let Cli { opts, cmd } = Cli::from_args();
 
     // Run forest as a daemon if no other subcommands are used. Otherwise, run the subcommand.
     match opts.to_config() {
-        Ok(cfg) => match cmd {
-            Some(command) => {
-                task::block_on(subcommand::process(command, cfg));
-            }
-            None => {
-                if opts.detach {
-                    create_ipc_lock();
-                    info!(
-                        "Redirecting stdout and stderr to files {} and {}.",
-                        cfg.daemon.stdout.display(),
-                        cfg.daemon.stderr.display()
-                    );
-                    let result = build_daemon(&cfg.daemon)
-                        .unwrap_or_else(|e| {
-                            cli_error_and_die(format!("Error building daemon. Error was: {e}"), 1)
-                        })
-                        .start();
-                    match result {
-                        Ok(_) => info!("Process detached"),
-                        Err(e) => {
-                            cli_error_and_die(format!("Error when detaching. Error was: {e}"), 1);
+        Ok(cfg) => {
+            logger::setup_logger(&cfg.log);
+            match cmd {
+                Some(command) => {
+                    task::block_on(subcommand::process(command, cfg));
+                }
+                None => {
+                    if opts.detach {
+                        create_ipc_lock();
+                        info!(
+                            "Redirecting stdout and stderr to files {} and {}.",
+                            cfg.daemon.stdout.display(),
+                            cfg.daemon.stderr.display()
+                        );
+                        let result = build_daemon(&cfg.daemon)
+                            .unwrap_or_else(|e| {
+                                cli_error_and_die(
+                                    format!("Error building daemon. Error was: {e}"),
+                                    1,
+                                )
+                            })
+                            .start();
+                        match result {
+                            Ok(_) => info!("Process detached"),
+                            Err(e) => {
+                                cli_error_and_die(
+                                    format!("Error when detaching. Error was: {e}"),
+                                    1,
+                                );
+                            }
                         }
                     }
+                    task::block_on(daemon::start(cfg, opts.detach));
                 }
-                task::block_on(daemon::start(cfg, opts.detach));
             }
-        },
+        }
         Err(e) => {
             cli_error_and_die(format!("Error parsing config. Error was: {e}"), 1);
         }