style(relay): remove prefixes used in logs & apply standard rules

* Capitalize first letter of functionnal logs

Author: Alenar

mithril-relay/src/p2p/peer.rs

@@ -112,7 +112,7 @@ impl Peer {
 
     /// Start the peer
     pub async fn start(mut self) -> StdResult<Self> {
-        debug!(self.logger, "Peer: starting...");
+        debug!(self.logger, "Starting...");
         let mut swarm = SwarmBuilder::with_new_identity()
             .with_tokio()
             .with_tcp(
@@ -150,7 +150,7 @@ impl Peer {
             .build();
 
         for topic in self.topics.values() {
-            debug!(self.logger, "Peer: subscribing to"; "topic" => ?topic, "local_peer_id" => ?self.local_peer_id());
+            debug!(self.logger, "Subscribing to"; "topic" => ?topic, "local_peer_id" => ?self.local_peer_id());
             swarm.behaviour_mut().gossipsub.subscribe(topic)?;
         }
 
@@ -159,7 +159,7 @@ impl Peer {
 
         loop {
             if let Some(PeerEvent::ListeningOnAddr { address }) = self.tick_swarm().await? {
-                info!(self.logger, "Peer: listening on"; "address" => ?address, "local_peer_id" => ?self.local_peer_id());
+                info!(self.logger, "Listening on"; "address" => ?address, "local_peer_id" => ?self.local_peer_id());
                 self.addr_peer = Some(address);
                 break;
             }
@@ -183,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!(self.logger, "Peer: reading next event"; "local_peer_id" => ?self.local_peer_id());
+        debug!(self.logger, "Reading next event"; "local_peer_id" => ?self.local_peer_id());
         match self
             .swarm
             .as_mut()
@@ -193,23 +193,23 @@ impl Peer {
             .await
         {
             Some(swarm::SwarmEvent::NewListenAddr { address, .. }) => {
-                debug!(self.logger, "Peer: received listening address event"; "address" => ?address, "local_peer_id" => ?self.local_peer_id());
+                debug!(self.logger, "Received listening address event"; "address" => ?address, "local_peer_id" => ?self.local_peer_id());
                 Ok(Some(PeerEvent::ListeningOnAddr { address }))
             }
             Some(swarm::SwarmEvent::OutgoingConnectionError { peer_id, error, .. }) => {
-                debug!(self.logger, "Peer: received outgoing connection error event"; "error" => ?error, "remote_peer_id" => ?peer_id, "local_peer_id" => ?self.local_peer_id());
+                debug!(self.logger, "Received outgoing connection error event"; "error" => ?error, "remote_peer_id" => ?peer_id, "local_peer_id" => ?self.local_peer_id());
                 Ok(Some(PeerEvent::OutgoingConnectionError { peer_id, error }))
             }
             Some(swarm::SwarmEvent::ConnectionEstablished { peer_id, .. }) => {
-                debug!(self.logger, "Peer: received connection established event"; "remote_peer_id" => ?peer_id, "local_peer_id" => ?self.local_peer_id());
+                debug!(self.logger, "Received connection established event"; "remote_peer_id" => ?peer_id, "local_peer_id" => ?self.local_peer_id());
                 Ok(Some(PeerEvent::ConnectionEstablished { peer_id }))
             }
             Some(swarm::SwarmEvent::Behaviour(event)) => {
-                debug!(self.logger, "Peer: received behaviour event"; "event" => ?event, "local_peer_id" => ?self.local_peer_id());
+                debug!(self.logger, "Received behaviour event"; "event" => ?event, "local_peer_id" => ?self.local_peer_id());
                 Ok(Some(PeerEvent::Behaviour { event }))
             }
             Some(event) => {
-                debug!(self.logger, "Peer: received other event"; "event" => ?event, "local_peer_id" => ?self.local_peer_id());
+                debug!(self.logger, "Received other event"; "event" => ?event, "local_peer_id" => ?self.local_peer_id());
                 Ok(None)
             }
             _ => Ok(None),
@@ -276,7 +276,7 @@ impl Peer {
 
     /// Connect to a remote peer
     pub fn dial(&mut self, addr: Multiaddr) -> StdResult<()> {
-        debug!(self.logger, "Peer: dialing to"; "address" => ?addr, "local_peer_id" => ?self.local_peer_id());
+        debug!(self.logger, "Dialing to"; "address" => ?addr, "local_peer_id" => ?self.local_peer_id());
         self.swarm
             .as_mut()
             .ok_or(PeerError::UnavailableSwarm())

mithril-relay/src/relay/aggregator.rs

@@ -43,17 +43,17 @@ impl AggregatorRelay {
         match response {
             Ok(response) => match response.status() {
                 StatusCode::CREATED => {
-                    info!(self.logger, "Relay aggregator: sent successfully signature message to aggregator"; "signature_message" => #?signature_message);
+                    info!(self.logger, "Sent successfully signature message to aggregator"; "signature_message" => #?signature_message);
                     Ok(())
                 }
                 status => {
-                    error!(self.logger, "Relay aggregator: Post `/register-signatures` should have returned a 201 status code, got: {status}");
+                    error!(self.logger, "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!(
-                    self.logger, "Relay aggregator: Post `/register-signatures` failed";
+                    self.logger, "Post `/register-signatures` failed";
                     "error" => ?err
                 );
                 Err(anyhow!(err).context("Post `/register-signatures` failed"))
@@ -74,17 +74,17 @@ impl AggregatorRelay {
         match response {
             Ok(response) => match response.status() {
                 StatusCode::CREATED => {
-                    info!(self.logger, "Relay aggregator: sent successfully signer registration message to aggregator"; "signer_message" => #?signer_message);
+                    info!(self.logger, "Sent successfully signer registration message to aggregator"; "signer_message" => #?signer_message);
                     Ok(())
                 }
                 status => {
-                    error!(self.logger, "Relay aggregator: Post `/register-signer` should have returned a 201 status code, got: {status}");
+                    error!(self.logger, "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!(
-                    self.logger, "Relay aggregator: Post `/register-signer` failed";
+                    self.logger, "Post `/register-signer` failed";
                     "error" => ?err
                 );
                 Err(anyhow!(err).context("Post `/register-signer` failed"))
@@ -105,7 +105,7 @@ impl AggregatorRelay {
                     {
                         retry_count += 1;
                         if retry_count >= retry_max {
-                            error!(self.logger, "Relay aggregator: failed to send signer registration message to aggregator after {retry_count} attempts"; "signer_message" => #?signer_message_received, "error" => ?e);
+                            error!(self.logger, "Failed to send signer registration message to aggregator after {retry_count} attempts"; "signer_message" => #?signer_message_received, "error" => ?e);
                             return Err(e);
                         }
                     }
@@ -119,7 +119,7 @@ impl AggregatorRelay {
                     {
                         retry_count += 1;
                         if retry_count >= retry_max {
-                            error!(self.logger, "Relay aggregator: failed to send signature message to aggregator after {retry_count} attempts"; "signature_message" => #?signature_message_received, "error" => ?e);
+                            error!(self.logger, "Failed to send signature message to aggregator after {retry_count} attempts"; "signature_message" => #?signature_message_received, "error" => ?e);
                             return Err(e);
                         }
                     }

mithril-relay/src/relay/passive.rs

@@ -16,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!(relay_logger, "PassiveRelay: starting...");
+        debug!(relay_logger, "Starting...");
 
         Ok(Self {
             peer: Peer::new(addr).with_logger(logger).start().await?,
@@ -38,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!(self.logger, "Relay passive: received signer registration message from P2P network"; "signer_message" => #?signer_message_received);
+                    info!(self.logger, "Received signer registration message from P2P network"; "signer_message" => #?signer_message_received);
                 }
                 Ok(Some(BroadcastMessage::RegisterSignature(signature_message_received))) => {
-                    info!(self.logger, "Relay passive: received signature message from P2P network"; "signature_message" => #?signature_message_received);
+                    info!(self.logger, "Received signature message from P2P network"; "signature_message" => #?signature_message_received);
                 }
                 Ok(None) => {}
                 Err(e) => return Err(e),

mithril-relay/src/relay/signer.rs

@@ -34,7 +34,7 @@ impl SignerRelay {
         logger: &Logger,
     ) -> StdResult<Self> {
         let relay_logger = logger.new_with_component_name::<Self>();
-        debug!(relay_logger, "SignerRelay: starting...");
+        debug!(relay_logger, "Starting...");
         let (signature_tx, signature_rx) = unbounded_channel::<RegisterSignatureMessage>();
         let (signer_tx, signer_rx) = unbounded_channel::<RegisterSignerMessage>();
         let signer_repeater = Arc::new(MessageRepeater::new(
@@ -52,7 +52,7 @@ impl SignerRelay {
             logger,
         )
         .await;
-        info!(relay_logger, "SignerRelay: listening on"; "address" => ?server.address());
+        info!(relay_logger, "Listening on"; "address" => ?server.address());
 
         Ok(Self {
             server,
@@ -118,25 +118,25 @@ impl SignerRelay {
             message = self.signature_rx.recv()  => {
                 match message {
                     Some(signature_message) => {
-                        info!(self.logger, "SignerRelay: publish signature to p2p network"; "message" => #?signature_message);
+                        info!(self.logger, "Publish signature to p2p network"; "message" => #?signature_message);
                         self.peer.publish_signature(&signature_message)?;
                         Ok(())
                     }
                     None => {
-                        debug!(self.logger, "SignerRelay: no signature message available");
+                        debug!(self.logger, "No signature message available");
                         Ok(())
                     }
                 }
             },
             message = self.signer_rx.recv()  => {
                 match message {
                     Some(signer_message) => {
-                        info!(self.logger, "SignerRelay: publish signer-registration to p2p network"; "message" => #?signer_message);
+                        info!(self.logger, "Publish signer-registration to p2p network"; "message" => #?signer_message);
                         self.peer.publish_signer_registration(&signer_message)?;
                         Ok(())
                     }
                     None => {
-                        debug!(self.logger, "SignerRelay: no signer message available");
+                        debug!(self.logger, "No signer message available");
                         Ok(())
                     }
                 }
@@ -220,7 +220,7 @@ mod handlers {
         logger: Logger,
         aggregator_endpoint: String,
     ) -> Result<impl warp::Reply, Infallible> {
-        debug!(logger, "SignerRelay: serve HTTP route /");
+        debug!(logger, "Serve HTTP route /");
         let response = reqwest::Client::new()
             .get(format!("{aggregator_endpoint}/"))
             .send()
@@ -234,7 +234,7 @@ mod handlers {
         tx: UnboundedSender<RegisterSignerMessage>,
         repeater: Arc<repeater::MessageRepeater<RegisterSignerMessage>>,
     ) -> Result<impl warp::Reply, Infallible> {
-        debug!(logger, "SignerRelay: serve HTTP route /register-signer"; "register_signer_message" => #?register_signer_message);
+        debug!(logger, "Serve HTTP route /register-signer"; "register_signer_message" => #?register_signer_message);
 
         repeater.set_message(register_signer_message.clone()).await;
         match tx.send(register_signer_message) {
@@ -254,7 +254,7 @@ mod handlers {
         logger: Logger,
         tx: UnboundedSender<RegisterSignatureMessage>,
     ) -> Result<impl warp::Reply, Infallible> {
-        debug!(logger, "SignerRelay: serve HTTP route /register-signatures"; "register_signature_message" => #?register_signature_message);
+        debug!(logger, "Serve HTTP route /register-signatures"; "register_signature_message" => #?register_signature_message);
         match tx.send(register_signature_message) {
             Ok(_) => Ok(Box::new(warp::reply::with_status(
                 "".to_string(),
@@ -271,7 +271,7 @@ mod handlers {
         logger: Logger,
         aggregator_endpoint: String,
     ) -> Result<impl warp::Reply, Infallible> {
-        debug!(logger, "SignerRelay: serve HTTP route /epoch-settings");
+        debug!(logger, "Serve HTTP route /epoch-settings");
         let response = reqwest::Client::new()
             .get(format!("{aggregator_endpoint}/epoch-settings"))
             .send()
@@ -283,7 +283,7 @@ mod handlers {
         logger: Logger,
         aggregator_endpoint: String,
     ) -> Result<impl warp::Reply, Infallible> {
-        debug!(logger, "SignerRelay: serve HTTP route /certificate-pending");
+        debug!(logger, "Serve HTTP route /certificate-pending");
         let response = reqwest::Client::new()
             .get(format!("{aggregator_endpoint}/certificate-pending"))
             .send()
@@ -300,29 +300,30 @@ mod handlers {
                 Ok(status) => match response.text().await {
                     Ok(content) => {
                         debug!(
-                            logger, "SignerRelay: received response with status '{status}' and content {content:?}"
+                            logger,
+                            "received response with status '{status}' and content {content:?}"
                         );
 
                         Ok(Box::new(warp::reply::with_status(content, status)))
                     }
                     Err(err) => {
-                        debug!(logger, "SignerRelay: received error"; "error" => ?err);
+                        debug!(logger, "Received error"; "error" => ?err);
                         Ok(Box::new(warp::reply::with_status(
                             format!("{err:?}"),
                             StatusCode::INTERNAL_SERVER_ERROR,
                         )))
                     }
                 },
                 Err(err) => {
-                    debug!(logger, "SignerRelay: failed to parse the returned status"; "error" => ?err);
+                    debug!(logger, "Failed to parse the returned status"; "error" => ?err);
                     Ok(Box::new(warp::reply::with_status(
                         format!("{err:?}"),
                         StatusCode::INTERNAL_SERVER_ERROR,
                     )))
                 }
             },
             Err(err) => {
-                debug!(logger, "SignerRelay: received error"; "error" => ?err);
+                debug!(logger, "Received error"; "error" => ?err);
                 Ok(Box::new(warp::reply::with_status(
                     format!("{err:?}"),
                     StatusCode::INTERNAL_SERVER_ERROR,

mithril-relay/src/repeater.rs

@@ -30,13 +30,13 @@ impl<M: Clone + Debug + Sync + Send + 'static> MessageRepeater<M> {
     }
 
     async fn reset_next_repeat_at(&self) {
-        debug!(self.logger, "MessageRepeater: reset next_repeat_at");
+        debug!(self.logger, "Reset next_repeat_at");
         *self.next_repeat_at.lock().await = Some(Instant::now() + self.delay);
     }
 
     /// Set the message to repeat
     pub async fn set_message(&self, message: M) {
-        debug!(self.logger, "MessageRepeater: set message"; "message" => #?message);
+        debug!(self.logger, "Set message"; "message" => #?message);
         *self.message.lock().await = Some(message);
         self.reset_next_repeat_at().await;
     }
@@ -52,13 +52,13 @@ impl<M: Clone + Debug + Sync + Send + 'static> MessageRepeater<M> {
         tokio::time::sleep(wait_delay).await;
         match self.message.lock().await.as_ref() {
             Some(message) => {
-                debug!(self.logger, "MessageRepeater: repeat message"; "message" => #?message);
+                debug!(self.logger, "Repeat message"; "message" => #?message);
                 self.tx_message
                     .send(message.clone())
                     .map_err(|e| anyhow!(e))?
             }
             None => {
-                debug!(self.logger, "MessageRepeater: no message to repeat");
+                debug!(self.logger, "No message to repeat");
             }
         }
         self.reset_next_repeat_at().await;