rt::tracing：给 spawn 出去的任务带上 span

    fn execute(&self, fut: Fut) {
        #[cfg(feature = "rt-tracing-exec-force")]
        tokio::spawn(fut.in_current_span());

        #[cfg(not(feature = "rt-tracing-exec-force"))]
        tokio::spawn(fut);
    }

impl<E, F> Executor<F> for CurrentSpanExecutor<E>
where
    E: Executor<Instrumented<F>>,
    F: Future,
{
    fn execute(&self, future: F) {
        self.inner.execute(future.in_current_span());
    }
}

    let executor = {
        // Propagate spans to spawned tasks.
        use hyper_util::rt::{CurrentSpanExecutor, TokioExecutor};
        let tokio = TokioExecutor::new();
        CurrentSpanExecutor::new(tokio)
    };

let mk = || {
    let span = info_span!("example");
    span.follows_from(Span::current());
    span
};
let executor = MkSpanExecutor::new(TokioExecutor::new(), mk);

hyper = { version = "1", features = ["full"] }   # 1.12.0
hyper-util = { version = "=0.1.21", features = ["full"] }
tokio = { version = "=1.54.1", features = ["full"] }
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["registry"] }
http-body-util = "0.1"
bytes = "1"

// Prints span closes and every hyper-util event with the spans it sits in.
struct Probe;
impl<S: Subscriber + for<'a> LookupSpan<'a>> Layer<S> for Probe {
  fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
    if let Some(s) = ctx.span(&id) { println!("{:>5}ms  close span `{}`", ms(), s.name()); }
  }
  fn on_event(&self, e: &Event<'_>, ctx: Context<'_, S>) {
    if !e.metadata().target().starts_with("hyper_util") { return; }
    let mut m = Msg(String::new());
    e.record(&mut m);
    let scope: Vec<_> = ctx.event_scope(e).map(|s| s.from_root().map(|s| s.name()).collect()).unwrap_or_default();
    println!("{:>5}ms  event {:?} spans={scope:?}", ms(), m.0);
  }
}

async fn run<E>(name: &str, exec: E, addr: std::net::SocketAddr)
where
  E: hyper::rt::Executor<std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>> + Clone + Send + Sync + 'static,
{
  println!("== {name}");
  let client: Client<_, Empty<Bytes>> = Client::builder(exec)
    .pool_idle_timeout(Duration::from_secs(1))
    .pool_timer(TokioTimer::new())
    .build_http();
  let url: hyper::Uri = format!("http://{addr}/").parse().unwrap();
  async {
    let resp = client.get(url).await.unwrap();
    resp.into_body().collect().await.unwrap();
    println!("{:>5}ms  response body read", ms());
  }
  .instrument(tracing::info_span!("request"))
  .await;
  tokio::time::sleep(Duration::from_secs(3)).await;
  println!("{:>5}ms  drop client", ms());
  drop(client);
  tokio::time::sleep(Duration::from_millis(200)).await;
}

// main: run("TokioExecutor", TokioExecutor::new(), ..) then
//       run("CurrentSpanExecutor<TokioExecutor>", CurrentSpanExecutor::new(TokioExecutor::new()), ..)

== TokioExecutor
    2ms  event "checkout waiting for idle connection: (\"http\", 127.0.0.1:50696)" spans=["request"]
    ...
    5ms  event "pooling idle connection for (\"http\", 127.0.0.1:50696)" spans=["request"]
    5ms  response body read
    5ms  close span `request`
 1007ms  event "idle interval checking for expired" spans=[]
 1007ms  event "idle interval evicting expired for (\"http\", 127.0.0.1:50696)" spans=[]
 1007ms  event "pool empty, canceling idle interval" spans=[]
 1007ms  server: connection closed
 3007ms  drop client
== CurrentSpanExecutor<TokioExecutor>
 3209ms  event "checkout waiting for idle connection: (\"http\", 127.0.0.1:50696)" spans=["request"]
    ...
 3211ms  event "pooling idle connection for (\"http\", 127.0.0.1:50696)" spans=["request"]
 3211ms  response body read
 4212ms  event "idle interval checking for expired" spans=["request"]
 4212ms  event "idle interval evicting expired for (\"http\", 127.0.0.1:50696)" spans=["request"]
 4212ms  event "pool empty, canceling idle interval" spans=["request"]
 4213ms  close span `request`
 4213ms  server: connection closed
 6212ms  drop client

== hyper-util 0.1.20 TokioExecutor (tracing feature on)
    1ms  event "checkout waiting for idle connection: (\"http\", 127.0.0.1:50743)" spans=["request"]
    ...
    3ms  response body read
    3ms  event "put; add idle connection for (\"http\", 127.0.0.1:50743)" spans=["request"]
    3ms  event "pooling idle connection for (\"http\", 127.0.0.1:50743)" spans=["request"]
 1005ms  event "idle interval checking for expired" spans=["request"]
 1005ms  event "idle interval evicting expired for (\"http\", 127.0.0.1:50743)" spans=["request"]
 1005ms  server: connection closed
 2007ms  event "idle interval checking for expired" spans=["request"]
 3005ms  drop client
 3005ms  event "pool closed, canceling idle interval" spans=["request"]
 3005ms  close span `request`