fix broken log targets

src/consensus/proto/protocol_proposal.rs

@@ -45,7 +45,7 @@ impl ProtocolProposal {
         state: ValidatorStatePtr,
         p2p: P2pPtr,
     ) -> Result<ProtocolBasePtr> {
-        debug!("Adding ProtocolProposal to the protocol registry");
+        debug!(target: "consensus::protocol_proposal::init()", "Adding ProtocolProposal to the protocol registry");
         let msg_subsystem = channel.get_message_subsystem();
         msg_subsystem.add_dispatch::<BlockProposal>().await;
 
@@ -63,27 +63,27 @@ impl ProtocolProposal {
     }
 
     async fn handle_receive_proposal(self: Arc<Self>) -> Result<()> {
-        debug!(target: "consensus::protocol_proposal::init()", "ProtocolProposal::handle_receive_proposal() [START]");
+        debug!(target: "consensus::protocol_proposal::handle_receive_proposal()", "ProtocolProposal::handle_receive_proposal() [START]");
 
         let exclude_list = vec![self.channel_address.clone()];
         loop {
             let proposal = match self.proposal_sub.receive().await {
                 Ok(v) => v,
                 Err(e) => {
-                    debug!(target: "consensus::protocol_proposal::init()", "ProtocolProposal::handle_receive_proposal(): recv fail: {}", e);
+                    debug!(target: "consensus::protocol_proposal::handle_receive_proposal()", "ProtocolProposal::handle_receive_proposal(): recv fail: {}", e);
                     continue
                 }
             };
 
-            debug!(target: "consensus::protocol_proposal::init()", "ProtocolProposal::handle_receive_proposal(): recv: {}", proposal);
-            trace!(target: "consensus::protocol_proposal::init()", "ProtocolProposal::handle_receive_proposal(): Full proposal: {:?}", proposal);
+            debug!(target: "consensus::protocol_proposal::handle_receive_proposal()", "ProtocolProposal::handle_receive_proposal(): recv: {}", proposal);
+            trace!(target: "consensus::protocol_proposal::handle_receive_proposal()", "ProtocolProposal::handle_receive_proposal(): Full proposal: {:?}", proposal);
 
             let proposal_copy = (*proposal).clone();
 
             // Verify we have the proposal already
             let mut lock = self.state.write().await;
             if lock.consensus.proposal_exists(&proposal_copy.hash) {
-                debug!(target: "consensus::protocol_proposal::init()", "ProtocolProposal::handle_receive_proposal(): Proposal already received.");
+                debug!(target: "consensus::protocol_proposal::handle_receive_proposal()", "ProtocolProposal::handle_receive_proposal(): Proposal already received.");
                 continue
             }
 
@@ -95,7 +95,7 @@ impl ProtocolProposal {
                             self.p2p.broadcast_with_exclude(proposal_copy, &exclude_list).await
                         {
                             error!(
-                                target: "consensus::protocol_proposal::init()",
+                                target: "consensus::protocol_proposal::handle_receive_proposal()",
                                 "ProtocolProposal::handle_receive_proposal(): proposal broadcast fail: {}",
                                 e
                             );
@@ -104,7 +104,7 @@ impl ProtocolProposal {
                 }
                 Err(e) => {
                     error!(
-                        target: "consensus::protocol_proposal::init()",
+                        target: "consensus::protocol_proposal::handle_receive_proposal()",
                         "ProtocolProposal::handle_receive_proposal(): receive_proposal error: {}",
                         e
                     );
@@ -118,10 +118,10 @@ impl ProtocolProposal {
 #[async_trait]
 impl ProtocolBase for ProtocolProposal {
     async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "consensus::protocol_proposal::init()", "ProtocolProposal::start() [START]");
+        debug!(target: "consensus::protocol_proposal::start()", "ProtocolProposal::start() [START]");
         self.jobsman.clone().start(executor.clone());
         self.jobsman.clone().spawn(self.clone().handle_receive_proposal(), executor.clone()).await;
-        debug!(target: "consensus::protocol_proposal::init()", "ProtocolProposal::start() [END]");
+        debug!(target: "consensus::protocol_proposal::start()", "ProtocolProposal::start() [END]");
         Ok(())
     }
 

src/consensus/proto/protocol_sync.rs

@@ -81,7 +81,7 @@ impl ProtocolSync {
     }
 
     async fn handle_receive_request(self: Arc<Self>) -> Result<()> {
-        debug!("ProtocolSync::handle_receive_request() [START]");
+        debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_request() [START]");
         loop {
             let order = match self.request_sub.receive().await {
                 Ok(v) => v,
@@ -112,13 +112,13 @@ impl ProtocolSync {
     }
 
     async fn handle_receive_block(self: Arc<Self>) -> Result<()> {
-        debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_block() [START]");
+        debug!(target: "consensus::protocol_sync::handle_receive_block()", "ProtocolSync::handle_receive_block() [START]");
         let exclude_list = vec![self.channel.address()];
         loop {
             let info = match self.block_sub.receive().await {
                 Ok(v) => v,
                 Err(e) => {
-                    debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_block(): recv fail: {}", e);
+                    debug!(target: "consensus::protocol_sync::handle_receive_block()", "ProtocolSync::handle_receive_block(): recv fail: {}", e);
                     continue
                 }
             };
@@ -135,7 +135,7 @@ impl ProtocolSync {
                     let slot = participating.unwrap();
                     if current >= slot {
                         debug!(
-                            target: "consensus::protocol_sync::handle_receive_request()",
+                            target: "consensus::protocol_sync::handle_receive_block()",
                             "ProtocolSync::handle_receive_block(): node runs in consensus mode, skipping..."
                         );
                         continue
@@ -143,19 +143,19 @@ impl ProtocolSync {
                 }
             }
 
-            info!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_block(): Received block: {}", info.blockhash());
+            info!(target: "consensus::protocol_sync::handle_receive_block()", "ProtocolSync::handle_receive_block(): Received block: {}", info.blockhash());
 
-            debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_block(): Processing received block");
+            debug!(target: "consensus::protocol_sync::handle_receive_block()", "ProtocolSync::handle_receive_block(): Processing received block");
             let info_copy = (*info).clone();
             match self.state.write().await.receive_finalized_block(info_copy.clone()).await {
                 Ok(v) => {
                     if v {
-                        debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolProposal::handle_receive_block(): block processed successfully, broadcasting...");
+                        debug!(target: "consensus::protocol_sync::handle_receive_block()", "ProtocolProposal::handle_receive_block(): block processed successfully, broadcasting...");
                         if let Err(e) =
                             self.p2p.broadcast_with_exclude(info_copy, &exclude_list).await
                         {
                             error!(
-                                target: "consensus::protocol_sync::handle_receive_request()",
+                                target: "consensus::protocol_sync::handle_receive_block()",
                                 "ProtocolSync::handle_receive_block(): p2p broadcast fail: {}",
                                 e
                             );
@@ -163,20 +163,20 @@ impl ProtocolSync {
                     }
                 }
                 Err(e) => {
-                    debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_block(): error processing finalized block: {}", e);
+                    debug!(target: "consensus::protocol_sync::handle_receive_block()", "ProtocolSync::handle_receive_block(): error processing finalized block: {}", e);
                 }
             };
         }
     }
 
     async fn handle_receive_slot_checkpoint_request(self: Arc<Self>) -> Result<()> {
-        debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_slot_checkpoint_request() [START]");
+        debug!(target: "consensus::protocol_sync::handle_receive_slot_checkpoint_request()", "ProtocolSync::handle_receive_slot_checkpoint_request() [START]");
         loop {
             let request = match self.slot_checkpoin_request_sub.receive().await {
                 Ok(v) => v,
                 Err(e) => {
                     debug!(
-                        target: "consensus::protocol_sync::handle_receive_request()",
+                        target: "consensus::protocol_sync::handle_receive_slot_checkpoint_request()",
                         "ProtocolSync::handle_receive_slot_checkpoint_request(): recv fail: {}",
                         e
                     );
@@ -184,7 +184,7 @@ impl ProtocolSync {
                 }
             };
 
-            debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_slot_checkpoint_request() received {:?}", request);
+            debug!(target: "consensus::protocol_sync::handle_receive_slot_checkpoint_request()", "ProtocolSync::handle_receive_slot_checkpoint_request() received {:?}", request);
 
             // Extra validations can be added here
             let key = request.slot;
@@ -197,12 +197,12 @@ impl ProtocolSync {
             {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_slot_checkpoint_request(): get_slot_checkpoints_after fail: {}", e);
+                    error!(target: "consensus::protocol_sync::handle_receive_slot_checkpoint_request()", "ProtocolSync::handle_receive_slot_checkpoint_request(): get_slot_checkpoints_after fail: {}", e);
                     continue
                 }
             };
             debug!(
-                target: "consensus::protocol_sync::handle_receive_request()",
+                target: "consensus::protocol_sync::handle_receive_slot_checkpoint_request()",
                 "ProtocolSync::handle_receive_slot_checkpoint_request(): Found {} slot checkpoints",
                 slot_checkpoints.len()
             );
@@ -210,7 +210,7 @@ impl ProtocolSync {
             let response = SlotCheckpointResponse { slot_checkpoints };
             if let Err(e) = self.channel.send(response).await {
                 error!(
-                    target: "consensus::protocol_sync::handle_receive_request()",
+                    target: "consensus::protocol_sync::handle_receive_slot_checkpoint_request()",
                     "ProtocolSync::handle_receive_slot_checkpoint_request(): channel send fail: {}",
                     e
                 )
@@ -219,13 +219,13 @@ impl ProtocolSync {
     }
 
     async fn handle_receive_slot_checkpoint(self: Arc<Self>) -> Result<()> {
-        debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_slot_checkpoint() [START]");
+        debug!(target: "consensus::protocol_sync::handle_receive_slot_checkpoint()", "ProtocolSync::handle_receive_slot_checkpoint() [START]");
         let exclude_list = vec![self.channel.address()];
         loop {
             let slot_checkpoint = match self.slot_checkpoints_sub.receive().await {
                 Ok(v) => v,
                 Err(e) => {
-                    debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_slot_checkpoint(): recv fail: {}", e);
+                    debug!(target: "consensus::protocol_sync::handle_receive_slot_checkpoint()", "ProtocolSync::handle_receive_slot_checkpoint(): recv fail: {}", e);
                     continue
                 }
             };
@@ -242,7 +242,7 @@ impl ProtocolSync {
                     let slot = participating.unwrap();
                     if current >= slot {
                         debug!(
-                            target: "consensus::protocol_sync::handle_receive_request()",
+                            target: "consensus::protocol_sync::handle_receive_slot_checkpoint()",
                             "ProtocolSync::handle_receive_block(): node runs in consensus mode, skipping..."
                         );
                         continue
@@ -251,12 +251,12 @@ impl ProtocolSync {
             }
 
             info!(
-                target: "consensus::protocol_sync::handle_receive_request()",
+                target: "consensus::protocol_sync::handle_receive_slot_checkpoint()",
                 "ProtocolSync::handle_receive_slot_checkpoint(): Received slot checkpoint: {}",
                 slot_checkpoint.slot
             );
 
-            debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_slot_checkpoint(): Processing received slot checkpoint");
+            debug!(target: "consensus::protocol_sync::handle_receive_slot_checkpoint()", "ProtocolSync::handle_receive_slot_checkpoint(): Processing received slot checkpoint");
             let slot_checkpoint_copy = (*slot_checkpoint).clone();
             match self
                 .state
@@ -267,14 +267,14 @@ impl ProtocolSync {
             {
                 Ok(v) => {
                     if v {
-                        debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolProposal::handle_receive_slot_checkpoint(): slot checkpoint processed successfully, broadcasting...");
+                        debug!(target: "consensus::protocol_sync::handle_receive_slot_checkpoint()", "ProtocolProposal::handle_receive_slot_checkpoint(): slot checkpoint processed successfully, broadcasting...");
                         if let Err(e) = self
                             .p2p
                             .broadcast_with_exclude(slot_checkpoint_copy, &exclude_list)
                             .await
                         {
                             error!(
-                                target: "consensus::protocol_sync::handle_receive_request()",
+                                target: "consensus::protocol_sync::handle_receive_slot_checkpoint()",
                                 "ProtocolSync::handle_receive_slot_checkpoint(): p2p broadcast fail: {}",
                                 e
                             );
@@ -282,7 +282,7 @@ impl ProtocolSync {
                     }
                 }
                 Err(e) => {
-                    debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::handle_receive_slot_checkpoint(): error processing finalized slot checkpoint: {}", e);
+                    debug!(target: "consensus::protocol_sync::handle_receive_slot_checkpoint()", "ProtocolSync::handle_receive_slot_checkpoint(): error processing finalized slot checkpoint: {}", e);
                 }
             };
         }
@@ -292,7 +292,7 @@ impl ProtocolSync {
 #[async_trait]
 impl ProtocolBase for ProtocolSync {
     async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::start() [START]");
+        debug!(target: "consensus::protocol_sync::start()", "ProtocolSync::start() [START]");
         self.jobsman.clone().start(executor.clone());
         self.jobsman.clone().spawn(self.clone().handle_receive_request(), executor.clone()).await;
         self.jobsman
@@ -304,7 +304,7 @@ impl ProtocolBase for ProtocolSync {
             .clone()
             .spawn(self.clone().handle_receive_slot_checkpoint(), executor.clone())
             .await;
-        debug!(target: "consensus::protocol_sync::handle_receive_request()", "ProtocolSync::start() [END]");
+        debug!(target: "consensus::protocol_sync::start()", "ProtocolSync::start() [END]");
         Ok(())
     }
 

src/consensus/proto/protocol_sync_consensus.rs

@@ -68,7 +68,7 @@ impl ProtocolSyncConsensus {
     }
 
     async fn handle_receive_request(self: Arc<Self>) -> Result<()> {
-        debug!("ProtocolSyncConsensus::handle_receive_request() [START]");
+        debug!(target: "consensus::protocol_sync_consensus::handle_receive_request()", "ProtocolSyncConsensus::handle_receive_request() [START]");
         loop {
             let req = match self.request_sub.receive().await {
                 Ok(v) => v,
@@ -108,18 +108,18 @@ impl ProtocolSyncConsensus {
     }
 
     async fn handle_receive_slot_checkpoints_request(self: Arc<Self>) -> Result<()> {
-        debug!(target: "consensus::protocol_sync_consensus::handle_receive_request()", "ProtocolSyncConsensus::handle_receive_slot_checkpoints_request() [START]");
+        debug!(target: "consensus::protocol_sync_consensus::handle_receive_slot_checkpoints_request()", "ProtocolSyncConsensus::handle_receive_slot_checkpoints_request() [START]");
         loop {
             let req = match self.slot_checkpoints_request_sub.receive().await {
                 Ok(v) => v,
                 Err(e) => {
-                    debug!(target: "consensus::protocol_sync_consensus::handle_receive_request()", "ProtocolSyncConsensus::handle_receive_slot_checkpoints_request() recv fail: {}", e);
+                    debug!(target: "consensus::protocol_sync_consensus::handle_receive_slot_checkpoints_request()", "ProtocolSyncConsensus::handle_receive_slot_checkpoints_request() recv fail: {}", e);
                     continue
                 }
             };
 
             debug!(
-                target: "consensus::protocol_sync_consensus::handle_receive_request()",
+                target: "consensus::protocol_sync_consensus::handle_receive_slot_checkpoints_request()",
                 "ProtocolSyncConsensuss::handle_receive_slot_checkpoints_request() received {:?}",
                 req
             );
@@ -130,7 +130,7 @@ impl ProtocolSyncConsensus {
             let is_empty = lock.consensus.slot_checkpoints.is_empty();
             let response = ConsensusSlotCheckpointsResponse { bootstrap_slot, is_empty };
             if let Err(e) = self.channel.send(response).await {
-                error!(target: "consensus::protocol_sync_consensus::handle_receive_request()", "ProtocolSyncConsensus::handle_receive_slot_checkpoints_request() channel send fail: {}", e);
+                error!(target: "consensus::protocol_sync_consensus::handle_receive_slot_checkpoints_request()", "ProtocolSyncConsensus::handle_receive_slot_checkpoints_request() channel send fail: {}", e);
             };
         }
     }
@@ -139,14 +139,14 @@ impl ProtocolSyncConsensus {
 #[async_trait]
 impl ProtocolBase for ProtocolSyncConsensus {
     async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "consensus::protocol_sync_consensus::handle_receive_request()", "ProtocolSyncConsensus::start() [START]");
+        debug!(target: "consensus::protocol_sync_consensus::start()", "ProtocolSyncConsensus::start() [START]");
         self.jobsman.clone().start(executor.clone());
         self.jobsman.clone().spawn(self.clone().handle_receive_request(), executor.clone()).await;
         self.jobsman
             .clone()
             .spawn(self.clone().handle_receive_slot_checkpoints_request(), executor.clone())
             .await;
-        debug!(target: "consensus::protocol_sync_consensus::handle_receive_request()", "ProtocolSyncConsensus::start() [END]");
+        debug!(target: "consensus::protocol_sync_consensus::start()", "ProtocolSyncConsensus::start() [END]");
         Ok(())
     }
 

src/consensus/proto/protocol_tx.rs

@@ -53,7 +53,7 @@ impl ProtocolTx {
         state: ValidatorStatePtr,
         p2p: P2pPtr,
     ) -> Result<ProtocolBasePtr> {
-        debug!("Adding ProtocolTx to the protocol registry");
+        debug!(target: "consensus::protocol_tx::init()", "Adding ProtocolTx to the protocol registry");
         let msg_subsystem = channel.get_message_subsystem();
         msg_subsystem.add_dispatch::<Transaction>().await;
 
@@ -70,13 +70,13 @@ impl ProtocolTx {
     }
 
     async fn handle_receive_tx(self: Arc<Self>) -> Result<()> {
-        debug!(target: "consensus::protocol_tx::init()", "ProtocolTx::handle_receive_tx() [START]");
+        debug!(target: "consensus::protocol_tx::handle_receive_tx()", "ProtocolTx::handle_receive_tx() [START]");
         let exclude_list = vec![self.channel_address.clone()];
         loop {
             let tx = match self.tx_sub.receive().await {
                 Ok(v) => v,
                 Err(e) => {
-                    debug!(target: "consensus::protocol_tx::init()", "ProtocolTx::handle_receive_tx(): recv fail: {}", e);
+                    debug!(target: "consensus::protocol_tx::handle_receive_tx()", "ProtocolTx::handle_receive_tx(): recv fail: {}", e);
                     continue
                 }
             };
@@ -86,7 +86,7 @@ impl ProtocolTx {
             // Nodes use unconfirmed_txs vector as seen_txs pool.
             if self.state.write().await.append_tx(tx_copy.clone()).await {
                 if let Err(e) = self.p2p.broadcast_with_exclude(tx_copy, &exclude_list).await {
-                    error!(target: "consensus::protocol_tx::init()", "handle_receive_tx(): p2p broadcast fail: {}", e);
+                    error!(target: "consensus::protocol_tx::handle_receive_tx()", "handle_receive_tx(): p2p broadcast fail: {}", e);
                 };
             }
         }
@@ -96,10 +96,10 @@ impl ProtocolTx {
 #[async_trait]
 impl ProtocolBase for ProtocolTx {
     async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "consensus::protocol_tx::init()", "ProtocolTx::start() [START]");
+        debug!(target: "consensus::protocol_tx::start()", "ProtocolTx::start() [START]");
         self.jobsman.clone().start(executor.clone());
         self.jobsman.clone().spawn(self.clone().handle_receive_tx(), executor.clone()).await;
-        debug!(target: "consensus::protocol_tx::init()", "ProtocolTx::start() [END]");
+        debug!(target: "consensus::protocol_tx::start()", "ProtocolTx::start() [END]");
         Ok(())
     }
 

src/net/hosts.rs

@@ -59,7 +59,7 @@ impl Hosts {
 
     /// Add a new host to the host list, after filtering.
     pub async fn store(&self, input_addrs: Vec<Url>) {
-        debug!(target: "net", "hosts::store() [Start]");
+        debug!(target: "net::hosts::store()", "hosts::store() [Start]");
         let addrs = if !self.localnet {
             let filtered = filter_localnet(input_addrs);
             let filtered = filter_invalid(&self.ipv4_range, &self.ipv6_range, filtered);
@@ -78,20 +78,20 @@ impl Hosts {
     /// Add a new hosts external adders to the host list, after filtering and verifying
     /// the address url resolves to the provided connection address.
     pub async fn store_ext(&self, connection_addr: Url, input_addrs: Vec<Url>) {
-        debug!(target: "net::hosts::store()", "hosts::store_ext() [Start]");
+        debug!(target: "net::hosts::store_ext()", "hosts::store_ext() [Start]");
         let addrs = if !self.localnet {
             let filtered = filter_localnet(input_addrs);
             let filtered = filter_invalid(&self.ipv4_range, &self.ipv6_range, filtered);
             filter_non_resolving(connection_addr, filtered)
         } else {
-            debug!(target: "net::hosts::store()", "hosts::store_ext() [Localnet mode, skipping filterring.]");
+            debug!(target: "net::hosts::store_ext()", "hosts::store_ext() [Localnet mode, skipping filterring.]");
             input_addrs
         };
         let mut addrs_map = self.addrs.lock().await;
         for addr in addrs {
             addrs_map.insert(addr);
         }
-        debug!(target: "net::hosts::store()", "hosts::store_ext() [End]");
+        debug!(target: "net::hosts::store_ext()", "hosts::store_ext() [End]");
     }
 
     /// Return the list of hosts.
@@ -112,7 +112,7 @@ impl Hosts {
 
 /// Auxiliary function to filter localnet hosts.
 fn filter_localnet(input_addrs: Vec<Url>) -> Vec<Url> {
-    debug!(target: "net::hosts::store()", "hosts::filter_localnet() [Input addresses: {:?}]", input_addrs);
+    debug!(target: "net::hosts::filter_localnet()", "hosts::filter_localnet() [Input addresses: {:?}]", input_addrs);
     let mut filtered = vec![];
 
     for addr in &input_addrs {
@@ -121,13 +121,13 @@ fn filter_localnet(input_addrs: Vec<Url>) -> Vec<Url> {
                 filtered.push(addr.clone());
                 continue
             }
-            debug!(target: "net::hosts::store()", "hosts::filter_localnet() [Filtered localnet addr: {}]", addr);
+            debug!(target: "net::hosts::filter_localnet()", "hosts::filter_localnet() [Filtered localnet addr: {}]", addr);
             continue
         }
-        warn!(target: "net::hosts::store()", "hosts::filter_localnet() [{} addr.host_str is empty, skipping.]", addr);
+        warn!(target: "net::hosts::filter_localnet()", "hosts::filter_localnet() [{} addr.host_str is empty, skipping.]", addr);
     }
 
-    debug!(target: "net::hosts::store()", "hosts::filter_localnet() [Filtered addresses: {:?}]", filtered);
+    debug!(target: "net::hosts::filter_localnet()", "hosts::filter_localnet() [Filtered addresses: {:?}]", filtered);
     filtered
 }
 
@@ -137,14 +137,14 @@ fn filter_invalid(
     ipv6_range: &IpRange<Ipv6Net>,
     input_addrs: Vec<Url>,
 ) -> HashMap<Url, Vec<IpAddr>> {
-    debug!(target: "net::hosts::store()", "hosts::filter_invalid() [Input addresses: {:?}]", input_addrs);
+    debug!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Input addresses: {:?}]", input_addrs);
     let mut filtered = HashMap::new();
     for addr in &input_addrs {
         // Discard domainless Urls
         let domain = match addr.domain() {
             Some(d) => d,
             None => {
-                debug!(target: "net::hosts::store()", "hosts::filter_invalid() [Filtered domainless url: {}]", addr);
+                debug!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Filtered domainless url: {}]", addr);
                 continue
             }
         };
@@ -156,7 +156,7 @@ fn filter_invalid(
                     filtered.insert(addr.clone(), vec![]);
                 }
                 false => {
-                    warn!(target: "net::hosts::store()", "hosts::filter_invalid() [Got invalid onion address: {}]", addr)
+                    warn!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Got invalid onion address: {}]", addr)
                 }
             }
             continue
@@ -169,7 +169,7 @@ fn filter_invalid(
         if let Ok(socket_addrs) = addr.socket_addrs(|| None) {
             // Check if domain resolved to anything
             if socket_addrs.is_empty() {
-                debug!(target: "net::hosts::store()", "hosts::filter_invalid() [Filtered unresolvable URL: {}]", addr);
+                debug!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Filtered unresolvable URL: {}]", addr);
                 continue
             }
 
@@ -180,13 +180,13 @@ fn filter_invalid(
                 match ip {
                     IpAddr::V4(a) => {
                         if ipv4_range.contains(&a) {
-                            debug!(target: "net::hosts::store()", "hosts::filter_invalid() [Filtered private-range IPv4: {}]", a);
+                            debug!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Filtered private-range IPv4: {}]", a);
                             continue
                         }
                     }
                     IpAddr::V6(a) => {
                         if ipv6_range.contains(&a) {
-                            debug!(target: "net::hosts::store()", "hosts::filter_invalid() [Filtered private range IPv6: {}]", a);
+                            debug!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Filtered private range IPv6: {}]", a);
                             continue
                         }
                     }
@@ -195,18 +195,18 @@ fn filter_invalid(
             }
 
             if resolves.is_empty() {
-                debug!(target: "net::hosts::store()", "hosts::filter_invalid() [Filtered unresolvable URL: {}]", addr);
+                debug!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Filtered unresolvable URL: {}]", addr);
                 continue
             }
 
             filtered.insert(addr.clone(), resolves);
         } else {
-            warn!(target: "net::hosts::store()", "hosts::filter_invalid() [Failed resolving socket_addrs for {}]", addr);
+            warn!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Failed resolving socket_addrs for {}]", addr);
             continue
         }
     }
 
-    debug!(target: "net::hosts::store()", "hosts::filter_invalid() [Filtered addresses: {:?}]", filtered);
+    debug!(target: "net::hosts::filter_invalid()", "hosts::filter_invalid() [Filtered addresses: {:?}]", filtered);
     filtered
 }
 
@@ -214,8 +214,8 @@ fn filter_invalid(
 /// the same as `connection_addr`'s IP address.
 /// Skips .onion domains.
 fn filter_non_resolving(connection_addr: Url, input_addrs: HashMap<Url, Vec<IpAddr>>) -> Vec<Url> {
-    debug!(target: "net::hosts::store()", "hosts::filter_non_resolving() [Input addresses: {:?}]", input_addrs);
-    debug!(target: "net::hosts::store()", "hosts::filter_non_resolving() [Connection address: {}]", connection_addr);
+    debug!(target: "net::hosts::filter_non_resolving()", "hosts::filter_non_resolving() [Input addresses: {:?}]", input_addrs);
+    debug!(target: "net::hosts::filter_non_resolving()", "hosts::filter_non_resolving() [Connection address: {}]", connection_addr);
 
     // Retrieve connection IPs
     let mut ipv4_range = vec![];
@@ -231,13 +231,13 @@ fn filter_non_resolving(connection_addr: Url, input_addrs: HashMap<Url, Vec<IpAd
             }
         }
         Err(e) => {
-            error!(target: "net::hosts::store()", "hosts::filter_non_resolving() [Failed resolving connection_addr {}: {}]", connection_addr, e);
+            error!(target: "net::hosts::filter_non_resolving()", "hosts::filter_non_resolving() [Failed resolving connection_addr {}: {}]", connection_addr, e);
             return vec![]
         }
     };
 
-    debug!(target: "net::hosts::store()", "hosts::filter_non_resolving() [{} IPv4: {:?}]", connection_addr, ipv4_range);
-    debug!(target: "net::hosts::store()", "hosts::filter_non_resolving() [{} IPv6: {:?}]", connection_addr, ipv6_range);
+    debug!(target: "net::hosts::filter_non_resolving()", "hosts::filter_non_resolving() [{} IPv4: {:?}]", connection_addr, ipv4_range);
+    debug!(target: "net::hosts::filter_non_resolving()", "hosts::filter_non_resolving() [{} IPv6: {:?}]", connection_addr, ipv6_range);
 
     let mut filtered = vec![];
     for (addr, resolves) in &input_addrs {
@@ -269,14 +269,14 @@ fn filter_non_resolving(connection_addr: Url, input_addrs: HashMap<Url, Vec<IpAd
         }
 
         if !valid {
-            debug!(target: "net::hosts::store()", "hosts::filter_non_resolving() [Filtered unresolvable url: {}]", addr);
+            debug!(target: "net::hosts::filter_non_resolving()", "hosts::filter_non_resolving() [Filtered unresolvable url: {}]", addr);
             continue
         }
 
         filtered.push(addr.clone());
     }
 
-    debug!(target: "net::hosts::store()", "hosts::filter_non_resolving() [Filtered addresses: {:?}]", filtered);
+    debug!(target: "net::hosts::filter_non_resolving()", "hosts::filter_non_resolving() [Filtered addresses: {:?}]", filtered);
     filtered
 }
 

src/net/p2p.rs

@@ -156,7 +156,7 @@ impl P2p {
     /// Invoke startup and seeding sequence. Call from constructing thread.
     // ANCHOR: start
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net", "P2p::start() [BEGIN]");
+        debug!(target: "net::p2p::start()", "P2p::start() [BEGIN]");
 
         *self.state.lock().await = P2pState::Start;
 
@@ -186,7 +186,7 @@ impl P2p {
     /// Waits for a stop signal and stops the network if received.
     // ANCHOR: run
     pub async fn run(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net::p2p::start()", "P2p::run() [BEGIN]");
+        debug!(target: "net::p2p::run()", "P2p::run() [BEGIN]");
 
         *self.state.lock().await = P2pState::Run;
 
@@ -210,20 +210,20 @@ impl P2p {
         inbound.stop().await;
         outbound.stop().await;
 
-        debug!(target: "net::p2p::start()", "P2p::run() [END]");
+        debug!(target: "net::p2p::run()", "P2p::run() [END]");
         Ok(())
     }
     // ANCHOR_END: run
 
     /// Wait for outbound connections to be established.
     pub async fn wait_for_outbound(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net::p2p::start()", "P2p::wait_for_outbound() [BEGIN]");
+        debug!(target: "net::p2p::wait_for_outbound()", "P2p::wait_for_outbound() [BEGIN]");
         // To verify that the network needs initialization, we check if we have seeds or peers configured,
         // and have configured outbound slots.
         if !(self.settings.seeds.is_empty() && self.settings.peers.is_empty()) &&
             self.settings.outbound_connections > 0
         {
-            debug!(target: "net::p2p::start()", "P2p::wait_for_outbound(): seeds are configured, waiting for outbound initialization...");
+            debug!(target: "net::p2p::wait_for_outbound()", "P2p::wait_for_outbound(): seeds are configured, waiting for outbound initialization...");
             // Retrieve P2P network settings;
             let settings = self.settings();
 
@@ -278,7 +278,7 @@ impl P2p {
             self.session_outbound().await.disable_notify().await;
         }
 
-        debug!(target: "net::p2p::start()", "P2p::wait_for_outbound() [END]");
+        debug!(target: "net::p2p::wait_for_outbound()", "P2p::wait_for_outbound() [END]");
         Ok(())
     }
 
@@ -313,15 +313,15 @@ impl P2p {
                 msg = subscriber.receive().fuse() => {
                         if let Err(e) = msg {
                             warn!(
-                                target: "net::p2p::start()",
+                                target: "net::p2p::outbound_addr_loop()",
                                 "P2p::wait_for_outbound(): Outbound connection failed [{}]: {}",
                                 addr, e
                             );
                         }
                 },
-                _ = stop_sub.receive().fuse() => debug!(target: "net::p2p::start()", "P2p::wait_for_outbound(): stop signal received!"),
+                _ = stop_sub.receive().fuse() => debug!(target: "net::p2p::outbound_addr_loop()", "P2p::wait_for_outbound(): stop signal received!"),
                 _ = timeout_r.recv().fuse() => {
-                    warn!(target: "net::p2p::start()", "P2p::wait_for_outbound(): Timeout on outbound connection: {}", addr);
+                    warn!(target: "net::p2p::outbound_addr_loop()", "P2p::wait_for_outbound(): Timeout on outbound connection: {}", addr);
                     continue
                 },
             }
@@ -354,13 +354,13 @@ impl P2p {
         }
 
         if futures.is_empty() {
-            error!(target: "net::p2p::start()", "P2P::broadcast: No connected channels found");
+            error!(target: "net::p2p::broadcast()", "P2P::broadcast: No connected channels found");
             return Ok(())
         }
 
         while let Some(entry) = futures.next().await {
             if let Err(e) = entry {
-                error!(target: "net::p2p::start()", "{}", e);
+                error!(target: "net::p2p::broadcast()", "{}", e);
             }
         }
 
@@ -392,13 +392,13 @@ impl P2p {
         }
 
         if futures.is_empty() {
-            error!(target: "net::p2p::start()", "P2P::broadcast_with_exclude: No connected channels found");
+            error!(target: "net::p2p::broadcast_with_exclude()", "P2P::broadcast_with_exclude: No connected channels found");
             return Ok(())
         }
 
         while let Some(entry) = futures.next().await {
             if let Err(e) = entry {
-                error!(target: "net::p2p::start()", "{}", e);
+                error!(target: "net::p2p::broadcast_with_exclude()", "{}", e);
             }
         }
 

src/net/protocol/protocol_address.rs

@@ -89,7 +89,7 @@ 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", "ProtocolAddress::handle_receive_addrs() [START]");
+        debug!(target: "net::protocol_address::handle_receive_addrs()", "ProtocolAddress::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());
@@ -101,10 +101,10 @@ 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_addrs()", "ProtocolAddress::handle_receive_ext_addrs() [START]");
+        debug!(target: "net::protocol_address::handle_receive_ext_addrs()", "ProtocolAddress::handle_receive_ext_addrs() [START]");
         loop {
             let ext_addrs_msg = self.ext_addrs_sub.receive().await?;
-            debug!(target: "net::protocol_address::handle_receive_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 +113,17 @@ 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_addrs()", "ProtocolAddress::handle_receive_get_addrs() [START]");
+        debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::handle_receive_get_addrs() [START]");
         loop {
             let _get_addrs = self.get_addrs_sub.receive().await?;
 
-            debug!(target: "net::protocol_address::handle_receive_addrs()", "ProtocolAddress::handle_receive_get_addrs() received GetAddrs message");
+            debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::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_addrs()", "ProtocolAddress::handle_receive_get_addrs() sending {} addrs", addrs.len());
+            debug!(target: "net::protocol_address::handle_receive_get_addrs()", "ProtocolAddress::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 +132,7 @@ impl ProtocolAddress {
     }
 
     async fn send_my_addrs(self: Arc<Self>) -> Result<()> {
-        debug!(target: "net::protocol_address::handle_receive_addrs()", "ProtocolAddress::send_addrs() [START]");
+        debug!(target: "net::protocol_address::send_my_addrs()", "ProtocolAddress::send_addrs() [START]");
         loop {
             let ext_addrs = self.settings.external_addr.clone();
             let ext_addr_msg = message::ExtAddrsMessage { ext_addrs };
@@ -157,7 +157,7 @@ impl ProtocolBase for ProtocolAddress {
             self.jobsman.clone().spawn(self.clone().send_my_addrs(), executor.clone()).await;
         }
 
-        debug!(target: "net::protocol_address::handle_receive_addrs()", "ProtocolAddress::start() [START]");
+        debug!(target: "net::protocol_address::start()", "ProtocolAddress::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 +166,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::handle_receive_addrs()", "ProtocolAddress::start() [END]");
+        debug!(target: "net::protocol_address::start()", "ProtocolAddress::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", "ProtocolPing::run_ping_pong() [START]");
+        debug!(target: "net::protocol_ping::run_ping_pong()", "ProtocolPing::run_ping_pong() [START]");
         loop {
             // Wait channel_heartbeat amount of time.
             sleep(self.settings.channel_heartbeat_seconds.into()).await;
@@ -104,16 +104,16 @@ impl ProtocolPing {
     /// 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::run_ping_pong()", "ProtocolPing::reply_to_ping() [START]");
+        debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::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::run_ping_pong()", "ProtocolPing::reply_to_ping() received Ping message");
+            debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::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::run_ping_pong()", "ProtocolPing::reply_to_ping() sent Pong reply");
+            debug!(target: "net::protocol_ping::reply_to_ping()", "ProtocolPing::reply_to_ping() sent Pong reply");
         }
     }
 
@@ -129,11 +129,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::run_ping_pong()", "ProtocolPing::start() [START]");
+        debug!(target: "net::protocol_ping::start()", "ProtocolPing::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::run_ping_pong()", "ProtocolPing::start() [END]");
+        debug!(target: "net::protocol_ping::start()", "ProtocolPing::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", "ProtocolSeed::send_self_address() ext_addrs={:?}", ext_addrs);
+        debug!(target: "net::protocol_seed::send_self_address()", "ProtocolSeed::send_self_address() ext_addrs={:?}", ext_addrs);
         let ext_addr_msg = message::ExtAddrsMessage { ext_addrs };
         self.channel.clone().send(ext_addr_msg).await
     }
@@ -77,7 +77,7 @@ impl ProtocolBase for ProtocolSeed {
     /// then sends our address to the seed server. Sends a get-address
     /// message and receives an address message.
     async fn start(self: Arc<Self>, _executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net::protocol_seed::send_self_address()", "START");
+        debug!(target: "net::protocol_seed::start()", "START");
 
         // Send own address to the seed server.
         self.send_self_address().await?;
@@ -89,13 +89,13 @@ impl ProtocolBase for ProtocolSeed {
         // Receive addresses.
         let addrs_msg = self.addr_sub.receive().await?;
         debug!(
-            target: "net::protocol_seed::send_self_address()",
+            target: "net::protocol_seed::start()",
             "ProtocolSeed::start() received {} addrs",
             addrs_msg.addrs.len()
         );
         self.hosts.store(addrs_msg.addrs.clone()).await;
 
-        debug!(target: "net::protocol_seed::send_self_address()", "END");
+        debug!(target: "net::protocol_seed::start()", "END");
         Ok(())
     }
 

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", "ProtocolVersion::run() [START]");
+        debug!(target: "net::protocol_version::run()", "ProtocolVersion::run() [START]");
         // Start timer
         // Send version, wait for verack
         // Wait for version, send verack
@@ -85,7 +85,7 @@ impl ProtocolVersion {
 
     /// Send and recieve version information.
     async fn exchange_versions(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        debug!(target: "net::protocol_version::run()", "ProtocolVersion::exchange_versions() [START]");
+        debug!(target: "net::protocol_version::exchange_versions()", "ProtocolVersion::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::run()", "ProtocolVersion::exchange_versions() [END]");
+        debug!(target: "net::protocol_version::exchange_versions()", "ProtocolVersion::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::run()", "ProtocolVersion::send_version() [START]");
+        debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [START]");
 
         let version = message::VersionMessage { node_id: self.settings.node_id.clone() };
 
@@ -114,14 +114,14 @@ impl ProtocolVersion {
         if !self.settings.seeds.contains(&self.channel.address()) {
             match &self.settings.app_version {
                 Some(app_version) => {
-                    debug!(target: "net::protocol_version::run()", "ProtocolVersion::send_version() [App version: {}]", app_version);
-                    debug!(target: "net::protocol_version::run()", "ProtocolVersion::send_version() [Recieved version: {}]", verack_msg.app);
+                    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);
                     // 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::run()", "ProtocolVersion::send_version() [Malformed version detected. Disconnecting from channel.]");
+                        error!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [Malformed version detected. Disconnecting from channel.]");
                         self.hosts.remove(&self.channel.address()).await;
                         self.channel.stop().await;
                         return Err(Error::ChannelStopped)
@@ -131,7 +131,7 @@ impl ProtocolVersion {
                         app_versions[1] != verack_msg_versions[1]
                     {
                         error!(
-                            target: "net::protocol_version::run()",
+                            target: "net::protocol_version::send_version()",
                             "ProtocolVersion::send_version() [Wrong app version from ({}). Disconnecting from channel.]",
                             self.channel.address()
                         );
@@ -141,19 +141,19 @@ impl ProtocolVersion {
                     }
                 }
                 None => {
-                    debug!(target: "net::protocol_version::run()", "ProtocolVersion::send_version() [App version not set, ignorring received]")
+                    debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::send_version() [App version not set, ignorring received]")
                 }
             }
         }
 
-        debug!(target: "net::protocol_version::run()", "ProtocolVersion::send_version() [END]");
+        debug!(target: "net::protocol_version::send_version()", "ProtocolVersion::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::run()", "ProtocolVersion::recv_version() [START]");
+        debug!(target: "net::protocol_version::recv_version()", "ProtocolVersion::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 +163,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::run()", "ProtocolVersion::recv_version() [END]");
+        debug!(target: "net::protocol_version::recv_version()", "ProtocolVersion::recv_version() [END]");
         Ok(())
     }
 }

src/runtime/import/db.rs

@@ -78,7 +78,7 @@ pub(crate) fn db_init(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i
             let contract_id = &env.contract_id;
 
             let Ok(mem_slice) = ptr.slice(&memory_view, len) else {
-                error!(target: "wasm_runtime::db_init", "Failed to make slice from ptr");
+                error!(target: "runtime::db::db_init()", "Failed to make slice from ptr");
                 return DB_INIT_FAILED
             };
 
@@ -153,13 +153,13 @@ pub(crate) fn db_lookup(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) ->
             let contracts = &env.blockchain.contracts;
 
             let Ok(mem_slice) = ptr.slice(&memory_view, len) else {
-                error!(target: "runtime::db::db_init()", "Failed to make slice from ptr");
+                error!(target: "runtime::db::db_lookup()", "Failed to make slice from ptr");
                 return DB_LOOKUP_FAILED
             };
 
             let mut buf = vec![0_u8; len as usize];
             if let Err(e) = mem_slice.read_slice(&mut buf) {
-                error!(target: "runtime::db::db_init()", "Failed to read from memory slice: {}", e);
+                error!(target: "runtime::db::db_lookup()", "Failed to read from memory slice: {}", e);
                 return DB_LOOKUP_FAILED
             };
 
@@ -168,7 +168,7 @@ pub(crate) fn db_lookup(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) ->
             let cid: ContractId = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode ContractId: {}", e);
+                    error!(target: "runtime::db::db_lookup()", "Failed to decode ContractId: {}", e);
                     return DB_LOOKUP_FAILED
                 }
             };
@@ -176,7 +176,7 @@ pub(crate) fn db_lookup(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) ->
             let db_name: String = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode db_name: {}", e);
+                    error!(target: "runtime::db::db_lookup()", "Failed to decode db_name: {}", e);
                     return DB_LOOKUP_FAILED
                 }
             };
@@ -186,7 +186,7 @@ pub(crate) fn db_lookup(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) ->
             let tree_handle = match contracts.lookup(db, &cid, &db_name) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to lookup db: {}", e);
+                    error!(target: "runtime::db::db_lookup()", "Failed to lookup db: {}", e);
                     return DB_LOOKUP_FAILED
                 }
             };
@@ -204,7 +204,7 @@ pub(crate) fn db_lookup(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) ->
             (db_handles.len() - 1) as i32
         }
         _ => {
-            error!(target: "runtime::db::db_init()", "db_lookup called in unauthorized section");
+            error!(target: "runtime::db::db_lookup()", "db_lookup called in unauthorized section");
             CALLER_ACCESS_DENIED
         }
     }
@@ -218,13 +218,13 @@ pub(crate) fn db_set(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i3
             let memory_view = env.memory_view(&ctx);
 
             let Ok(mem_slice) = ptr.slice(&memory_view, len) else {
-                error!(target: "runtime::db::db_init()", "Failed to make slice from ptr");
+                error!(target: "runtime::db::db_set()", "Failed to make slice from ptr");
                 return DB_SET_FAILED
             };
 
             let mut buf = vec![0_u8; len as usize];
             if let Err(e) = mem_slice.read_slice(&mut buf) {
-                error!(target: "runtime::db::db_init()", "Failed to read from memory slice: {}", e);
+                error!(target: "runtime::db::db_set()", "Failed to read from memory slice: {}", e);
                 return DB_SET_FAILED
             };
 
@@ -234,7 +234,7 @@ pub(crate) fn db_set(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i3
             let db_handle: u32 = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode DbHandle: {}", e);
+                    error!(target: "runtime::db::db_set()", "Failed to decode DbHandle: {}", e);
                     return DB_SET_FAILED
                 }
             };
@@ -243,7 +243,7 @@ pub(crate) fn db_set(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i3
             let key: Vec<u8> = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode key vec: {}", e);
+                    error!(target: "runtime::db::db_set()", "Failed to decode key vec: {}", e);
                     return DB_SET_FAILED
                 }
             };
@@ -251,7 +251,7 @@ pub(crate) fn db_set(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i3
             let value: Vec<u8> = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode value vec: {}", e);
+                    error!(target: "runtime::db::db_set()", "Failed to decode value vec: {}", e);
                     return DB_SET_FAILED
                 }
             };
@@ -262,7 +262,7 @@ pub(crate) fn db_set(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i3
             let mut db_batches = env.db_batches.borrow_mut();
 
             if db_handles.len() <= db_handle || db_batches.len() <= db_handle {
-                error!(target: "runtime::db::db_init()", "Requested DbHandle that is out of bounds");
+                error!(target: "runtime::db::db_set()", "Requested DbHandle that is out of bounds");
                 return DB_SET_FAILED
             }
 
@@ -271,7 +271,7 @@ pub(crate) fn db_set(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i3
             let db_batch = &mut db_batches[handle_idx];
 
             if db_handle.contract_id != env.contract_id {
-                error!(target: "runtime::db::db_init()", "Unauthorized to write to DbHandle");
+                error!(target: "runtime::db::db_set()", "Unauthorized to write to DbHandle");
                 return CALLER_ACCESS_DENIED
             }
 
@@ -291,13 +291,13 @@ pub(crate) fn db_get(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i6
             let memory_view = env.memory_view(&ctx);
 
             let Ok(mem_slice) = ptr.slice(&memory_view, len) else {
-                error!(target: "runtime::db::db_init()", "Failed to make slice from ptr");
+                error!(target: "runtime::db::db_get()", "Failed to make slice from ptr");
                 return DB_GET_FAILED.into()
             };
 
             let mut buf = vec![0_u8; len as usize];
             if let Err(e) = mem_slice.read_slice(&mut buf) {
-                error!(target: "runtime::db::db_init()", "Failed to read from memory slice: {}", e);
+                error!(target: "runtime::db::db_get()", "Failed to read from memory slice: {}", e);
                 return DB_GET_FAILED.into()
             };
 
@@ -307,7 +307,7 @@ pub(crate) fn db_get(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i6
             let db_handle: u32 = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode DbHandle: {}", e);
+                    error!(target: "runtime::db::db_get()", "Failed to decode DbHandle: {}", e);
                     return DB_GET_FAILED.into()
                 }
             };
@@ -316,7 +316,7 @@ pub(crate) fn db_get(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i6
             let key: Vec<u8> = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode key from vec: {}", e);
+                    error!(target: "runtime::db::db_get()", "Failed to decode key from vec: {}", e);
                     return DB_GET_FAILED.into()
                 }
             };
@@ -326,7 +326,7 @@ pub(crate) fn db_get(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i6
             let db_handles = env.db_handles.borrow();
 
             if db_handles.len() <= db_handle {
-                error!(target: "runtime::db::db_init()", "Requested DbHandle that is out of bounds");
+                error!(target: "runtime::db::db_get()", "Requested DbHandle that is out of bounds");
                 return DB_GET_FAILED.into()
             }
 
@@ -336,13 +336,13 @@ pub(crate) fn db_get(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u32) -> i6
             let ret = match db_handle.get(&key) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Internal error getting from tree: {}", e);
+                    error!(target: "runtime::db::db_get()", "Internal error getting from tree: {}", e);
                     return DB_GET_FAILED.into()
                 }
             };
 
             let Some(return_data) = ret else {
-                debug!(target: "runtime::db::db_init()", "returned empty vec");
+                debug!(target: "runtime::db::db_get()", "returned empty vec");
                 return -127
             };
 
@@ -366,13 +366,13 @@ pub(crate) fn db_contains_key(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u
             let memory_view = env.memory_view(&ctx);
 
             let Ok(mem_slice) = ptr.slice(&memory_view, len) else {
-                error!(target: "runtime::db::db_init()", "Failed to make slice from ptr");
+                error!(target: "runtime::db::db_contains_key()", "Failed to make slice from ptr");
                 return DB_CONTAINS_KEY_FAILED
             };
 
             let mut buf = vec![0_u8; len as usize];
             if let Err(e) = mem_slice.read_slice(&mut buf) {
-                error!(target: "runtime::db::db_init()", "Failed to read from memory slice: {}", e);
+                error!(target: "runtime::db::db_contains_key()", "Failed to read from memory slice: {}", e);
                 return DB_CONTAINS_KEY_FAILED
             };
 
@@ -382,7 +382,7 @@ pub(crate) fn db_contains_key(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u
             let db_handle: u32 = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode DbHandle: {}", e);
+                    error!(target: "runtime::db::db_contains_key()", "Failed to decode DbHandle: {}", e);
                     return DB_CONTAINS_KEY_FAILED
                 }
             };
@@ -391,7 +391,7 @@ pub(crate) fn db_contains_key(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u
             let key: Vec<u8> = match Decodable::decode(&mut buf_reader) {
                 Ok(v) => v,
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "Failed to decode key vec: {}", e);
+                    error!(target: "runtime::db::db_contains_key()", "Failed to decode key vec: {}", e);
                     return DB_CONTAINS_KEY_FAILED
                 }
             };
@@ -401,7 +401,7 @@ pub(crate) fn db_contains_key(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u
             let db_handles = env.db_handles.borrow();
 
             if db_handles.len() <= db_handle {
-                error!(target: "runtime::db::db_init()", "Requested DbHandle that is out of bounds");
+                error!(target: "runtime::db::db_contains_key()", "Requested DbHandle that is out of bounds");
                 return DB_CONTAINS_KEY_FAILED
             }
 
@@ -411,7 +411,7 @@ pub(crate) fn db_contains_key(ctx: FunctionEnvMut<Env>, ptr: WasmPtr<u8>, len: u
             match db_handle.contains_key(&key) {
                 Ok(v) => i32::from(v), // <- 0=false, 1=true
                 Err(e) => {
-                    error!(target: "runtime::db::db_init()", "sled.tree.contains_key failed: {}", e);
+                    error!(target: "runtime::db::db_contains_key()", "sled.tree.contains_key failed: {}", e);
                     DB_CONTAINS_KEY_FAILED
                 }
             }