refactor(relay): use a dedicated logger for all logs

+ remove `slog_scope`, now only used in integration tests.

Author: Alenar

mithril-relay/Cargo.toml

@@ -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"

mithril-relay/src/commands/aggregator.rs

@@ -1,7 +1,7 @@
 use clap::Parser;
 use libp2p::Multiaddr;
 use mithril_common::StdResult;
-use slog_scope::error;
+use slog::error;
 
 use super::CommandContext;
 use crate::AggregatorRelay;
@@ -27,16 +27,16 @@ impl AggregatorCommand {
         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, context.logger()).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" => format!("{err:#?}"));
             }
         }
     }

mithril-relay/src/commands/mod.rs

@@ -13,8 +13,7 @@ use clap::Parser;
 use config::{builder::DefaultState, ConfigBuilder, Map, Source, Value};
 use context::CommandContext;
 use mithril_common::StdResult;
-use slog::{Level, Logger};
-use slog_scope::debug;
+use slog::{debug, Level, Logger};
 use std::path::PathBuf;
 
 /// Relay for Mithril Node
@@ -46,9 +45,9 @@ pub struct Args {
 impl Args {
     /// execute command
     pub async fn execute(&self, logger: Logger) -> StdResult<()> {
-        debug!("Run Mode: {}", self.run_mode);
+        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());

mithril-relay/src/commands/passive.rs

@@ -1,7 +1,7 @@
 use clap::Parser;
 use libp2p::Multiaddr;
 use mithril_common::StdResult;
-use slog_scope::error;
+use slog::error;
 
 use super::CommandContext;
 use crate::PassiveRelay;
@@ -22,14 +22,15 @@ impl PassiveCommand {
     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, context.logger()).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" => format!("{err:#?}"));
             }
         }
     }

mithril-relay/src/commands/signer.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use clap::Parser;
 use libp2p::Multiaddr;
 use mithril_common::StdResult;
-use slog_scope::error;
+use slog::error;
 
 use super::CommandContext;
 use crate::SignerRelay;
