用了 non_blocking，一行日志都没有

tracing = "=0.1.44"
tracing-subscriber = "=0.3.23"
tracing-appender = "=0.2.5"

fn main() {
  let (writer, _) = tracing_appender::non_blocking(std::io::stdout());
  let counter = writer.error_counter();
  tracing_subscriber::fmt().with_ansi(false).without_time().with_writer(writer).init();
  for i in 0..3 {
    tracing::info!(i, "hello");
  }
  eprintln!("dropped_lines = {}", counter.dropped_lines());
}

dropped_lines = 3

 INFO guard_named: hello i=0
 INFO guard_named: hello i=1
 INFO guard_named: hello i=2
dropped_lines = 0

impl Drop for WorkerGuard {
    fn drop(&mut self) {
        match self
            .sender
            .send_timeout(Msg::Shutdown, Duration::from_millis(100))
        {
            Ok(_) => {
                // Attempt to wait for `Worker` to flush all messages before dropping. This happens
                // when the `Worker` calls `recv()` on a zero-capacity channel. Use `send_timeout`
                // so that drop is not blocked indefinitely.
                // TODO: Make timeout configurable.
                let _ = self.shutdown.send_timeout((), Duration::from_millis(1000));
            }
            Err(SendTimeoutError::Disconnected(_)) => (),
            Err(SendTimeoutError::Timeout(e)) => println!(
                "Failed to send shutdown signal to logging worker. Error: {:?}",
                e
            ),
        }
    }
}

                loop {
                    match self.work() {
                        Ok(WorkerState::Continue) | Ok(WorkerState::Empty) => {}
                        Ok(WorkerState::Shutdown) | Ok(WorkerState::Disconnected) => {
                            let _ = self.shutdown.recv();
                            break;
                        }
                        Err(_) => {
                            // TODO: Expose a metric for IO Errors, or print to stderr
                        }
                    }
                }

    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        let buf_size = buf.len();
        if self.is_lossy {
            if self.channel.try_send(Msg::Line(buf.to_vec())).is_err() {
                self.error_counter.incr_saturating();
            }
        } else {
            return match self.channel.send(Msg::Line(buf.to_vec())) {
                Ok(_) => Ok(buf_size),
                Err(_) => Err(io::Error::from(io::ErrorKind::Other)),
            };
        }
        Ok(buf_size)
    }

[tracing-subscriber] Unable to write an event to the Writer for this Subscriber! Error: other error

[tracing-subscriber] Unable to write an event to the Writer for this Subscriber! Error: other error

[tracing-subscriber] Unable to write an event to the Writer for this Subscriber! Error: other error

use std::io::{self, Write};
use std::time::{Duration, Instant};

// 一个慢 writer：每行 20 ms，模拟慢磁盘或网络
struct Slow;

impl Write for Slow {
  fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
    std::thread::sleep(Duration::from_millis(20));
    io::stdout().write_all(buf)?;
    Ok(buf.len())
  }
  fn flush(&mut self) -> io::Result<()> {
    io::stdout().flush()
  }
}

fn main() {
  let args: Vec<String> = std::env::args().collect();
  let how = args[1].as_str();
  let n: usize = args[2].parse().unwrap();
  let (writer, _guard) = tracing_appender::non_blocking(Slow);
  tracing_subscriber::fmt()
    .with_ansi(false)
    .without_time()
    .with_target(false)
    .with_writer(writer)
    .init();
  for i in 0..n {
    tracing::info!(i);
  }
  let start = Instant::now();
  match how {
    "exit" => std::process::exit(0),
    "return" => {
      drop(_guard);
      eprintln!("guard dropped after {} ms", start.elapsed().as_millis());
    }
    _ => unreachable!(),
  }
}

== exit 5
lines written: 0
== return 5
guard dropped after 143 ms
lines written: 5

use std::io::{self, Write};
use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
use std::time::{Duration, Instant};

use tracing_appender::non_blocking::NonBlockingBuilder;

static WRITTEN: AtomicUsize = AtomicUsize::new(0);

// 每行 1 ms 的 writer，只计数不输出
struct Slow;

impl Write for Slow {
  fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
    std::thread::sleep(Duration::from_millis(1));
    WRITTEN.fetch_add(1, Relaxed);
    Ok(buf.len())
  }
  fn flush(&mut self) -> io::Result<()> {
    Ok(())
  }
}

fn main() {
  let lossy = std::env::args().nth(1).unwrap() == "lossy";
  let (writer, guard) = NonBlockingBuilder::default()
    .buffered_lines_limit(8)
    .lossy(lossy)
    .finish(Slow);
  let counter = writer.error_counter();
  let sub = tracing_subscriber::fmt().with_writer(writer).finish();
  let start = Instant::now();
  tracing::subscriber::with_default(sub, || {
    for i in 0..1000 {
      tracing::info!(i);
    }
  });
  let emit_ms = start.elapsed().as_millis();
  drop(guard);
  println!(
    "lossy={lossy:<5} 发 1000 条用了 {emit_ms:>4} ms，写出 {:>4}，dropped_lines = {}",
    WRITTEN.load(Relaxed),
    counter.dropped_lines()
  );
}

lossy=true  发 1000 条用了    0 ms，写出    9，dropped_lines = 991
lossy=true  发 1000 条用了    0 ms，写出    9，dropped_lines = 991
lossy=true  发 1000 条用了    0 ms，写出    9，dropped_lines = 991
lossy=false 发 1000 条用了 1478 ms，写出 1000，dropped_lines = 0
lossy=false 发 1000 条用了 1473 ms，写出 1000，dropped_lines = 0
lossy=false 发 1000 条用了 1481 ms，写出 1000，dropped_lines = 0

== return 100
guard dropped after 1001 ms
lines written: 36
== return 100
guard dropped after 1010 ms
lines written: 35
== return 100
guard dropped after 1010 ms
lines written: 35