feat: introduce tracing

examples/dcutr/src/main.rs

@@ -172,10 +172,10 @@ fn main() -> Result<(), Box<dyn Error>> {
     .build();
 
     swarm
-        .listen_on("/ip4/0.0.0.0/udp/0/quic-v1".parse().unwrap())
+        .listen_on("/ip4/0.0.0.0/udp/4001/quic-v1".parse().unwrap())
         .unwrap();
     swarm
-        .listen_on("/ip4/0.0.0.0/tcp/0".parse().unwrap())
+        .listen_on("/ip6/::/udp/4001/quic-v1".parse().unwrap())
         .unwrap();
 
     // Wait to listen on all interfaces.

examples/ping-example/Cargo.toml

@@ -10,3 +10,5 @@ async-std = { version = "1.12", features = ["attributes"] }
 async-trait = "0.1"
 futures = "0.3.28"
 libp2p = { path = "../../libp2p", features = ["async-std", "dns", "macros", "noise", "ping", "tcp", "websocket", "yamux"] }
+tracing = { version = "0.1.37", features = ["log"] }
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }

examples/ping-example/src/main.rs

@@ -27,10 +27,19 @@ use libp2p::{
     swarm::{keep_alive, NetworkBehaviour, SwarmBuilder, SwarmEvent},
     tcp, yamux, Multiaddr, PeerId, Transport,
 };
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::EnvFilter;
 use std::error::Error;
 
 #[async_std::main]
 async fn main() -> Result<(), Box<dyn Error>> {
+
+    let env_filter = EnvFilter::builder()
+        .with_default_directive(LevelFilter::DEBUG.into())
+        .from_env_lossy();
+
+    tracing_subscriber::fmt().with_env_filter(env_filter).init();
+
     let local_key = identity::Keypair::generate_ed25519();
     let local_peer_id = PeerId::from(local_key.public());
     println!("Local peer id: {local_peer_id:?}");

protocols/ping/Cargo.toml

@@ -21,6 +21,7 @@ libp2p-identity = { workspace = true }
 log = "0.4.19"
 rand = "0.8"
 void = "1.0"
+tracing = "0.1.37"
 
 [dev-dependencies]
 async-std = "1.6.2"

protocols/ping/src/handler.rs

@@ -258,11 +258,11 @@ impl ConnectionHandler for Handler {
             match fut.poll_unpin(cx) {
                 Poll::Pending => {}
                 Poll::Ready(Err(e)) => {
-                    log::debug!("Inbound ping error: {:?}", e);
+                    tracing::debug!("Inbound ping error: {:?}", e);
                     self.inbound = None;
                 }
                 Poll::Ready(Ok(stream)) => {
-                    log::trace!("answered inbound ping from {}", self.peer);
+                    tracing::trace!("answered inbound ping from {}", self.peer);
 
                     // A ping from a remote peer has been answered, wait for the next.
                     self.inbound = Some(protocol::recv_ping(stream).boxed());
@@ -273,7 +273,7 @@ impl ConnectionHandler for Handler {
         loop {
             // Check for outbound ping failures.
             if let Some(error) = self.pending_errors.pop_back() {
-                log::debug!("Ping failure: {:?}", error);
+                tracing::debug!("Ping failure: {:?}", error);
 
                 self.failures += 1;
 
@@ -295,7 +295,7 @@ impl ConnectionHandler for Handler {
                         break;
                     }
                     Poll::Ready(Ok((stream, rtt))) => {
-                        log::debug!("latency to {} is {}ms", self.peer, rtt.as_millis());
+                        tracing::debug!("latency to {} is {}ms", self.peer, rtt.as_millis());
 
                         self.failures = 0;
                         self.interval.reset(self.config.interval);

swarm/Cargo.toml

@@ -31,6 +31,8 @@ multistream-select = { workspace = true }
 [target.'cfg(not(any(target_os = "emscripten", target_os = "wasi", target_os = "unknown")))'.dependencies]
 async-std = { version = "1.6.2", optional = true }
 tokio = { version = "1.29", features = ["rt"], optional = true }
+tracing = "0.1.37"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
 
 [features]
 macros = ["dep:libp2p-swarm-derive"]

swarm/src/connection.rs

@@ -82,6 +82,12 @@ impl ConnectionId {
     }
 }
 
+impl fmt::Display for ConnectionId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 /// Information about a successfully established connection.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct Connected {

swarm/src/connection/pool.rs

@@ -307,6 +307,8 @@ where
 {
     /// Creates a new empty `Pool`.
     pub(crate) fn new(local_id: PeerId, config: PoolConfig) -> Self {
+        let span = tracing::error_span!("peer id:", %local_id, connection_id = tracing::field::Empty);
+        let _guard = span.enter();
         let (pending_connection_events_tx, pending_connection_events_rx) = mpsc::channel(0);
         let executor = match config.executor {
             Some(exec) => ExecSwitch::Executor(exec),
@@ -495,6 +497,10 @@ where
     ) {
         let connection = connection.extract();
 
+        let span = tracing::error_span!("peer id:", %obtained_peer_id, connection_id = tracing::field::Empty);
+        let _guard = span.enter();
+        span.record("connection id", tracing::field::display(id));
+
         let conns = self.established.entry(obtained_peer_id).or_default();
         self.counters.inc_established(endpoint);