Improve tracing spans and log levels

Adjust log levels so that important events are visible atl og level INFO.
Adjust spans so that they carry more useful names and fields.

Author: surban

aggligator/src/agg/task.rs

@@ -386,7 +386,8 @@ where
     ///
     /// This returns when the connection has been terminated.
     /// Cancelling the returned future leads to immediate termination of the connection.
-    #[tracing::instrument(level = "debug")]
+    #[tracing::instrument(name = "aggligator::connection", level = "info", skip_all, 
+                          fields(conn_id =? self.conn_id, dir =% self.direction), ret)]
     pub async fn run(mut self) -> Result<(), TaskError> {
         tracing::debug!("link aggregator task starting");
         self.start_time = Instant::now();

aggligator/src/transport/acceptor.rs

@@ -283,7 +283,7 @@ impl Acceptor {
     }
 
     /// Task managing all listening transports.
-    #[tracing::instrument(level="debug", skip_all, fields(id=?server.id()))]
+    #[tracing::instrument(name = "aggligator::acceptor", level = "info", skip_all, fields(server_id =? server.id()))]
     async fn task(
         server: BoxServer, active_transports: Arc<RwLock<Vec<Weak<dyn AcceptingTransport>>>>,
         mut transport_rx: mpsc::UnboundedReceiver<AcceptingTransportPack>,
@@ -338,7 +338,7 @@ impl Acceptor {
     }
 
     /// Task managing a listening transport.
-    #[tracing::instrument(level="debug", skip_all, fields(transport=transport.transport.name()))]
+    #[tracing::instrument(level = "debug", skip_all, fields(transport = transport.transport.name()))]
     async fn transport_task(
         server: BoxServer, transport: AcceptingTransportPack, link_error_tx: broadcast::Sender<BoxLinkError>,
         wrappers: Arc<Vec<BoxAcceptingWrapper>>,
@@ -392,12 +392,12 @@ impl Acceptor {
                 let link = match server.add_incoming(tx, rx, tag.clone(), &user_data).await {
                     Ok(link) => link,
                     Err(err) => {
-                        tracing::debug!("adding link for tag {tag} to connection failed: {err}");
+                        tracing::warn!("adding link for tag {tag} to connection failed: {err}");
                         let _ = link_error_tx.send(LinkError::incoming(&tag, err.into()));
                         return;
                     }
                 };
-                tracing::debug!("link for tag {tag} connected");
+                tracing::info!("link for tag {tag} connected to {:?}", link.conn_id());
 
                 // Disconnect link when transport is removed.
                 struct DisconnectLink<'a>(&'a BoxLink);
@@ -410,14 +410,14 @@ impl Acceptor {
 
                 // Wait for disconnection and publish reason.
                 let reason = link.disconnected().await;
-                tracing::debug!("link for tag {tag} disconnected: {reason}");
+                tracing::info!("link for tag {tag} disconnected: {reason}");
                 let _ = link_error_tx.send(BoxLinkError::incoming(&tag, reason.into()));
             };
             accepting_tasks.push(task);
         };
 
         if let Err(err) = &res {
-            tracing::warn!("transport failed: {err}");
+            tracing::warn!("transport {} failed: {err}", transport.name());
         }
 
         let _ = result_tx.send(res);

aggligator/src/transport/connector.rs

@@ -242,7 +242,7 @@ impl Connector {
 
     /// Task for handling all transports.
     #[allow(clippy::too_many_arguments)]
-    #[tracing::instrument(level="debug", skip_all, fields(id=?control.id()))]
+    #[tracing::instrument(name = "aggligator::connector", level = "info", skip_all, fields(conn_id =? control.id()))]
     async fn task(
         control: BoxControl, active_transports: Arc<RwLock<Vec<Weak<dyn ConnectingTransport>>>>,
         mut transport_rx: mpsc::UnboundedReceiver<TransportPack>, tags_tx: watch::Sender<HashSet<LinkTagBox>>,
@@ -327,7 +327,7 @@ impl Connector {
     }
 
     /// Task for handling a transport.
-    #[tracing::instrument(level="debug", skip_all, fields(transport=transport_pack.transport.name()))]
+    #[tracing::instrument(level = "debug", skip_all, fields(transport = transport_pack.transport.name()))]
     async fn transport_task(
         transport_pack: TransportPack, control: BoxControl, tags_fw_tx: watch::Sender<HashSet<LinkTagBox>>,
         mut disabled_tags_rx: watch::Receiver<HashSet<LinkTagBox>>,
@@ -425,13 +425,13 @@ impl Connector {
                         let link = match control.add(tx, rx, tag.clone(), &tag.user_data()).await {
                             Ok(link) => link,
                             Err(err) => {
-                                tracing::debug!("adding link for tag {tag} to connection failed: {err}");
+                                tracing::warn!("adding link for tag {tag} to connection failed: {err}");
                                 let _ = link_error_tx.send(BoxLinkError::outgoing(conn_id, &tag, err.into()));
                                 sleep(reconnect_delay).await;
                                 return (tag, None);
                             }
                         };
-                        tracing::debug!("link for tag {tag} connected");
+                        tracing::info!("link for tag {tag} connected");
 
                         // Disconnect link when transport is removed.
                         struct DisconnectLink<'a>(&'a BoxLink);
@@ -445,7 +445,7 @@ impl Connector {
                         // Wait for disconnection and publish reason.
                         let sleep_until = sleep(reconnect_delay);
                         let reason = link.disconnected().await;
-                        tracing::debug!("link for tag {tag} disconnected: {reason}");
+                        tracing::info!("link for tag {tag} disconnected: {reason}");
                         let _ = link_error_tx.send(BoxLinkError::outgoing(conn_id, &tag, reason.clone().into()));
                         sleep_until.await;
 
@@ -483,7 +483,7 @@ impl Connector {
         // Publish result.
         match &res {
             Ok(()) => tracing::debug!("transport terminated"),
-            Err(err) => tracing::debug!("transport failed: {err}"),
+            Err(err) => tracing::warn!("transport {} failed: {err}", transport.name()),
         }
         let _ = result_tx.send(res);
     }