26ee6d2 node: Reduce log messages when sending messages — heartwood

Radicle Heartwood Protocol & Stack

node: Reduce log messages when sending messages

Alexis Sellier committed 3 years ago

commit 26ee6d26dc19a9aa868eadf84f35e41b13dc83ab
parent 9120db4ddbd196b697bc385c80dd4a529f7d190c

3 files changed +23 -16

modified radicle-node/src/service.rs

@@ -1062,7 +1062,7 @@ where

             return Ok(());
         };
         peer.last_active = self.clock;
         message.log(log::Level::Debug, remote);
         message.log(log::Level::Debug, remote, Link::Inbound);
         trace!(target: "service", "Received message {:?} from {}", &message, peer.id);

modified radicle-node/src/service/message.rs

@@ -7,7 +7,7 @@ use crate::node;

 use crate::node::Address;
 use crate::prelude::BoundedVec;
 use crate::service::filter::Filter;
 use crate::service::{NodeId, Timestamp};
 use crate::service::{Link, NodeId, Timestamp};
 use crate::storage;
 use crate::storage::refs::SignedRefs;
 use crate::storage::{ReadRepository, ReadStorage};

@@ -408,33 +408,36 @@ impl Message {

         })
     }
     pub fn log(&self, level: log::Level, remote: &NodeId) {
     pub fn log(&self, level: log::Level, remote: &NodeId, link: Link) {
         if !log::log_enabled!(level) {
             return;
         }
         let (verb, prep) = if link.is_inbound() {
             ("Received", "from")
         } else {
             ("Sending", "to")
         };
         let msg = match self {
             Self::Announcement(Announcement { node, message, .. }) => match message {
                 AnnouncementMessage::Node(NodeAnnouncement { addresses, .. }) => format!(
                     "Node announced by {node} with {} addresses, relayed by {remote}",
                     "{verb} node announcement of {node} with {} addresses {prep} {remote}",
                     addresses.len()
                 ),
                 AnnouncementMessage::Refs(RefsAnnouncement { rid, refs, .. }) => {
                     format!(
                         "Refs announced by {node} for {rid} with {} remotes, relayed by {remote}",
                         refs.len()
                     )
                 }
                 AnnouncementMessage::Refs(RefsAnnouncement { rid, refs, .. }) => format!(
                     "{verb} refs announcement of {node} for {rid} with {} remotes {prep} {remote}",
                     refs.len()
                 ),
                 AnnouncementMessage::Inventory(InventoryAnnouncement { inventory, .. }) => {
                     format!(
                         "Inventory announced by {node} with {} item(s), relayed by {remote}",
                         "{verb} inventory announcement of {node} with {} item(s) {prep} {remote}",
                         inventory.len()
                     )
                 }
             },
             Self::Ping { .. } => format!("Ping received from {remote}"),
             Self::Pong { .. } => format!("Pong received from {remote}"),
             Self::Ping { .. } => format!("{verb} ping {prep} {remote}"),
             Self::Pong { .. } => format!("{verb} pong {prep} {remote}"),
             Self::Subscribe(Subscribe { .. }) => {
                 format!("Subscription filter received from {remote}")
                 format!("{verb} subscription filter {prep} {remote}")
             }
         };
         log::log!(target: "service", level, "{msg}");

modified radicle-node/src/service/reactor.rs

@@ -4,6 +4,7 @@ use log::*;

 use crate::prelude::*;
 use crate::service::session::Session;
 use crate::service::Link;
 use crate::storage::Namespaces;
 use super::message::{Announcement, AnnouncementMessage};

@@ -49,7 +50,9 @@ impl Reactor {

     }
     pub fn write(&mut self, remote: &Session, msg: Message) {
         debug!(target: "service", "Write {:?} to {}", &msg, remote);
         msg.log(log::Level::Debug, &remote.id, Link::Outbound);
         trace!(target: "service", "Write {:?} to {}", &msg, remote);
         self.io.push_back(Io::Write(remote.id, vec![msg]));
     }

@@ -57,7 +60,7 @@ impl Reactor {

         let msgs = msgs.into_iter().collect::<Vec<_>>();
         for (ix, msg) in msgs.iter().enumerate() {
             debug!(
             trace!(
                 target: "service",
                 "Write {:?} to {} ({}/{})",
                 msg,

@@ -65,6 +68,7 @@ impl Reactor {

                 ix + 1,
                 msgs.len()
             );
             msg.log(log::Level::Debug, &remote.id, Link::Outbound);
         }
         self.io.push_back(Io::Write(remote.id, msgs));
     }