tracing: Elide redundant info in tracing contexts (#661)

The tracing context includes redundant information, particularly about
the traffic target.

This change modifies the accept stack to include both the source peer and
target addresses in the `accept` context; and the target address has
been removed from intermediate contexts, many of which can be moved to
the debug level now.

Author: olix0r

linkerd/app/core/src/serve.rs

@@ -36,6 +36,7 @@ where
                     let span = info_span!(
                         "accept",
                         peer.addr = %addrs.peer(),
+                        target.addr = %addrs.target_addr(),
                     );
 
                     // Ready the service before dispatching the request to it.

linkerd/app/inbound/src/endpoint.rs

@@ -200,26 +200,12 @@ impl stack_tracing::GetSpan<()> for Target {
 
         match self.http_version {
             http::Version::H2 => match self.dst.name_addr() {
-                None => info_span!(
-                    "http2",
-                    port = %self.socket_addr.port(),
-                ),
-                Some(name) => info_span!(
-                    "http2",
-                    %name,
-                    port = %self.socket_addr.port(),
-                ),
+                None => info_span!("http2"),
+                Some(name) => info_span!("http2", %name),
             },
             http::Version::Http1 => match self.dst.name_addr() {
-                None => info_span!(
-                    "http1",
-                    port = %self.socket_addr.port(),
-                ),
-                Some(name) => info_span!(
-                    "http1",
-                    %name,
-                    port = %self.socket_addr.port(),
-                ),
+                None => info_span!("http1"),
+                Some(name) => info_span!("http1", %name),
             },
         }
     }

linkerd/app/inbound/src/lib.rs

@@ -27,7 +27,7 @@ use linkerd2_app_core::{
 };
 use std::collections::HashMap;
 use tokio::sync::mpsc;
-use tracing::{info, info_span};
+use tracing::{debug_span, info};
 
 pub mod endpoint;
 mod prevent_loop;
@@ -240,7 +240,7 @@ impl Config {
                 ),
             )
             .spawn_buffer(buffer_capacity)
-            .instrument(|_: &Target| info_span!("profile"))
+            .instrument(|_: &Target| debug_span!("profile"))
             .check_make_service::<Target, http::Request<_>>();
 
         let forward = target
@@ -254,7 +254,7 @@ impl Config {
                 ),
             )
             .spawn_buffer(buffer_capacity)
-            .instrument(|_: &Target| info_span!("forward"))
+            .instrument(|_: &Target| debug_span!("forward"))
             .check_make_service::<Target, http::Request<http::boxed::Payload>>();
 
         // Attempts to resolve the target as a service profile or, if that
@@ -355,13 +355,8 @@ impl Config {
                     .box_http_request()
                     .box_http_response(),
             )
+            .instrument(|_: &_| debug_span!("source"))
             .check_new_service::<tls::accept::Meta, http::Request<_>>()
-            .instrument(|src: &tls::accept::Meta| {
-                info_span!(
-                    "source",
-                    target.addr = %src.addrs.target_addr(),
-                )
-            })
             .into_inner()
             .into_make_service();
 

linkerd/app/outbound/src/lib.rs

@@ -30,7 +30,7 @@ use std::{
     time::Duration,
 };
 use tokio::sync::mpsc;
-use tracing::{info, info_span};
+use tracing::{debug_span, info, info_span};
 
 pub mod endpoint;
 mod prevent_loop;
@@ -335,7 +335,7 @@ impl Config {
                 ),
             )
             .spawn_buffer(buffer_capacity)
-            .instrument(|t: &HttpEndpoint| info_span!("forward", peer.addr = %t.addr, peer.id = ?t.identity))
+            .instrument(|t: &HttpEndpoint| debug_span!("forward", peer.id = ?t.identity))
             .check_make_service::<HttpEndpoint, http::Request<_>>();
 
         // Attempts to route route request to a logical services that uses
@@ -416,7 +416,7 @@ impl Config {
                     .push_make_thunk()
                     .push(admit::AdmitLayer::new(prevent_loop))
                     .push_map_target(TcpEndpoint::from)
-                    .instrument(|_: &SocketAddr| info_span!("forward")),
+                    .instrument(|_: &SocketAddr| debug_span!("forward")),
                 is_discovery_rejected,
             )
             .into_new_service()
@@ -432,7 +432,7 @@ impl Config {
             .spawn_buffer(buffer_capacity)
             .check_make_service::<SocketAddr, ()>()
             .push(svc::layer::mk(tcp::Forward::new))
-            .instrument(|a: &SocketAddr| info_span!("tcp", dst = %a))
+            .instrument(|_: &SocketAddr| info_span!("tcp"))
     }
 
     pub async fn build_server<E, R, C, H, S>(
@@ -524,9 +524,7 @@ impl Config {
                     .box_http_response(),
             )
             .push(svc::layer::mk(http::normalize_uri::MakeNormalizeUri::new))
-            .instrument(
-                |addrs: &listen::Addrs| info_span!("source", target.addr = %addrs.target_addr()),
-            )
+            .instrument(|_: &listen::Addrs| debug_span!("source"))
             .check_new_service::<listen::Addrs, http::Request<_>>()
             .into_inner()
             .into_make_service();

linkerd/proxy/http/src/detect.rs

@@ -15,7 +15,7 @@ use std::{
     time::Duration,
 };
 use tower::{util::ServiceExt, Service};
-use tracing::{info_span, trace};
+use tracing::{debug, info_span, trace};
 use tracing_futures::Instrument;
 
 type Server = hyper::server::conn::Http<trace::Executor>;
@@ -152,6 +152,7 @@ where
 
         let timeout = tokio::time::delay_for(self.timeout);
         Box::pin(async move {
+            trace!("Detecting");
             let (version, io) = tokio::select! {
                 res = HttpVersion::detect(io) => { res? }
                 () = timeout => {
@@ -161,7 +162,7 @@ where
 
             match version {
                 Some(HttpVersion::Http1) => {
-                    trace!("Handling as HTTP");
+                    debug!("Handling as HTTP");
                     // Enable support for HTTP upgrades (CONNECT and websockets).
                     let http = upgrade::Service::new(http, drain.clone());
                     let conn = server
@@ -176,7 +177,7 @@ where
                 }
 
                 Some(HttpVersion::H2) => {
-                    trace!("Handling as H2");
+                    debug!("Handling as H2");
                     let conn = server
                         .http2_only(true)
                         .serve_connection(io, HyperServerSvc::new(http));
@@ -188,7 +189,7 @@ where
                 }
 
                 None => {
-                    trace!("Forwarding TCP");
+                    debug!("Forwarding TCP");
                     let release = drain.ignore_signal();
                     tcp.oneshot(io).err_into::<Error>().await?;
                     drop(release);