Merge pull request #2014 from input-output-hk/djo/1981/enhance_logs_i…

…n_relay

Enhance logs in mithril-relay

mithril-relay/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mithril-relay"
-version = "0.1.25"
+version = "0.1.26"
 description = "A Mithril relay"
 authors = { workspace = true }
 edition = { workspace = true }
@@ -43,8 +43,10 @@ slog = { version = "2.7.0", features = [
 ] }
 slog-async = "2.8.0"
 slog-bunyan = "2.5.0"
-slog-scope = "4.4.0"
-slog-term = "2.9.1"
 thiserror = "1.0.64"
 tokio = { version = "1.40.0", features = ["full"] }
 warp = "0.3.7"
+
+[dev-dependencies]
+slog-scope = "4.4.0"
+slog-term = "2.9.1"

mithril-relay/src/commands/aggregator.rs

@@ -1,9 +1,9 @@
 use clap::Parser;
-use config::{builder::DefaultState, ConfigBuilder};
 use libp2p::Multiaddr;
 use mithril_common::StdResult;
-use slog_scope::error;
+use slog::error;
 
+use super::CommandContext;
 use crate::AggregatorRelay;
 
 #[derive(Parser, Debug, Clone)]
@@ -23,19 +23,20 @@ pub struct AggregatorCommand {
 
 impl AggregatorCommand {
     /// Main command execution
-    pub async fn execute(&self, _config_builder: ConfigBuilder<DefaultState>) -> StdResult<()> {
+    pub async fn execute(&self, context: CommandContext) -> StdResult<()> {
         let dial_to = self.dial_to.to_owned();
         let addr: Multiaddr = format!("/ip4/0.0.0.0/tcp/{}", self.listen_port).parse()?;
         let aggregator_endpoint = self.aggregator_endpoint.to_owned();
+        let logger = context.logger();
 
-        let mut relay = AggregatorRelay::start(&addr, &aggregator_endpoint).await?;
+        let mut relay = AggregatorRelay::start(&addr, &aggregator_endpoint, logger).await?;
         if let Some(dial_to_address) = dial_to {
             relay.dial_peer(dial_to_address.clone())?;
         }
 
         loop {
             if let Err(err) = relay.tick().await {
-                error!("RelayAggregator: tick error"; "error" => format!("{err:#?}"));
+                error!(logger, "RelayAggregator: tick error"; "error" => ?err);
             }
         }
     }

mithril-relay/src/commands/context.rs

@@ -0,0 +1,29 @@
+use config::builder::DefaultState;
+use config::ConfigBuilder;
+use slog::Logger;
+
+/// Context for the command execution
+pub struct CommandContext {
+    config_builder: ConfigBuilder<DefaultState>,
+    logger: Logger,
+}
+
+impl CommandContext {
+    /// Create a new command context
+    pub fn new(config_builder: ConfigBuilder<DefaultState>, logger: Logger) -> Self {
+        Self {
+            config_builder,
+            logger,
+        }
+    }
+
+    /// Get the configured parameters
+    pub fn config_builder(&self) -> ConfigBuilder<DefaultState> {
+        self.config_builder.clone()
+    }
+
+    /// Get the shared logger
+    pub fn logger(&self) -> &Logger {
+        &self.logger
+    }
+}

mithril-relay/src/commands/mod.rs

@@ -1,4 +1,5 @@
 mod aggregator;
+mod context;
 mod passive;
 mod relay;
 mod signer;
@@ -10,9 +11,9 @@ pub use signer::SignerCommand;
 
 use clap::Parser;
 use config::{builder::DefaultState, ConfigBuilder, Map, Source, Value};
+use context::CommandContext;
 use mithril_common::StdResult;
-use slog::Level;
-use slog_scope::debug;
+use slog::{debug, Level, Logger};
 use std::path::PathBuf;
 
 /// Relay for Mithril Node
@@ -43,15 +44,16 @@ pub struct Args {
 
 impl Args {
     /// execute command
-    pub async fn execute(&self) -> StdResult<()> {
-        debug!("Run Mode: {}", self.run_mode);
+    pub async fn execute(&self, logger: Logger) -> StdResult<()> {
+        debug!(logger, "Run Mode: {}", self.run_mode);
         let filename = format!("{}/{}.json", self.config_directory.display(), self.run_mode);
-        debug!("Reading configuration file '{}'.", filename);
+        debug!(logger, "Reading configuration file '{filename}'.");
         let config: ConfigBuilder<DefaultState> = config::Config::builder()
             .add_source(config::File::with_name(&filename).required(false))
             .add_source(self.clone());
 
-        self.command.execute(config).await
+        let context = CommandContext::new(config, logger);
+        self.command.execute(context).await
     }
 
     /// get log level from parameters

mithril-relay/src/commands/passive.rs

@@ -1,9 +1,9 @@
 use clap::Parser;
-use config::{builder::DefaultState, ConfigBuilder};
 use libp2p::Multiaddr;
 use mithril_common::StdResult;
-use slog_scope::error;
+use slog::error;
 
+use super::CommandContext;
 use crate::PassiveRelay;
 
 #[derive(Parser, Debug, Clone)]
@@ -19,17 +19,18 @@ pub struct PassiveCommand {
 
 impl PassiveCommand {
     /// Main command execution
-    pub async fn execute(&self, _config_builder: ConfigBuilder<DefaultState>) -> StdResult<()> {
+    pub async fn execute(&self, context: CommandContext) -> StdResult<()> {
         let dial_to = self.dial_to.to_owned();
         let addr: Multiaddr = format!("/ip4/0.0.0.0/tcp/{}", self.listen_port).parse()?;
+        let logger = context.logger();
 
-        let mut relay = PassiveRelay::start(&addr).await?;
+        let mut relay = PassiveRelay::start(&addr, logger).await?;
         if let Some(dial_to_address) = dial_to {
             relay.dial_peer(dial_to_address.clone())?;
         }
         loop {
             if let Err(err) = relay.tick().await {
-                error!("P2PClient: tick error"; "error" => format!("{err:#?}"));
+                error!(logger, "P2PClient: tick error"; "error" => ?err);
             }
         }
     }

mithril-relay/src/commands/relay.rs

@@ -1,10 +1,10 @@
-use super::{AggregatorCommand, Args, PassiveCommand, SignerCommand};
 use anyhow::anyhow;
 use clap::{CommandFactory, Subcommand};
-use config::{builder::DefaultState, ConfigBuilder};
 use mithril_common::StdResult;
 use mithril_doc::GenerateDocCommands;
 
+use super::{AggregatorCommand, Args, CommandContext, PassiveCommand, SignerCommand};
+
 /// The available sub-commands of the relay
 #[derive(Subcommand, Debug, Clone)]
 pub enum RelayCommands {
@@ -27,11 +27,11 @@ pub enum RelayCommands {
 
 impl RelayCommands {
     /// Execute the command
-    pub async fn execute(&self, config_builder: ConfigBuilder<DefaultState>) -> StdResult<()> {
+    pub async fn execute(&self, context: CommandContext) -> StdResult<()> {
         match self {
-            Self::Aggregator(cmd) => cmd.execute(config_builder).await,
-            Self::Signer(cmd) => cmd.execute(config_builder).await,
-            Self::Passive(cmd) => cmd.execute(config_builder).await,
+            Self::Aggregator(cmd) => cmd.execute(context).await,
+            Self::Signer(cmd) => cmd.execute(context).await,
+            Self::Passive(cmd) => cmd.execute(context).await,
             Self::GenerateDoc(cmd) => cmd
                 .execute(&mut Args::command())
                 .map_err(|message| anyhow!(message)),

mithril-relay/src/commands/signer.rs

@@ -1,11 +1,11 @@
 use std::time::Duration;
 
 use clap::Parser;
-use config::{builder::DefaultState, ConfigBuilder};
 use libp2p::Multiaddr;
 use mithril_common::StdResult;
-use slog_scope::error;
+use slog::error;
 
+use super::CommandContext;
 use crate::SignerRelay;
 
 #[derive(Parser, Debug, Clone)]
@@ -33,7 +33,8 @@ pub struct SignerCommand {
 
 impl SignerCommand {
     /// Main command execution
-    pub async fn execute(&self, _config_builder: ConfigBuilder<DefaultState>) -> StdResult<()> {
+    pub async fn execute(&self, context: CommandContext) -> StdResult<()> {
+        let logger = context.logger();
         let server_port = self.server_port.to_owned();
         let dial_to = self.dial_to.to_owned();
         let addr: Multiaddr = format!("/ip4/0.0.0.0/tcp/{}", self.listen_port).parse()?;
@@ -45,6 +46,7 @@ impl SignerCommand {
             &server_port,
             &aggregator_endpoint,
             &signer_repeater_delay,
+            logger,
         )
         .await?;
         if let Some(dial_to_address) = dial_to {
@@ -53,7 +55,7 @@ impl SignerCommand {
 
         loop {
             if let Err(err) = relay.tick().await {
-                error!("RelaySigner: tick error"; "error" => format!("{err:#?}"));
+                error!(logger, "RelaySigner: tick error"; "error" => ?err);
             }
         }
     }

mithril-relay/src/lib.rs

@@ -21,3 +21,33 @@ pub mod mithril_p2p_topic {
     /// The topic name where signatures are published
     pub const SIGNATURES: &str = "mithril/signatures";
 }
+
+#[cfg(test)]
+pub mod test_tools {
+    use std::fs::File;
+    use std::io;
+    use std::sync::Arc;
+
+    use slog::{Drain, Logger};
+    use slog_async::Async;
+    use slog_term::{CompactFormat, PlainDecorator};
+
+    pub struct TestLogger;
+
+    impl TestLogger {
+        fn from_writer<W: io::Write + Send + 'static>(writer: W) -> Logger {
+            let decorator = PlainDecorator::new(writer);
+            let drain = CompactFormat::new(decorator).build().fuse();
+            let drain = Async::new(drain).build().fuse();
+            Logger::root(Arc::new(drain), slog::o!())
+        }
+
+        pub fn stdout() -> Logger {
+            Self::from_writer(slog_term::TestStdoutWriter)
+        }
+
+        pub fn file(filepath: &std::path::Path) -> Logger {
+            Self::from_writer(File::create(filepath).unwrap())
+        }
+    }
+}

mithril-relay/src/main.rs

@@ -8,8 +8,10 @@ use mithril_relay::Args;
 use slog::{Drain, Level, Logger};
 
 pub fn build_logger(min_level: Level) -> Logger {
-    let decorator = slog_term::TermDecorator::new().build();
-    let drain = slog_term::CompactFormat::new(decorator).build().fuse();
+    let drain = slog_bunyan::with_name("mithril-relay", std::io::stderr())
+        .set_pretty(false)
+        .build()
+        .fuse();
     let drain = slog::LevelFilter::new(drain, min_level).fuse();
     let drain = slog_async::Async::new(drain).build().fuse();
 
@@ -19,7 +21,7 @@ pub fn build_logger(min_level: Level) -> Logger {
 #[tokio::main]
 async fn main() -> StdResult<()> {
     let args = Args::parse();
-    let _guard = slog_scope::set_global_logger(build_logger(args.log_level()));
+    let logger = build_logger(args.log_level());
 
-    args.execute().await
+    args.execute(logger).await
 }