fix: better tracing spans (#3399)

## Description

This adds tracing spans to tasks we spawn where we didn't do this so
far.

I also added alpn and remote fields to the router tasks for connections,
to match what we do for outgoing connections.

Additionally, this improves the display of remote node ids and ALPNs by
using tracing's display formatter, to omit the quotes.

## Breaking Changes

<!-- Optional, if there are any breaking changes document them,
including how to migrate older code. -->

## Notes & open questions

<!-- Any notes, remarks or open questions you have to make about the PR.
-->

## Change checklist
<!-- Remove any that are not relevant. -->
- [x] Self-review.
- [ ] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [ ] Tests if relevant.
- [ ] All breaking changes documented.
- [ ] List all breaking changes in the above "Breaking Changes" section.
- [ ] Open an issue or PR on any number0 repos that are affected by this
breaking change. Give guidance on how the updates should be handled or
do the actual updates themselves. The major ones are:
    - [ ] [`quic-rpc`](https://github.com/n0-computer/quic-rpc)
    - [ ] [`iroh-gossip`](https://github.com/n0-computer/iroh-gossip)
    - [ ] [`iroh-blobs`](https://github.com/n0-computer/iroh-blobs)
    - [ ] [`dumbpipe`](https://github.com/n0-computer/dumbpipe)
    - [ ] [`sendme`](https://github.com/n0-computer/sendme)

Author: Frando

iroh/src/endpoint.rs

@@ -712,7 +712,7 @@ impl Endpoint {
     ///    establishing and maintaining direct connections.  Carefully test settings you use and
     ///    consider this currently as still rather experimental.
     #[instrument(name = "connect", skip_all, fields(
-        me = self.node_id().fmt_short(),
+        me = %self.node_id().fmt_short(),
         remote = tracing::field::Empty,
         alpn = String::from_utf8_lossy(alpn).to_string(),
     ))]
@@ -723,7 +723,10 @@ impl Endpoint {
         options: ConnectOptions,
     ) -> Result<Connecting, ConnectWithOptsError> {
         let node_addr: NodeAddr = node_addr.into();
-        tracing::Span::current().record("remote", node_addr.node_id.fmt_short());
+        tracing::Span::current().record(
+            "remote",
+            tracing::field::display(node_addr.node_id.fmt_short()),
+        );
 
         // Connecting to ourselves is not supported.
         ensure!(node_addr.node_id != self.node_id(), SelfConnectSnafu);

iroh/src/magicsock.rs

@@ -1177,24 +1177,27 @@ impl DirectAddrUpdateState {
         let msock = self.msock.clone();
 
         let run_done = self.run_done.clone();
-        task::spawn(async move {
-            let fut = time::timeout(
-                NET_REPORT_TIMEOUT,
-                net_reporter.get_report(if_state, why.is_major()),
-            );
-            match fut.await {
-                Ok(report) => {
-                    msock.net_report.set((Some(report), why)).ok();
-                }
-                Err(time::Elapsed { .. }) => {
-                    warn!("net_report report timed out");
+        task::spawn(
+            async move {
+                let fut = time::timeout(
+                    NET_REPORT_TIMEOUT,
+                    net_reporter.get_report(if_state, why.is_major()),
+                );
+                match fut.await {
+                    Ok(report) => {
+                        msock.net_report.set((Some(report), why)).ok();
+                    }
+                    Err(time::Elapsed { .. }) => {
+                        warn!("net_report report timed out");
+                    }
                 }
-            }
 
-            // mark run as finished
-            debug!("direct addr update done ({:?})", why);
-            run_done.send(()).await.ok();
-        });
+                // mark run as finished
+                debug!("direct addr update done ({:?})", why);
+                run_done.send(()).await.ok();
+            }
+            .instrument(tracing::Span::current()),
+        );
     }
 }
 

iroh/src/protocol.rs

@@ -46,7 +46,7 @@ use n0_future::{
 };
 use snafu::{Backtrace, Snafu};
 use tokio_util::sync::CancellationToken;
-use tracing::{error, info_span, trace, warn, Instrument};
+use tracing::{error, field::Empty, info_span, trace, warn, Instrument};
 
 use crate::{
     endpoint::{Connecting, Connection, RemoteNodeIdError},
@@ -447,9 +447,10 @@ impl RouterBuilder {
 
                         let protocols = protocols.clone();
                         let token = handler_cancel_token.child_token();
+                        let span = info_span!("router.accept", me=%endpoint.node_id().fmt_short(), remote=Empty, alpn=Empty);
                         join_set.spawn(async move {
                             token.run_until_cancelled(handle_connection(incoming, protocols)).await
-                        }.instrument(info_span!("router.accept")));
+                        }.instrument(span));
                     },
                 }
             }
@@ -471,7 +472,7 @@ impl RouterBuilder {
                 }
             }
         };
-        let task = task::spawn(run_loop_fut);
+        let task = task::spawn(run_loop_fut.instrument(tracing::Span::current()));
         let task = AbortOnDropHandle::new(task);
 
         Router {
@@ -497,12 +498,17 @@ async fn handle_connection(incoming: crate::endpoint::Incoming, protocols: Arc<P
             return;
         }
     };
+    tracing::Span::current().record("alpn", String::from_utf8_lossy(&alpn).to_string());
     let Some(handler) = protocols.get(&alpn) else {
         warn!("Ignoring connection: unsupported ALPN protocol");
         return;
     };
     match handler.on_connecting(connecting).await {
         Ok(connection) => {
+            if let Ok(remote) = connection.remote_node_id() {
+                tracing::Span::current()
+                    .record("remote", tracing::field::display(remote.fmt_short()));
+            };
             if let Err(err) = handler.accept(connection).await {
                 warn!("Handling incoming connection ended with error: {err}");
             }