manually fix some of the net messages to remove target from the actual log string

src/net/protocol/protocol_address.rs

@@ -89,10 +89,14 @@ impl ProtocolAddress {
     /// address messages on the address subsciption. Adds the recieved
     /// addresses to the list of hosts.
     async fn handle_receive_addrs(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_address::handle_receive_addrs()", "ProtocolAddress::handle_receive_addrs() [START]");
+        debug!(target: "net::protocol_address::handle_receive_addrs()", "START");
         loop {
             let addrs_msg = self.addrs_sub.receive().await?;
-            debug!(target: "net::protocol_address::handle_receive_addrs()", "ProtocolAddress::handle_receive_addrs() received {} addrs", addrs_msg.addrs.len());
+            debug!(
+                target: "net::protocol_address::handle_receive_addrs()",
+                "received {} addrs",
+                addrs_msg.addrs.len()
+            );
             self.hosts.store(addrs_msg.addrs.clone()).await;
         }
     }
@@ -101,10 +105,14 @@ impl ProtocolAddress {
     /// external address messages on the address subsciption. Adds the recieved
     /// external addresses to the list of hosts.
     async fn handle_receive_ext_addrs(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_address::handle_receive_ext_addrs()", "ProtocolAddress::handle_receive_ext_addrs() [START]");
+        debug!(target: "net::protocol_address::handle_receive_ext_addrs()", "START");
         loop {
             let ext_addrs_msg = self.ext_addrs_sub.receive().await?;
-            debug!(target: "net::protocol_address::handle_receive_ext_addrs()", "ProtocolAddress::handle_receive_ext_addrs() received {} addrs", ext_addrs_msg.ext_addrs.len());
+            debug!(
+                target: "net::protocol_address::handle_receive_ext_addrs()",
+                "ProtocolAddress::handle_receive_ext_addrs() received {} addrs",
+                ext_addrs_msg.ext_addrs.len()
+            );
             self.hosts.store_ext(self.channel.address(), ext_addrs_msg.ext_addrs.clone()).await;
         }
     }
@@ -113,17 +121,24 @@ impl ProtocolAddress {
     /// get-address messages on the get-address subsciption. Then replies
     /// with an address message.
     async fn handle_receive_get_addrs(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::handle_receive_get_addrs() [START]");
+        debug!(target: "net::protocol_address::handle_receive_get_addrs()", "START");
         loop {
             let _get_addrs = self.get_addrs_sub.receive().await?;
 
-            debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::handle_receive_get_addrs() received GetAddrs message");
+            debug!(
+                target: "net::protocol_address::handle_receive_get_addrs()",
+                "Received GetAddrs message"
+            );
 
             // Loads the list of hosts.
             let mut addrs = self.hosts.load_all().await;
             // Shuffling list of hosts
             addrs.shuffle(&mut rand::thread_rng());
-            debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::handle_receive_get_addrs() sending {} addrs", addrs.len());
+            debug!(
+                target: "net::protocol_address::handle_receive_get_addrs()",
+                "Sending {} addrs",
+                addrs.len()
+            );
             // Creates an address messages containing host address.
             let addrs_msg = message::AddrsMessage { addrs };
             // Sends the address message across the channel.
@@ -132,7 +147,7 @@ impl ProtocolAddress {
     }
 
     async fn send_my_addrs(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_address::send_my_addrs()", "ProtocolAddress::send_addrs() [START]");
+        debug!(target: "net::protocol_address::send_my_addrs()", "START");
         loop {
             let ext_addrs = self.settings.external_addr.clone();
             let ext_addr_msg = message::ExtAddrsMessage { ext_addrs };
@@ -157,7 +172,7 @@ impl ProtocolBase for ProtocolAddress {
             self.jobsman.clone().spawn(self.clone().send_my_addrs(), executor.clone()).await;
         }
 
-        debug!(target: "net::protocol_address::start()", "ProtocolAddress::start() [START]");
+        debug!(target: "net::protocol_address::start()", "START");
         self.jobsman.clone().start(executor.clone());
         self.jobsman.clone().spawn(self.clone().handle_receive_addrs(), executor.clone()).await;
         self.jobsman.clone().spawn(self.clone().handle_receive_ext_addrs(), executor.clone()).await;
@@ -166,7 +181,7 @@ impl ProtocolBase for ProtocolAddress {
         // Send get_address message.
         let get_addrs = message::GetAddrsMessage {};
         let _ = self.channel.clone().send(get_addrs).await;
-        debug!(target: "net::protocol_address::start()", "ProtocolAddress::start() [END]");
+        debug!(target: "net::protocol_address::start()", "END");
         Ok(())
     }
 

src/net/protocol/protocol_ping.rs

@@ -72,7 +72,7 @@ impl ProtocolPing {
     /// sends a ping message with a random nonce. Loop starts a timer, waits
     /// for the pong reply and insures the nonce is the same.
     async fn run_ping_pong(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_ping::run_ping_pong()", "ProtocolPing::run_ping_pong() [START]");
+        debug!(target: "net::protocol_ping::run_ping_pong()", "START");
         loop {
             // Wait channel_heartbeat amount of time.
             sleep(self.settings.channel_heartbeat_seconds.into()).await;
@@ -83,7 +83,7 @@ impl ProtocolPing {
             // Send ping message.
             let ping = message::PingMessage { nonce };
             self.channel.clone().send(ping).await?;
-            debug!(target: "net::protocol_ping::run_ping_pong()", "ProtocolPing::run_ping_pong() send Ping message");
+            debug!(target: "net::protocol_ping::run_ping_pong()", "Send Ping message");
             // Start the timer for ping timer.
             let start = Instant::now();
 
@@ -91,29 +91,36 @@ impl ProtocolPing {
             let pong_msg = self.pong_sub.receive().await?;
             if pong_msg.nonce != nonce {
                 // TODO: this is too extreme
-                error!(target: "net::protocol_ping::run_ping_pong()", "Wrong nonce for ping reply. Disconnecting from channel.");
+                error!(
+                    target: "net::protocol_ping::run_ping_pong()",
+                    "Wrong nonce for ping reply. Disconnecting from channel."
+                );
                 self.channel.stop().await;
                 return Err(Error::ChannelStopped)
             }
             let duration = start.elapsed().as_millis();
-            debug!(target: "net::protocol_ping::run_ping_pong()", "Received Pong message {}ms from [{:?}]",
-                   duration, self.channel.address());
+            debug!(
+                target: "net::protocol_ping::run_ping_pong()",
+                "Received Pong message {}ms from [{:?}]",
+                duration,
+                self.channel.address()
+            );
         }
     }
 
     /// Waits for ping, then replies with pong. Copies ping's nonce into the
     /// pong reply.
     async fn reply_to_ping(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::reply_to_ping() [START]");
+        debug!(target: "net::protocol_ping::reply_to_ping()", "START");
         loop {
             // Wait for ping, reply with pong that has a matching nonce.
             let ping = self.ping_sub.receive().await?;
-            debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::reply_to_ping() received Ping message");
+            debug!(target: "net::protocol_ping::reply_to_ping()", "Received Ping message");
 
             // Send pong message.
             let pong = message::PongMessage { nonce: ping.nonce };
             self.channel.clone().send(pong).await?;
-            debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::reply_to_ping() sent Pong reply");
+            debug!(target: "net::protocol_ping::reply_to_ping()", "Sent Pong reply");
         }
     }
 
@@ -129,11 +136,11 @@ impl ProtocolBase for ProtocolPing {
     /// protocol task manager, then queues the reply. Sends out a ping and
     /// waits for pong reply. Waits for ping and replies with a pong.
     async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net::protocol_ping::start()", "ProtocolPing::start() [START]");
+        debug!(target: "net::protocol_ping::start()", "START");
         self.jobsman.clone().start(executor.clone());
         self.jobsman.clone().spawn(self.clone().run_ping_pong(), executor.clone()).await;
         self.jobsman.clone().spawn(self.reply_to_ping(), executor).await;
-        debug!(target: "net::protocol_ping::start()", "ProtocolPing::start() [END]");
+        debug!(target: "net::protocol_ping::start()", "END");
         Ok(())
     }
 

src/net/protocol/protocol_seed.rs

@@ -65,7 +65,7 @@ impl ProtocolSeed {
         }
 
         let ext_addrs = self.settings.external_addr.clone();
-        debug!(target: "net::protocol_seed::send_self_address()", "ProtocolSeed::send_self_address() ext_addrs={:?}", ext_addrs);
+        debug!(target: "net::protocol_seed::send_self_address()", "ext_addrs={:?}", ext_addrs);
         let ext_addr_msg = message::ExtAddrsMessage { ext_addrs };
         self.channel.clone().send(ext_addr_msg).await
     }
@@ -88,10 +88,7 @@ impl ProtocolBase for ProtocolSeed {
 
         // Receive addresses.
         let addrs_msg = self.addr_sub.receive().await?;
-        debug!(
-            target: "net::protocol_seed::start()",
-            "ProtocolSeed::start() received {} addrs",
-            addrs_msg.addrs.len()
+        debug!(target: "net::protocol_seed::start()", "Received {} addrs", addrs_msg.addrs.len()
         );
         self.hosts.store(addrs_msg.addrs.clone()).await;
 

src/net/protocol/protocol_version.rs

@@ -64,7 +64,7 @@ impl ProtocolVersion {
     /// and wait for version acknowledgement. Wait for version info and send
     /// version acknowledgement.
     pub async fn run(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net::protocol_version::run()", "ProtocolVersion::run() [START]");
+        debug!(target: "net::protocol_version::run()", "START");
         // Start timer
         // Send version, wait for verack
         // Wait for version, send verack
@@ -79,13 +79,13 @@ impl ProtocolVersion {
             return Err(Error::ChannelTimeout)
         }
 
-        debug!(target: "net::protocol_version::run()", "ProtocolVersion::run() [END]");
+        debug!(target: "net::protocol_version::run()", "END");
         Ok(())
     }
 
     /// Send and recieve version information.
     async fn exchange_versions(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net::protocol_version::exchange_versions()", "ProtocolVersion::exchange_versions() [START]");
+        debug!(target: "net::protocol_version::exchange_versions()", "START");
 
         let send = executor.spawn(self.clone().send_version());
         let recv = executor.spawn(self.recv_version());
@@ -93,14 +93,14 @@ impl ProtocolVersion {
         send.await?;
         recv.await?;
 
-        debug!(target: "net::protocol_version::exchange_versions()", "ProtocolVersion::exchange_versions() [END]");
+        debug!(target: "net::protocol_version::exchange_versions()", "END");
         Ok(())
     }
 
     /// Send version info and wait for version acknowledgement
     /// and ensures the app version is the same, if configured.
     async fn send_version(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [START]");
+        debug!(target: "net::protocol_version::send_version()", "START");
 
         let version = message::VersionMessage { node_id: self.settings.node_id.clone() };
 
@@ -114,14 +114,21 @@ impl ProtocolVersion {
         if !self.settings.seeds.contains(&self.channel.address()) {
             match &self.settings.app_version {
                 Some(app_version) => {
-                    debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [App version: {}]", app_version);
-                    debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [Recieved version: {}]", verack_msg.app);
+                    debug!(
+                        target: "net::protocol_version::send_version()",
+                        "App version: {}, received version: {}",
+                        app_version,
+                        verack_msg.app
+                    );
                     // Version format: MAJOR.MINOR.PATCH
                     let app_versions: Vec<&str> = app_version.split('.').collect();
                     let verack_msg_versions: Vec<&str> = verack_msg.app.split('.').collect();
                     // Check for malformed versions
                     if app_versions.len() != 3 || verack_msg_versions.len() != 3 {
-                        error!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [Malformed version detected. Disconnecting from channel.]");
+                        error!(
+                            target: "net::protocol_version::send_version()",
+                            "Malformed version detected. Disconnecting from channel."
+                        );
                         self.hosts.remove(&self.channel.address()).await;
                         self.channel.stop().await;
                         return Err(Error::ChannelStopped)
@@ -132,7 +139,7 @@ impl ProtocolVersion {
                     {
                         error!(
                             target: "net::protocol_version::send_version()",
-                            "ProtocolVersion::send_version() [Wrong app version from ({}). Disconnecting from channel.]",
+                            "Wrong app version from ({}). Disconnecting from channel.",
                             self.channel.address()
                         );
                         self.hosts.remove(&self.channel.address()).await;
@@ -141,19 +148,22 @@ impl ProtocolVersion {
                     }
                 }
                 None => {
-                    debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [App version not set, ignorring received]")
+                    debug!(
+                        target: "net::protocol_version::send_version()",
+                        "App version not set, ignoring received"
+                    )
                 }
             }
         }
 
-        debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [END]");
+        debug!(target: "net::protocol_version::send_version()", "END");
         Ok(())
     }
 
     /// Recieve version info, check the message is okay and send version
     /// acknowledgement with app version attached.
     async fn recv_version(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_version::recv_version()", "ProtocolVersion::recv_version() [START]");
+        debug!(target: "net::protocol_version::recv_version()", "START");
         // Receive version message
         let version = self.version_sub.receive().await?;
         self.channel.set_remote_node_id(version.node_id.clone()).await;
@@ -163,7 +173,7 @@ impl ProtocolVersion {
             message::VerackMessage { app: self.settings.app_version.clone().unwrap_or_default() };
         self.channel.clone().send(verack).await?;
 
-        debug!(target: "net::protocol_version::recv_version()", "ProtocolVersion::recv_version() [END]");
+        debug!(target: "net::protocol_version::recv_version()", "END");
         Ok(())
     }
 }