Merge pull request #6158 from kantai/chore/improve-logs

Chore: logging niceties

Author: kantai

stackslib/src/config/mod.rs

@@ -2490,13 +2490,24 @@ impl Default for NodeConfig {
 impl NodeConfig {
     /// Get a SocketAddr for this node's RPC endpoint which uses the loopback address
     pub fn get_rpc_loopback(&self) -> Option<SocketAddr> {
-        let rpc_port = SocketAddr::from_str(&self.rpc_bind)
-            .map_err(|e| {
+        let rpc_port = self.rpc_bind_addr()?.port();
+        Some(SocketAddr::new(Ipv4Addr::LOCALHOST.into(), rpc_port))
+    }
+
+    pub fn rpc_bind_addr(&self) -> Option<SocketAddr> {
+        SocketAddr::from_str(&self.rpc_bind)
+            .inspect_err(|e| {
                 error!("Could not parse node.rpc_bind configuration setting as SocketAddr: {e}");
             })
-            .ok()?
-            .port();
-        Some(SocketAddr::new(Ipv4Addr::LOCALHOST.into(), rpc_port))
+            .ok()
+    }
+
+    pub fn p2p_bind_addr(&self) -> Option<SocketAddr> {
+        SocketAddr::from_str(&self.p2p_bind)
+            .inspect_err(|e| {
+                error!("Could not parse node.rpc_bind configuration setting as SocketAddr: {e}");
+            })
+            .ok()
     }
 
     pub fn add_signers_stackerdbs(&mut self, is_mainnet: bool) {

stackslib/src/net/db.rs

@@ -103,29 +103,17 @@ pub struct LocalPeer {
 
 impl fmt::Display for LocalPeer {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "local.{:x}://(bind={:?})(pub={:?})",
-            self.network_id,
-            &self.addrbytes.to_socketaddr(self.port),
-            &self
-                .public_ip_address
-                .map(|(ref addrbytes, ref port)| addrbytes.to_socketaddr(*port))
-        )
+        write!(f, "local::{}", self.port)?;
+        match &self.public_ip_address {
+            None => Ok(()),
+            Some((addr, port)) => write!(f, "::pub={}", addr.to_socketaddr(*port)),
+        }
     }
 }
 
 impl fmt::Debug for LocalPeer {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "local.{:x}://(bind={:?})(pub={:?})",
-            self.network_id,
-            &self.addrbytes.to_socketaddr(self.port),
-            &self
-                .public_ip_address
-                .map(|(ref addrbytes, ref port)| addrbytes.to_socketaddr(*port))
-        )
+        write!(f, "{self}")
     }
 }
 

stackslib/src/net/p2p.rs

@@ -5260,7 +5260,7 @@ impl PeerNetwork {
             &stacks_epoch.block_limit,
             &stacks_epoch.epoch_id,
         ) {
-            info!("Transaction rejected from mempool, {}", &e.into_json(&txid));
+            debug!("Transaction rejected from mempool, {}", &e.into_json(&txid));
             return false;
         }
 

stackslib/src/net/relay.rs

@@ -2459,19 +2459,19 @@ impl Relayer {
                 // forward if not stale
                 if chunk.rc_consensus_hash != *rc_consensus_hash {
                     debug!("Drop stale uploaded StackerDB chunk";
-                           "stackerdb_contract_id" => &format!("{}", &chunk.contract_id),
+                           "stackerdb_contract_id" => %chunk.contract_id,
                            "slot_id" => chunk.chunk_data.slot_id,
                            "slot_version" => chunk.chunk_data.slot_version,
                            "chunk.rc_consensus_hash" => %chunk.rc_consensus_hash,
                            "network.rc_consensus_hash" => %rc_consensus_hash);
                     continue;
                 }
 
-                debug!("Got uploaded StackerDB chunk"; "stackerdb_contract_id" => &format!("{}", &chunk.contract_id), "slot_id" => chunk.chunk_data.slot_id, "slot_version" => chunk.chunk_data.slot_version);
+                debug!("Got uploaded StackerDB chunk"; "stackerdb_contract_id" => %chunk.contract_id, "slot_id" => chunk.chunk_data.slot_id, "slot_version" => chunk.chunk_data.slot_version);
 
                 let msg = StacksMessageType::StackerDBPushChunk(chunk);
                 if let Err(e) = self.p2p.broadcast_message(vec![], msg) {
-                    warn!("Failed to broadcast Nakamoto blocks: {:?}", &e);
+                    warn!("Failed to broadcast Nakamoto blocks: {e:?}");
                 }
             }
             for (contract_id, new_chunks) in all_events.into_iter() {
@@ -2516,7 +2516,7 @@ impl Relayer {
                                 // to distinguish it from other message types.
                                 debug!(
                                     "Dropping stale StackerDB chunk";
-                                    "stackerdb_contract_id" => &format!("{}", &sync_result.contract_id),
+                                    "stackerdb_contract_id" => %sync_result.contract_id,
                                     "slot_id" => md.slot_id,
                                     "slot_version" => md.slot_version,
                                     "num_bytes" => chunk.data.len(),
@@ -2525,7 +2525,7 @@ impl Relayer {
                             } else {
                                 warn!(
                                     "Failed to store chunk for StackerDB";
-                                    "stackerdb_contract_id" => &format!("{}", &sync_result.contract_id),
+                                    "stackerdb_contract_id" => %sync_result.contract_id,
                                     "slot_id" => md.slot_id,
                                     "slot_version" => md.slot_version,
                                     "num_bytes" => chunk.data.len(),
@@ -2534,7 +2534,7 @@ impl Relayer {
                             }
                             continue;
                         } else {
-                            debug!("Stored chunk"; "stackerdb_contract_id" => &format!("{}", &sync_result.contract_id), "slot_id" => md.slot_id, "slot_version" => md.slot_version);
+                            debug!("Stored chunk"; "stackerdb_contract_id" => %sync_result.contract_id, "slot_id" => md.slot_id, "slot_version" => md.slot_version);
                         }
 
                         if let Some(event_list) = all_events.get_mut(&sync_result.contract_id) {
@@ -2548,13 +2548,13 @@ impl Relayer {
                             chunk_data: chunk,
                         });
                         if let Err(e) = self.p2p.broadcast_message(vec![], msg) {
-                            warn!("Failed to broadcast StackerDB chunk: {:?}", &e);
+                            warn!("Failed to broadcast StackerDB chunk: {e:?}");
                         }
                     }
                 }
                 tx.commit()?;
             } else {
-                info!("Got chunks for unconfigured StackerDB replica"; "stackerdb_contract_id" => &format!("{}", &sc));
+                debug!("Got chunks for unconfigured StackerDB replica"; "stackerdb_contract_id" => %sc);
             }
         }
 
@@ -2579,7 +2579,7 @@ impl Relayer {
         let sync_results = stackerdb_chunks
             .into_iter()
             .map(|chunk_data| {
-                debug!("Received pushed StackerDB chunk {:?}", &chunk_data);
+                debug!("Received pushed StackerDB chunk {chunk_data:?}");
                 let sync_result = StackerDBSyncResult::from_pushed_chunk(chunk_data);
                 sync_result
             })

stackslib/src/net/rpc.rs

@@ -548,14 +548,19 @@ impl ConversationHttp {
                         |conv_http, req| conv_http.handle_request(req, node),
                     )?;
 
+                    let msg_opt_log = if let Some(ref msg) = msg_opt {
+                        msg.get_message_description()
+                    } else {
+                        "None".into()
+                    };
                     info!("Handled StacksHTTPRequest";
                           "verb" => %verb,
                           "path" => %request_path,
                           "processing_time_ms" => start_time.elapsed().as_millis(),
                           "latency_ms" => latency,
                           "conn_id" => self.conn_id,
                           "peer_addr" => &self.peer_addr,
-                          "p2p_msg" => ?msg_opt);
+                          "p2p_msg" => msg_opt_log);
 
                     if let Some(msg) = msg_opt {
                         ret.push(msg);

testnet/stacks-node/src/nakamoto_node.rs

@@ -250,22 +250,31 @@ impl StacksNode {
 
         StacksNode::set_monitoring_miner_address(&keychain, &relayer_thread);
 
+        let relayer_thread_name = format!("relayer:{}", local_peer.port);
         let relayer_thread_handle = thread::Builder::new()
-            .name(format!("relayer-{}", &local_peer.data_url))
+            .name(relayer_thread_name)
             .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
             .spawn(move || {
                 relayer_thread.main(relay_recv);
             })
             .expect("FATAL: failed to start relayer thread");
 
+        let p2p_port = config
+            .node
+            .p2p_bind_addr()
+            .unwrap_or_else(|| panic!("Failed to parse socket: {}", &config.node.p2p_bind))
+            .port();
+        let rpc_port = config
+            .node
+            .rpc_bind_addr()
+            .unwrap_or_else(|| panic!("Failed to parse socket: {}", &config.node.rpc_bind))
+            .port();
+
         let p2p_event_dispatcher = runloop.get_event_dispatcher();
         let p2p_thread = PeerThread::new(runloop, p2p_net);
         let p2p_thread_handle = thread::Builder::new()
             .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
-            .name(format!(
-                "p2p-({},{})",
-                &config.node.p2p_bind, &config.node.rpc_bind
-            ))
+            .name(format!("p2p:({p2p_port},{rpc_port})"))
             .spawn(move || {
                 p2p_thread.main(p2p_event_dispatcher);
             })

testnet/stacks-node/src/run_loop/nakamoto.rs

@@ -306,11 +306,13 @@ impl RunLoop {
         let coordinator_indexer =
             make_bitcoin_indexer(&self.config, Some(self.should_keep_running.clone()));
 
+        let rpc_port = moved_config
+            .node
+            .rpc_bind_addr()
+            .unwrap_or_else(|| panic!("Failed to parse socket: {}", &moved_config.node.rpc_bind))
+            .port();
         let coordinator_thread_handle = thread::Builder::new()
-            .name(format!(
-                "chains-coordinator-{}",
-                &moved_config.node.rpc_bind
-            ))
+            .name(format!("chains-coordinator:{rpc_port}"))
             .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
             .spawn(move || {
                 debug!(