feat: Change all error/warn logs to debug

src/cid_prefix.rs

@@ -1,5 +1,5 @@
 use cid::{CidGeneric, Version};
-use tracing::error;
+use tracing::debug;
 
 use crate::multihasher::{MultihasherError, MultihasherTable};
 
@@ -89,7 +89,7 @@ impl CidPrefix {
         data: &[u8],
     ) -> Result<CidGeneric<S>, MultihasherError> {
         if self.multihash_size > S {
-            error!(
+            debug!(
                 "Multihash<{}> can not hold multihash of size {}",
                 S, self.multihash_size
             );

src/client.rs

@@ -20,7 +20,7 @@ use libp2p_swarm::{
     ConnectionHandlerEvent, ConnectionId, NotifyHandler, StreamProtocol, SubstreamProtocol, ToSwarm,
 };
 use smallvec::SmallVec;
-use tracing::warn;
+use tracing::debug;
 
 use crate::incoming_stream::ClientMessage;
 use crate::message::Codec;
@@ -570,7 +570,7 @@ impl<const S: usize> ClientConnectionHandler<S> {
     }
 
     fn close_sink_on_error(&mut self, location: &str) {
-        warn!("sink operation failed, closing: {location}");
+        debug!("sink operation failed, closing: {location}");
         self.sink_state = SinkState::None;
     }
 

src/incoming_stream.rs

@@ -8,7 +8,7 @@ use cid::CidGeneric;
 use fnv::FnvHashMap;
 use futures_util::future::{BoxFuture, Fuse, FusedFuture, FutureExt};
 use futures_util::stream::StreamExt;
-use tracing::error;
+use tracing::debug;
 
 use crate::cid_prefix::CidPrefix;
 use crate::message::Codec;
@@ -87,7 +87,7 @@ impl<const S: usize> futures_core::stream::Stream for IncomingStream<S> {
             let msg = match self.stream.poll_next_unpin(cx) {
                 Poll::Ready(Some(Ok(msg))) => msg,
                 Poll::Ready(Some(Err(e))) => {
-                    error!("Message decoding failed: {e}");
+                    debug!("Message decoding failed: {e}");
                     return Poll::Ready(None);
                 }
                 Poll::Ready(None) => return Poll::Ready(None),
@@ -116,7 +116,7 @@ async fn process_message<const S: usize>(
         let cid = match CidGeneric::try_from(&block_presence.cid[..]) {
             Ok(cid) => cid,
             Err(e) => {
-                error!("Invalid CID bytes: {}: {:?}", e, block_presence.cid);
+                debug!("Invalid CID bytes: {}: {:?}", e, block_presence.cid);
                 return None;
             }
         };
@@ -130,23 +130,26 @@ async fn process_message<const S: usize>(
 
     for payload in msg.payload {
         let Some(cid_prefix) = CidPrefix::from_bytes(&payload.prefix) else {
-            error!("block.prefix not decodable: {:?}", payload.prefix);
+            debug!("block.prefix not decodable: {:?}", payload.prefix);
             return None;
         };
 
         let cid = match cid_prefix.to_cid(&multihasher, &payload.data).await {
             Ok(cid) => cid,
             Err(MultihasherError::UnknownMultihashCode) => {
-                error!("Unknown multihash code: {}", cid_prefix.multihash_code());
+                debug!(
+                    "Multihasher non-fatal error: Unknown multihash code: {}",
+                    cid_prefix.multihash_code()
+                );
                 continue;
             }
             Err(MultihasherError::Custom(e)) => {
-                error!("{e}");
+                debug!("Multihasher non-fatal error: {e}");
                 continue;
             }
             // Any other error is fatal and we need to close the stream.
             Err(e) => {
-                error!("{e}");
+                debug!("Multihasher fatal error: {e}");
                 return None;
             }
         };

src/server.rs

@@ -16,7 +16,7 @@ use libp2p_swarm::{
     ConnectionHandlerEvent, NotifyHandler, StreamProtocol, SubstreamProtocol, ToSwarm,
 };
 use smallvec::SmallVec;
-use tracing::{debug, trace, warn};
+use tracing::{debug, trace};
 
 use crate::incoming_stream::ServerMessage;
 use crate::message::Codec;
@@ -271,7 +271,7 @@ where
                     self.outgoing_queue.push_back((cid, data));
                 }
                 Err(e) => {
-                    warn!("Fetching {cid} from blockstore failed: {e}");
+                    debug!("Fetching {cid} from blockstore failed: {e}");
                 }
             }
         }
@@ -393,7 +393,7 @@ impl<const S: usize> ServerConnectionHandler<S> {
     }
 
     fn close_sink_on_error(&mut self, location: &str) {
-        warn!("sink operation failed, closing: {location}");
+        debug!("sink operation failed, closing: {location}");
         self.sink = SinkState::None;
     }