跨 .await 持有 span.enter()，日志挂到别的 span 上

tracing = "=0.1.44"
tracing-subscriber = "=0.3.23"
tokio = { version = "=1.54.1", features = ["macros", "rt"] }

use tracing::{Instrument, info, info_span};

// 错误写法：守卫跨 .await
async fn wrong(id: u32) {
  let span = info_span!("task", id);
  let _g = span.enter();
  info!(who = id, "start");
  tokio::task::yield_now().await;
  info!(who = id, "after yield");
}

// 正确写法：span 交给 Instrumented，每次 poll 进出
async fn right(id: u32) {
  async {
    info!(who = id, "start");
    tokio::task::yield_now().await;
    info!(who = id, "after yield");
  }
  .instrument(info_span!("task", id))
  .await
}

// 旁观者：自己没有任何 span
async fn bystander() {
  info!(who = "c", "no span here");
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
  tracing_subscriber::fmt()
    .with_ansi(false)
    .without_time()
    .with_target(false)
    .init();

  info!("--- enter() 跨 .await");
  let tasks = [
    tokio::spawn(wrong(1)),
    tokio::spawn(wrong(2)),
    tokio::spawn(bystander()),
  ];
  for t in tasks {
    t.await.unwrap();
  }
  info!("--- .instrument()");
  let tasks = [
    tokio::spawn(right(1)),
    tokio::spawn(right(2)),
    tokio::spawn(bystander()),
  ];
  for t in tasks {
    t.await.unwrap();
  }
  info!("--- 结束");
}

 INFO --- enter() 跨 .await
 INFO task{id=1}: start who=1
 INFO task{id=1}:task{id=2}: start who=2
 INFO task{id=1}:task{id=2}: no span here who="c"
 INFO task{id=1}:task{id=2}: after yield who=2
 INFO task{id=1}: after yield who=1
 INFO --- .instrument()
 INFO task{id=1}: start who=1
 INFO task{id=2}: start who=2
 INFO no span here who="c"
 INFO task{id=2}: after yield who=2
 INFO task{id=1}: after yield who=1
 INFO --- 结束

    /// **Warning**: in asynchronous code that uses [async/await syntax][syntax],
    /// `Span::enter` should be used very carefully or avoided entirely. Holding
    /// the drop guard returned by `Span::enter` across `.await` points will
    /// result in incorrect traces. For example,

use tracing::info_span;

#[tokio::main]
async fn main() {
  // 借用版守卫 Entered 跨 .await：能编译
  tokio::spawn(async {
    let span = info_span!("a");
    let _g = span.enter();
    tokio::task::yield_now().await;
  })
  .await
  .unwrap();

  // 拥有版守卫 EnteredSpan 跨 .await：编译不过
  tokio::spawn(async {
    let _g = info_span!("b").entered();
    tokio::task::yield_now().await;
  })
  .await
  .unwrap();
}

error: future cannot be sent between threads safely
   --> src/bin/not_send.rs:15:3
    |
 15 | /   tokio::spawn(async {
 16 | |     let _g = info_span!("b").entered();
 17 | |     tokio::task::yield_now().await;
 18 | |   })
    | |____^ future created by async block is not `Send`
    |
    = help: within `{async block@src/bin/not_send.rs:15:16: 15:21}`, the trait `Send` is not implemented for `*mut ()`
note: future is not `Send` as this value is used across an await
   --> src/bin/not_send.rs:17:30
    |
 16 |     let _g = info_span!("b").entered();
    |         -- has type `EnteredSpan` which is not `Send`
 17 |     tokio::task::yield_now().await;
    |                              ^^^^^ await occurs here, with `_g` maybe used later
note: required by a bound in `tokio::spawn`
   --> ~/.cargo/registry/.../tokio-1.54.1/src/task/spawn.rs:176:21
    |
174 |     pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
    |            ----- required by a bound in this function
175 |     where
176 |         F: Future + Send + 'static,
    |                     ^^^^ required by this bound in `spawn`

warning[E0602]: unknown lint: `clippy::await_holding_span_guard`
  |
  = help: did you mean: `clippy::await_holding_lock`
  = note: requested on the command line with `-W clippy::await_holding_span_guard`
  = note: `#[warn(unknown_lints)]` on by default

async fn right(id: u32) {
  async {
    // ...
  }
  .instrument(info_span!("task", id))
  .await
}

await-holding-invalid-types = [
  { path = "tracing::span::Entered", reason = "用 Instrument::instrument 代替" },
  { path = "tracing::span::EnteredSpan", reason = "用 Instrument::instrument 代替" },
]

warning: holding a disallowed type across an await point `tracing::span::Entered`
 --> src/bin/hold_across_await.rs:6:7
  |
6 |   let _g = span.enter();
  |       ^^
  |
  = note: 用 Instrument::instrument 代替
  = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.99.0/index.html#await_holding_invalid_type
  = note: `#[warn(clippy::await_holding_invalid_type)]` on by default