cleanup logging

1 files changed, 14 insertions, 17 deletions

diff --git a/src/peer.rs b/src/peer.rs
index 54ba0a4..d27cda8 100644
--- a/src/peer.rs
+++ b/src/peer.rs
@@ -148,7 +148,6 @@ async fn heal_if_diverged(
 
 // --- peer discovery and HELLO ------------------------------------------------
 
-#[instrument(skip(state, peer))]
 pub(crate) async fn remember_peer(state: &AppState, peer: &str) {
     if peer.is_empty() {
         warn!("Ignoring empty peer public key");
@@ -165,18 +164,18 @@ pub(crate) async fn remember_peer(state: &AppState, peer: &str) {
     if !peer_states.contains_key(peer) {
         peer_states.entry(peer.to_owned()).or_default();
         info!(
+            peer = %peer,
             peer_count = peer_states.len(),
-            "Discovered and registered peer"
+            "Discovered peer"
         );
     } else {
-        trace!("Peer already registered");
+        trace!(peer = %peer, "Peer already registered");
     }
 }
 
-#[instrument(skip(state), fields(peer = %peer))]
 pub(crate) async fn send_hello_once(state: &AppState, peer: &str) -> Result<()> {
     let Some(peer_state_mutex) = state.get_peer_state(peer).await else {
-        trace!("Peer was forgotten; not sending HELLO");
+        trace!(peer = %peer, "Peer was forgotten; not sending HELLO");
         return Ok(());
     };
 
@@ -188,7 +187,7 @@ pub(crate) async fn send_hello_once(state: &AppState, peer: &str) -> Result<()>
             };
             true
         } else {
-            trace!(hello_state = ?peer_state.hello_state, "not sending");
+            trace!(peer = %peer, hello_state = ?peer_state.hello_state, "not sending");
             false
         }
     };
@@ -197,11 +196,10 @@ pub(crate) async fn send_hello_once(state: &AppState, peer: &str) -> Result<()>
         return Ok(());
     }
 
-    info!("Sending HELLO");
+    debug!(to = %peer, "Sending HELLO");
     transmit_hello(state, peer, HELLO_RETRY_INITIAL).await
 }
 
-#[instrument(skip(state), fields(peer = %peer))]
 async fn retry_hello_if_due(state: &AppState, peer: &str) -> Result<()> {
     let Some(peer_state_mutex) = state.get_peer_state(peer).await else {
         return Ok(());
@@ -222,6 +220,7 @@ async fn retry_hello_if_due(state: &AppState, peer: &str) -> Result<()> {
     };
 
     debug!(
+        peer = %peer,
         next_retry_ms = delay.as_millis(),
         "No HELLO_REPLY yet; re-sending HELLO"
     );
@@ -297,7 +296,6 @@ async fn flush_owed_hello_replies(state: &AppState) {
     }
 }
 
-#[instrument(skip(state), fields(peer = %peer))]
 async fn send_hello_reply(state: &AppState, peer: &str) -> Result<()> {
     let cluster_id = state
         .cluster_id()
@@ -331,7 +329,7 @@ async fn send_hello_reply(state: &AppState, peer: &str) -> Result<()> {
 
     let ready = state.is_ready().await;
 
-    debug!(ready, "Prepared HELLO_REPLY");
+    debug!(to = %peer, ready, "Sending HELLO_REPLY");
 
     state
         .transport
@@ -339,12 +337,12 @@ async fn send_hello_reply(state: &AppState, peer: &str) -> Result<()> {
         .await
         .context("Sending HELLO_REPLY")?;
 
-    debug!("HELLO_REPLY sent");
+    trace!(to = %peer, "HELLO_REPLY sent");
     Ok(())
 }
 
-#[instrument(skip(state), fields(from_peer = %from_peer, advertised_peers = ?advertised_peers))]
 async fn discover_peers(state: &AppState, from_peer: &str, advertised_peers: &[String]) {
+    // TODO here we could add a trace t oshwo advertised_peers
     for discovered_peer in advertised_peers {
         if discovered_peer == from_peer {
             continue;
@@ -432,7 +430,6 @@ pub(crate) async fn run_peer_worker(state: AppState) {
 
 // --- peer membership ---------------------------------------------------------
 
-#[instrument(skip(state), fields(peer = %peer, received_cluster = %cluster_id))]
 async fn establish_peer(
     state: &AppState,
     peer: &str,
@@ -482,12 +479,12 @@ async fn establish_peer(
     if peer_state.hello_state != HelloState::Established {
         peer_state.hello_state = HelloState::Established;
         peer_state.reset_sync();
-        info!("Handshake complete; sync state reset");
+        info!(peer = %peer, "Handshake complete; sync state reset");
     }
 
     let pending = std::mem::take(&mut peer_state.pending_inbound_sync);
 
-    info!(cluster_id = %cluster_id, pending_messages = pending.len(), "Peer membership established");
+    info!(peer = %peer, cluster_id = %cluster_id, pending_messages = pending.len(), "Peer membership established");
     Ok(pending)
 }
 
@@ -563,7 +560,6 @@ async fn observe_peer_epoch(state: &AppState, peer: &str, remote: Epoch) -> bool
 
 // --- inbound dispatch --------------------------------------------------------
 
-#[instrument(skip(state, message))]
 pub(crate) async fn handle_message(
     state: &AppState,
     peer: String,
@@ -590,7 +586,7 @@ pub(crate) async fn handle_message(
 
     let same_epoch = observe_peer_epoch(state, &peer, message.epoch()).await;
 
-    debug!(message = ?message, "Received message");
+    //debug!(from = %peer, message = ?message, "Received message");
 
     match message {
         transport::ParsedMessage::Hello(_) => {
@@ -626,6 +622,7 @@ pub(crate) async fn handle_message(
 
             if !pending.is_empty() {
                 debug!(
+                    to = %peer,
                     pending_messages = pending.len(),
                     "Replaying pending sync messages"
                 );