@@ -34,6 +34,7 @@ pub struct SignerCommand {
 impl SignerCommand {
     /// Main command execution
     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,7 +46,7 @@ impl SignerCommand {
             &server_port,
             &aggregator_endpoint,
             &signer_repeater_delay,
-            context.logger(),
+            logger,
         )
         .await?;
         if let Some(dial_to_address) = dial_to {
@@ -54,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" => format!("{err:#?}"));
             }
         }
     }

mithril-relay/src/main.rs

@@ -20,7 +20,6 @@ pub fn build_logger(min_level: Level) -> Logger {
 async fn main() -> StdResult<()> {
     let args = Args::parse();
     let logger = build_logger(args.log_level());
-    let _guard = slog_scope::set_global_logger(logger.clone());
 
     args.execute(logger).await
 }

mithril-relay/src/p2p/peer.rs

@@ -14,8 +14,7 @@ use mithril_common::{
     StdResult,
 };
 use serde::{Deserialize, Serialize};
-use slog::Logger;
-use slog_scope::{debug, info};
+use slog::{debug, info, Logger};
 use std::{collections::HashMap, time::Duration};
 
 use crate::{mithril_p2p_topic, p2p::PeerError};
@@ -113,7 +112,7 @@ impl Peer {
 
     /// Start the peer
     pub async fn start(mut self) -> StdResult<Self> {
-        debug!("Peer: starting...");
+        debug!(self.logger, "Peer: starting...");
         let mut swarm = SwarmBuilder::with_new_identity()
             .with_tokio()
             .with_tcp(
@@ -151,7 +150,7 @@ impl Peer {
             .build();
 
         for topic in self.topics.values() {
-            debug!("Peer: subscribing to"; "topic" => format!("{topic:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
+            debug!(self.logger, "Peer: subscribing to"; "topic" => format!("{topic:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
             swarm.behaviour_mut().gossipsub.subscribe(topic)?;
         }
 
@@ -160,7 +159,7 @@ impl Peer {
 
         loop {
             if let Some(PeerEvent::ListeningOnAddr { address }) = self.tick_swarm().await? {
-                info!("Peer: listening on"; "address" => format!("{address:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
+                info!(self.logger, "Peer: listening on"; "address" => format!("{address:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
                 self.addr_peer = Some(address);
                 break;
             }
@@ -184,7 +183,7 @@ impl Peer {
 
     /// Tick the peer swarm to receive the next event
     pub async fn tick_swarm(&mut self) -> StdResult<Option<PeerEvent>> {
-        debug!("Peer: reading next event"; "local_peer_id" => format!("{:?}", self.local_peer_id()));
+        debug!(self.logger, "Peer: reading next event"; "local_peer_id" => format!("{:?}", self.local_peer_id()));
         match self
             .swarm
             .as_mut()
@@ -194,23 +193,23 @@ impl Peer {
             .await
         {
             Some(swarm::SwarmEvent::NewListenAddr { address, .. }) => {
-                debug!("Peer: received listening address event"; "address" => format!("{address:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
+                debug!(self.logger, "Peer: received listening address event"; "address" => format!("{address:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
                 Ok(Some(PeerEvent::ListeningOnAddr { address }))
             }
             Some(swarm::SwarmEvent::OutgoingConnectionError { peer_id, error, .. }) => {
-                debug!("Peer: received outgoing connection error event"; "error" => format!("{error:#?}"), "remote_peer_id" => format!("{peer_id:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
+                debug!(self.logger, "Peer: received outgoing connection error event"; "error" => format!("{error:#?}"), "remote_peer_id" => format!("{peer_id:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
                 Ok(Some(PeerEvent::OutgoingConnectionError { peer_id, error }))
             }
             Some(swarm::SwarmEvent::ConnectionEstablished { peer_id, .. }) => {
-                debug!("Peer: received connection established event"; "remote_peer_id" => format!("{peer_id:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
+                debug!(self.logger, "Peer: received connection established event"; "remote_peer_id" => format!("{peer_id:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
                 Ok(Some(PeerEvent::ConnectionEstablished { peer_id }))
             }
             Some(swarm::SwarmEvent::Behaviour(event)) => {
-                debug!("Peer: received behaviour event"; "event" => format!("{event:#?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
+                debug!(self.logger, "Peer: received behaviour event"; "event" => format!("{event:#?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
                 Ok(Some(PeerEvent::Behaviour { event }))
             }
             Some(event) => {
-                debug!("Peer: received other event"; "event" => format!("{event:#?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
+                debug!(self.logger, "Peer: received other event"; "event" => format!("{event:#?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
                 Ok(None)
             }
             _ => Ok(None),
@@ -277,7 +276,7 @@ impl Peer {
 
     /// Connect to a remote peer
     pub fn dial(&mut self, addr: Multiaddr) -> StdResult<()> {
-        debug!("Peer: dialing to"; "address" => format!("{addr:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
+        debug!(self.logger, "Peer: dialing to"; "address" => format!("{addr:?}"), "local_peer_id" => format!("{:?}", self.local_peer_id()));
         self.swarm
             .as_mut()
             .ok_or(PeerError::UnavailableSwarm())

mithril-relay/src/relay/aggregator.rs

@@ -7,8 +7,7 @@ use mithril_common::{
     StdResult,
 };
 use reqwest::StatusCode;
-use slog::Logger;
-use slog_scope::{error, info};
+use slog::{error, info, Logger};
 
 /// A relay for a Mithril aggregator
 pub struct AggregatorRelay {
@@ -44,16 +43,19 @@ impl AggregatorRelay {
         match response {
             Ok(response) => match response.status() {
                 StatusCode::CREATED => {
-                    info!("Relay aggregator: sent successfully signature message to aggregator"; "signature_message" => format!("{:#?}", signature_message));
+                    info!(self.logger, "Relay aggregator: sent successfully signature message to aggregator"; "signature_message" => format!("{:#?}", signature_message));
                     Ok(())
                 }
                 status => {
-                    error!("Relay aggregator: Post `/register-signatures` should have returned a 201 status code, got: {status}");
+                    error!(self.logger, "Relay aggregator: Post `/register-signatures` should have returned a 201 status code, got: {status}");
                     Err(anyhow!("Post `/register-signatures` should have returned a 201 status code, got: {status}"))
                 }
             },
             Err(err) => {
-                error!("Relay aggregator: Post `/register-signatures` failed: {err:?}");
+                error!(
+                    self.logger,
+                    "Relay aggregator: Post `/register-signatures` failed: {err:?}"
+                );
                 Err(anyhow!("Post `/register-signatures` failed: {err:?}"))
             }
         }
@@ -72,16 +74,19 @@ impl AggregatorRelay {
         match response {
             Ok(response) => match response.status() {
                 StatusCode::CREATED => {
-                    info!("Relay aggregator: sent successfully signer registration message to aggregator"; "signer_message" => format!("{:#?}", signer_message));
+                    info!(self.logger, "Relay aggregator: sent successfully signer registration message to aggregator"; "signer_message" => format!("{:#?}", signer_message));
                     Ok(())
                 }
                 status => {
-                    error!("Relay aggregator: Post `/register-signer` should have returned a 201 status code, got: {status}");
+                    error!(self.logger, "Relay aggregator: Post `/register-signer` should have returned a 201 status code, got: {status}");
                     Err(anyhow!("Post `/register-signer` should have returned a 201 status code, got: {status}"))
                 }
             },
             Err(err) => {
-                error!("Relay aggregator: Post `/register-signer` failed: {err:?}");
+                error!(
+                    self.logger,
+                    "Relay aggregator: Post `/register-signer` failed: {err:?}"
+                );
                 Err(anyhow!("Post `/register-signer` failed: {err:?}"))
             }
         }
@@ -100,7 +105,7 @@ impl AggregatorRelay {
                     {
                         retry_count += 1;
                         if retry_count >= retry_max {
-                            error!("Relay aggregator: failed to send signer registration message to aggregator after {retry_count} attempts"; "signer_message" => format!("{:#?}", signer_message_received), "error" => format!("{e:?}"));
+                            error!(self.logger, "Relay aggregator: failed to send signer registration message to aggregator after {retry_count} attempts"; "signer_message" => format!("{:#?}", signer_message_received), "error" => format!("{e:?}"));
                             return Err(e);
                         }
                     }
@@ -114,7 +119,7 @@ impl AggregatorRelay {
                     {
                         retry_count += 1;
                         if retry_count >= retry_max {
-                            error!("Relay aggregator: failed to send signature message to aggregator after {retry_count} attempts"; "signature_message" => format!("{:#?}", signature_message_received), "error" => format!("{e:?}"));
+                            error!(self.logger, "Relay aggregator: failed to send signature message to aggregator after {retry_count} attempts"; "signature_message" => format!("{:#?}", signature_message_received), "error" => format!("{e:?}"));
                             return Err(e);
                         }
                     }

mithril-relay/src/relay/passive.rs

@@ -2,8 +2,7 @@ use crate::p2p::{BroadcastMessage, Peer, PeerEvent};
 use libp2p::Multiaddr;
 use mithril_common::logging::LoggerExtensions;
 use mithril_common::StdResult;
-use slog::Logger;
-use slog_scope::{debug, info};
+use slog::{debug, info, Logger};
 
 /// A passive relay
 pub struct PassiveRelay {
@@ -17,7 +16,7 @@ impl PassiveRelay {
     /// Start a passive relay
     pub async fn start(addr: &Multiaddr, logger: &Logger) -> StdResult<Self> {
         let relay_logger = logger.new_with_component_name::<Self>();
-        debug!("PassiveRelay: starting...");
+        debug!(relay_logger, "PassiveRelay: starting...");
 
         Ok(Self {
             peer: Peer::new(addr).with_logger(logger).start().await?,
@@ -39,10 +38,10 @@ impl PassiveRelay {
         if let Some(peer_event) = self.peer.tick_swarm().await? {
             match self.peer.convert_peer_event_to_message(peer_event) {
                 Ok(Some(BroadcastMessage::RegisterSigner(signer_message_received))) => {
-                    info!("Relay passive: received signer registration message from P2P network"; "signer_message" => format!("{:#?}", signer_message_received));
+                    info!(self.logger, "Relay passive: received signer registration message from P2P network"; "signer_message" => format!("{:#?}", signer_message_received));
                 }
                 Ok(Some(BroadcastMessage::RegisterSignature(signature_message_received))) => {
-                    info!("Relay passive: received signature message from P2P network"; "signature_message" => format!("{:#?}", signature_message_received));
+                    info!(self.logger, "Relay passive: received signature message from P2P network"; "signature_message" => format!("{:#?}", signature_message_received));
                 }
                 Ok(None) => {}
                 Err(e) => return Err(e),