chore: more debug output

Author: jcnelson

stackslib/src/net/p2p.rs

@@ -644,11 +644,9 @@ impl PeerNetwork {
         let (p2p_handle, bound_p2p_addr) = net.bind(my_addr)?;
         let (http_handle, bound_http_addr) = net.bind(http_addr)?;
 
-        test_debug!(
+        debug!(
             "{:?}: bound on p2p {:?}, http {:?}",
-            &self.local_peer,
-            bound_p2p_addr,
-            bound_http_addr
+            &self.local_peer, bound_p2p_addr, bound_http_addr
         );
 
         self.network = Some(net);
@@ -898,6 +896,12 @@ impl PeerNetwork {
                     return Err(e);
                 }
                 Ok(sz) => {
+                    if sz > 0 {
+                        debug!(
+                            "Sent {} bytes on p2p socket {:?} for conversation {:?}",
+                            sz, client_sock, convo
+                        );
+                    }
                     total_sent += sz;
                     if sz == 0 {
                         break;
@@ -1185,7 +1189,7 @@ impl PeerNetwork {
 
         let next_event_id = match self.network {
             None => {
-                test_debug!("{:?}: network not connected", &self.local_peer);
+                debug!("{:?}: network not connected", &self.local_peer);
                 return Err(net_error::NotConnected);
             }
             Some(ref mut network) => {
@@ -1481,7 +1485,7 @@ impl PeerNetwork {
                         (convo.to_neighbor_key(), Some(neighbor))
                     }
                     None => {
-                        test_debug!(
+                        debug!(
                             "No such neighbor in peer DB, but will ban nevertheless: {:?}",
                             convo.to_neighbor_key()
                         );
@@ -1645,11 +1649,9 @@ impl PeerNetwork {
 
         // already connected?
         if let Some(event_id) = self.get_event_id(&neighbor_key) {
-            test_debug!(
+            debug!(
                 "{:?}: already connected to {:?} on event {}",
-                &self.local_peer,
-                &neighbor_key,
-                event_id
+                &self.local_peer, &neighbor_key, event_id
             );
             return Err(net_error::AlreadyConnected(event_id, neighbor_key.clone()));
         }
@@ -1927,7 +1929,7 @@ impl PeerNetwork {
         match self.events.get(&peer_key) {
             None => {
                 // not connected
-                test_debug!("Could not sign for peer {:?}: not connected", peer_key);
+                debug!("Could not sign for peer {:?}: not connected", peer_key);
                 Err(net_error::PeerNotConnected)
             }
             Some(event_id) => self.sign_for_p2p(*event_id, message_payload),
@@ -1947,7 +1949,7 @@ impl PeerNetwork {
                 message_payload,
             );
         }
-        test_debug!("Could not sign for peer {}: not connected", event_id);
+        debug!("Could not sign for peer {}: not connected", event_id);
         Err(net_error::PeerNotConnected)
     }
 
@@ -1968,7 +1970,7 @@ impl PeerNetwork {
                 message_payload,
             );
         }
-        test_debug!("Could not sign for peer {}: not connected", event_id);
+        debug!("Could not sign for peer {}: not connected", event_id);
         Err(net_error::PeerNotConnected)
     }
 
@@ -2042,7 +2044,7 @@ impl PeerNetwork {
             match (self.peers.remove(&event_id), self.sockets.remove(&event_id)) {
                 (Some(convo), Some(sock)) => (convo, sock),
                 (Some(convo), None) => {
-                    test_debug!("{:?}: Rogue socket event {}", &self.local_peer, event_id);
+                    debug!("{:?}: Rogue socket event {}", &self.local_peer, event_id);
                     self.peers.insert(event_id, convo);
                     return Err(net_error::PeerNotConnected);
                 }
@@ -2055,7 +2057,7 @@ impl PeerNetwork {
                     return Err(net_error::PeerNotConnected);
                 }
                 (None, None) => {
-                    test_debug!("{:?}: Rogue socket event {}", &self.local_peer, event_id);
+                    debug!("{:?}: Rogue socket event {}", &self.local_peer, event_id);
                     return Err(net_error::PeerNotConnected);
                 }
             };
@@ -2184,7 +2186,7 @@ impl PeerNetwork {
             ) {
                 Ok((convo_unhandled, alive)) => (convo_unhandled, alive),
                 Err(_e) => {
-                    test_debug!(
+                    debug!(
                         "{:?}: Connection to {:?} failed: {:?}",
                         &self.local_peer,
                         self.get_p2p_convo(*event_id),
@@ -2196,7 +2198,7 @@ impl PeerNetwork {
             };
 
             if !alive {
-                test_debug!(
+                debug!(
                     "{:?}: Connection to {:?} is no longer alive",
                     &self.local_peer,
                     self.get_p2p_convo(*event_id),
@@ -2383,11 +2385,9 @@ impl PeerNetwork {
                 }
             };
             if neighbor.allowed < 0 || (neighbor.allowed as u64) > now {
-                test_debug!(
+                debug!(
                     "{:?}: event {} is allowed: {:?}",
-                    &self.local_peer,
-                    event_id,
-                    &nk
+                    &self.local_peer, event_id, &nk
                 );
                 safe.insert(*event_id);
             }
@@ -2474,17 +2474,19 @@ impl PeerNetwork {
         let mut relay_handles = std::mem::replace(&mut self.relay_handles, HashMap::new());
         for (event_id, handle_list) in relay_handles.iter_mut() {
             if handle_list.len() == 0 {
+                debug!("No handles for event {}", event_id);
                 drained.push(*event_id);
                 continue;
             }
 
-            test_debug!(
+            debug!(
                 "Flush {} relay handles to event {}",
                 handle_list.len(),
                 event_id
             );
 
             while handle_list.len() > 0 {
+                debug!("Flush {} relay handles", handle_list.len());
                 let res = self.with_p2p_convo(*event_id, |_network, convo, client_sock| {
                     if let Some(handle) = handle_list.front_mut() {
                         let (num_sent, flushed) =
@@ -2496,12 +2498,9 @@ impl PeerNetwork {
                                 }
                             };
 
-                        test_debug!(
+                        debug!(
                             "Flushed relay handle to {:?} ({:?}): sent={}, flushed={}",
-                            client_sock,
-                            convo,
-                            num_sent,
-                            flushed
+                            client_sock, convo, num_sent, flushed
                         );
                         return Ok((num_sent, flushed));
                     }
@@ -2512,14 +2511,15 @@ impl PeerNetwork {
                     Ok(Ok(x)) => x,
                     Ok(Err(_)) | Err(_) => {
                         // connection broken; next list
+                        debug!("Relay handle broken to event {}", event_id);
                         broken.push(*event_id);
                         break;
                     }
                 };
 
                 if !flushed && num_sent == 0 {
                     // blocked on this peer's socket
-                    test_debug!("Relay handle to event {} is blocked", event_id);
+                    debug!("Relay handle to event {} is blocked", event_id);
                     break;
                 }
 
@@ -2553,7 +2553,7 @@ impl PeerNetwork {
     /// Return true if we finish, and true if we're throttled
     fn do_network_neighbor_walk(&mut self, ibd: bool) -> bool {
         if cfg!(test) && self.connection_opts.disable_neighbor_walk {
-            test_debug!("neighbor walk is disabled");
+            debug!("neighbor walk is disabled");
             return true;
         }
 
@@ -2800,15 +2800,15 @@ impl PeerNetwork {
     fn need_public_ip(&mut self) -> bool {
         if !self.public_ip_learned {
             // IP was given, not learned.  nothing to do
-            test_debug!("{:?}: IP address was given to us", &self.local_peer);
+            debug!("{:?}: IP address was given to us", &self.local_peer);
             return false;
         }
         if self.local_peer.public_ip_address.is_some()
             && self.public_ip_learned_at + self.connection_opts.public_ip_timeout
                 >= get_epoch_time_secs()
         {
             // still fresh
-            test_debug!("{:?}: learned IP address is still fresh", &self.local_peer);
+            debug!("{:?}: learned IP address is still fresh", &self.local_peer);
             return false;
         }
         let throttle_timeout = if self.local_peer.public_ip_address.is_none() {
@@ -2871,7 +2871,7 @@ impl PeerNetwork {
         match self.do_learn_public_ip() {
             Ok(b) => {
                 if !b {
-                    test_debug!("{:?}: try do_learn_public_ip again", &self.local_peer);
+                    debug!("{:?}: try do_learn_public_ip again", &self.local_peer);
                     return false;
                 }
             }
@@ -2958,15 +2958,15 @@ impl PeerNetwork {
 
             for (_, block, _) in network_result.blocks.iter() {
                 if block_set.contains(&block.block_hash()) {
-                    test_debug!("Duplicate block {}", block.block_hash());
+                    debug!("Duplicate block {}", block.block_hash());
                 }
                 block_set.insert(block.block_hash());
             }
 
             for (_, mblocks, _) in network_result.confirmed_microblocks.iter() {
                 for mblock in mblocks.iter() {
                     if microblock_set.contains(&mblock.block_hash()) {
-                        test_debug!("Duplicate microblock {}", mblock.block_hash());
+                        debug!("Duplicate microblock {}", mblock.block_hash());
                     }
                     microblock_set.insert(mblock.block_hash());
                 }
@@ -4209,7 +4209,7 @@ impl PeerNetwork {
                         }
                         None => {
                             // skip this step -- no DNS client available
-                            test_debug!(
+                            debug!(
                                 "{:?}: no DNS client provided; skipping block download",
                                 &self.local_peer
                             );
@@ -4315,7 +4315,7 @@ impl PeerNetwork {
             }
             None => {
                 // skip this step -- no DNS client available
-                test_debug!(
+                debug!(
                     "{:?}: no DNS client provided; skipping block download",
                     &self.local_peer
                 );
@@ -4364,7 +4364,11 @@ impl PeerNetwork {
                 convo.to_neighbor_key(),
             ),
             None => {
-                test_debug!("No such neighbor event={}", event_id);
+                debug!(
+                    "{:?}: No such neighbor event={}",
+                    self.get_local_peer(),
+                    event_id
+                );
                 return None;
             }
         };
@@ -4373,10 +4377,9 @@ impl PeerNetwork {
             let reciprocal_event_id = match self.find_reciprocal_event(event_id) {
                 Some(re) => re,
                 None => {
-                    test_debug!(
+                    debug!(
                         "{:?}: no reciprocal conversation for {:?}",
-                        &self.local_peer,
-                        &neighbor_key
+                        &self.local_peer, &neighbor_key
                     );
                     return None;
                 }
@@ -4390,32 +4393,26 @@ impl PeerNetwork {
                         convo.to_neighbor_key(),
                     ),
                     None => {
-                        test_debug!(
+                        debug!(
                             "{:?}: No reciprocal conversation for {} (event={})",
-                            &self.local_peer,
-                            &neighbor_key,
-                            event_id
+                            &self.local_peer, &neighbor_key, event_id
                         );
                         return None;
                     }
                 };
 
             if !is_authenticated && !reciprocal_is_authenticated {
-                test_debug!(
+                debug!(
                     "{:?}: {:?} and {:?} are not authenticated",
-                    &self.local_peer,
-                    &neighbor_key,
-                    &reciprocal_neighbor_key
+                    &self.local_peer, &neighbor_key, &reciprocal_neighbor_key
                 );
                 return None;
             }
 
             if !is_outbound && !reciprocal_is_outbound {
-                test_debug!(
+                debug!(
                     "{:?}: {:?} and {:?} are not outbound",
-                    &self.local_peer,
-                    &neighbor_key,
-                    &reciprocal_neighbor_key
+                    &self.local_peer, &neighbor_key, &reciprocal_neighbor_key
                 );
                 return None;
             }
@@ -5196,7 +5193,7 @@ impl PeerNetwork {
     /// for.  Add them to our network pingbacks
     fn schedule_network_pingbacks(&mut self, event_ids: Vec<usize>) {
         if cfg!(test) && self.connection_opts.disable_pingbacks {
-            test_debug!("{:?}: pingbacks are disabled for testing", &self.local_peer);
+            debug!("{:?}: pingbacks are disabled for testing", &self.local_peer);
             return;
         }
 
@@ -5278,7 +5275,7 @@ impl PeerNetwork {
             }
         }
 
-        test_debug!(
+        debug!(
             "{:?}: have {} pingbacks scheduled",
             &self.local_peer,
             self.walk_pingbacks.len()
@@ -5580,6 +5577,13 @@ impl PeerNetwork {
             };
 
             // update cached burnchain view for /v2/info
+            debug!(
+                "{:?}: chain view for burn block {} has stacks tip consensus {}",
+                &self.local_peer,
+                new_chain_view.burn_block_height,
+                &new_chain_view.rc_consensus_hash
+            );
+
             self.chain_view = new_chain_view;
             self.chain_view_stable_consensus_hash = new_chain_view_stable_consensus_hash;
         }
@@ -5649,7 +5653,7 @@ impl PeerNetwork {
                 .get_last_selected_anchor_block_txid()?
                 .unwrap_or(Txid([0x00; 32]));
 
-            test_debug!(
+            debug!(
                 "{:?}: chain view is {:?}",
                 &self.get_local_peer(),
                 &self.chain_view