cleanup log messages

1 files changed, 21 insertions, 21 deletions

diff --git a/src/transport/libp2p.rs b/src/transport/libp2p.rs
index 30fdb23..8655f23 100644
--- a/src/transport/libp2p.rs
+++ b/src/transport/libp2p.rs
@@ -512,7 +512,7 @@ impl Libp2pTransport {
             },
             stopping,
         ));
-        info!(peer_id = %peer_id, "libp2p transport started");
+        info!(peer_id = %peer_id, "Transport started");
         Ok(Self {
             local_id: peer_id.to_string(),
             peer_id,
@@ -802,11 +802,11 @@ fn pick_relays(
     for (relay, address) in wanted {
         match swarm.listen_on(address.clone().with(Protocol::P2pCircuit)) {
             Ok(listener) => {
-                info!(relay = %relay, address = %address, "Picked a member as libp2p relay");
+                info!(relay = %relay, address = %address, "Picked a member as relay");
                 picked.insert(listener, relay);
             }
             Err(error) => {
-                debug!(relay = %relay, error = %error, "Couldn't use a member as libp2p relay");
+                debug!(relay = %relay, error = %error, "Couldn't use a member as relay");
             }
         }
     }
@@ -861,7 +861,7 @@ async fn run(
             _ = prune.tick() => {
                 let forgotten = lock(&book).prune(tokio::time::Instant::now(), |peer| swarm.is_connected(peer));
                 if forgotten > 0 {
-                    debug!(forgotten, "Forgot libp2p peers nobody mentions any more");
+                    debug!(forgotten, "Forgot peers nobody mentions any more");
                 }
             }
             _ = dht_bootstrap.tick(), if relaying.public => {
@@ -924,7 +924,7 @@ async fn run(
                                 }
                             }
                             _ => {
-                                warn!(relay = %relay, "Couldn't reach a libp2p relay; trying again later");
+                                warn!(relay = %relay, "Couldn't reach a relay; trying again later");
                                 tokio::time::sleep(RELAY_RETRY).await;
                                 let _ = again.send(Command::Reserve { relay, configured });
                             }
@@ -937,11 +937,11 @@ async fn run(
                     };
                     match swarm.listen_on(relay.clone().with(Protocol::P2pCircuit)) {
                         Ok(listener) => {
-                            debug!(relay = %relay, "Reserving a slot on a libp2p relay");
+                            debug!(relay = %relay, "Reserving a slot on a relay");
                             reservations.insert(listener, (configured, relay_peer));
                         }
                         Err(error) => {
-                            warn!(relay = %relay, error = %error, "Couldn't use a libp2p relay; trying again later");
+                            warn!(relay = %relay, error = %error, "Couldn't use a relay; trying again later");
                             reserve_later(configured);
                         }
                     }
@@ -972,7 +972,7 @@ async fn run(
                             dialled = endpoint.is_dialer(),
                             address = %endpoint.get_remote_address(),
                             relayed,
-                            "libp2p connection opened"
+                            "Connection opened"
                         );
                     }
                     for done in connecting.remove(&peer_id).into_iter().flatten() {
@@ -989,7 +989,7 @@ async fn run(
                         peer = %peer_id,
                         connection = %connection_id,
                         cause = ?cause,
-                        "libp2p connection closed"
+                        "Connection closed"
                     );
                 }
                 SwarmEvent::OutgoingConnectionError { connection_id, peer_id, error } => {
@@ -1009,7 +1009,7 @@ async fn run(
                     }
                 }
                 SwarmEvent::NewListenAddr { address, .. } => {
-                    info!(address = %address, "libp2p listening");
+                    info!(address = %address, "Listening");
                     // A relay tells those reserving where it is: its external addresses.
                     if serving && !is_local(&address) && !is_relayed(&address) {
                         swarm.add_external_address(address.clone());
@@ -1020,7 +1020,7 @@ async fn run(
                     }
                 }
                 SwarmEvent::ExpiredListenAddr { address, .. } => {
-                    info!(address = %address, "libp2p no longer listening");
+                    info!(address = %address, "No longer listening");
                     if serving {
                         swarm.remove_external_address(&address);
                     }
@@ -1039,7 +1039,7 @@ async fn run(
                                 book.counts.slots_not_granted += 1;
                             }
                         }
-                        warn!(relay = %relay, reason = ?reason, "Lost the slot on a libp2p relay; reserving again later");
+                        warn!(relay = %relay, reason = ?reason, "Lost the slot on a relay; reserving again later");
                         reserve_later(relay);
                     }
                     // A relay picked among the members: the next check picks again, another
@@ -1068,7 +1068,7 @@ async fn run(
                     }
                 }
                 SwarmEvent::ListenerError { error, .. } => {
-                    warn!(error = %error, "libp2p listener failed");
+                    warn!(error = %error, "Listener failed");
                 }
                 SwarmEvent::Behaviour(BehaviourEvent::RelayClient(
                     ::libp2p::relay::client::Event::ReservationReqAccepted { relay_peer_id, renewal, .. },
@@ -1082,13 +1082,13 @@ async fn run(
                         }
                     }
                     if !renewal {
-                        info!(relay = %relay_peer_id, "Reachable through a libp2p relay");
+                        info!(relay = %relay_peer_id, "Reachable through a relay");
                     }
                 }
                 SwarmEvent::Behaviour(BehaviourEvent::Autonat(
                     ::libp2p::autonat::Event::StatusChanged { old, new },
                 )) => {
-                    info!(old = ?old, new = ?new, "libp2p reachability (AutoNAT)");
+                    info!(old = ?old, new = ?new, "Reachability (AutoNAT)");
                     {
                         use ::libp2p::autonat::NatStatus;
                         let mut book = lock(&book);
@@ -1103,7 +1103,7 @@ async fn run(
                     nat = new;
                 }
                 SwarmEvent::Behaviour(BehaviourEvent::Relay(event)) => {
-                    debug!(event = ?event, "libp2p relay");
+                    debug!(event = ?event, "Relay event");
                 }
                 SwarmEvent::Behaviour(BehaviourEvent::Dcutr(event)) => match event.result {
                     Ok(_) => {
@@ -1122,7 +1122,7 @@ async fn run(
                     let listen = published(&info.listen_addrs);
                     // Every new connection identifies again: logged when it says something new.
                     if book.knows(peer_id, &listen) {
-                        trace!(peer = %peer_id, connection = %connection_id, "libp2p peer identified again");
+                        trace!(peer = %peer_id, connection = %connection_id, "Peer identified again");
                     } else {
                         debug!(
                             peer = %peer_id,
@@ -1130,7 +1130,7 @@ async fn run(
                             listen = ?info.listen_addrs,
                             observed = %info.observed_addr,
                             agent = %info.agent_version,
-                            "libp2p peer identified"
+                            "Peer identified"
                         );
                     }
                     // Last first: `remember` puts each in front.
@@ -1163,7 +1163,7 @@ async fn run(
                         if peer == relaying.local {
                             continue;
                         }
-                        debug!(peer = %peer, address = %address, "libp2p peer on the LAN");
+                        debug!(peer = %peer, address = %address, "Peer on the LAN");
                         let continuum = {
                             let mut book = lock(&book);
                             book.remember(peer, address.clone());
@@ -1404,7 +1404,7 @@ impl Transport for Libp2pTransport {
                             let _ = sender.send((peer, body)).await;
                         }
                         Err(error) => {
-                            debug!(peer = %peer, error = %format!("{error:#}"), "Dropping an unreadable libp2p stream");
+                            debug!(peer = %peer, error = %format!("{error:#}"), "Dropping an unreadable stream");
                         }
                     }
                     drop(permit);
@@ -1419,7 +1419,7 @@ impl Transport for Libp2pTransport {
                     }
                 }
                 Err(error) => {
-                    debug!(peer = %peer, error = %error, "Dropping a libp2p message that doesn't decode");
+                    debug!(peer = %peer, error = %error, "Dropping a message that doesn't decode");
                 }
             }
         }