Update to track upstream changes

tokio-trace-env-logger/examples/hyper-echo/sloggish.rs

@@ -12,31 +12,68 @@
 //! [`slog` README]: https://github.com/slog-rs/slog#terminal-output-example
 extern crate ansi_term;
 extern crate humantime;
-extern crate tokio_trace_subscriber;
-
 use self::ansi_term::{Color, Style};
-use super::tokio_trace::{self, Id, Level, Subscriber};
+use super::tokio_trace::{
+ self,
+ field::{Field, Record},
+ Id, Level, Subscriber,
+};
 
 use std::{
+ cell::RefCell,
  collections::HashMap,
  fmt,
  io::{self, Write},
  sync::{
  atomic::{AtomicUsize, Ordering},
  Mutex,
  },
+ thread,
  time::SystemTime,
 };
 
+/// Tracks the currently executing span on a per-thread basis.
+#[derive(Clone)]
+pub struct CurrentSpanPerThread {
+ current: &'static thread::LocalKey<RefCell<Vec<Id>>>,
+}
+
+impl CurrentSpanPerThread {
+ pub fn new() -> Self {
+ thread_local! {
+ static CURRENT: RefCell<Vec<Id>> = RefCell::new(vec![]);
+ };
+ Self { current: &CURRENT }
+ }
+
+ /// Returns the [`Id`](::Id) of the span in which the current thread is
+ /// executing, or `None` if it is not inside of a span.
+ pub fn id(&self) -> Option<Id> {
+ self.current
+ .with(|current| current.borrow().last().cloned())
+ }
+
+ pub fn enter(&self, span: Id) {
+ self.current.with(|current| {
+ current.borrow_mut().push(span);
+ })
+ }
+
+ pub fn exit(&self) {
+ self.current.with(|current| {
+ let _ = current.borrow_mut().pop();
+ })
+ }
+}
+
 pub struct SloggishSubscriber {
  // TODO: this can probably be unified with the "stack" that's used for
  // printing?
- current: tokio_trace_subscriber::CurrentSpanPerThread,
+ current: CurrentSpanPerThread,
  indent_amount: usize,
  stderr: io::Stderr,
  stack: Mutex<Vec<Id>>,
  spans: Mutex<HashMap<Id, Span>>,
- events: Mutex<HashMap<Id, Event>>,
  ids: AtomicUsize,
 }
 
@@ -45,72 +82,86 @@ struct Span {
  kvs: Vec<(&'static str, String)>,
 }
 
-struct Event {
- level: tokio_trace::Level,
- target: String,
- message: String,
- kvs: Vec<(&'static str, String)>,
+struct Event<'a> {
+ stderr: io::StderrLock<'a>,
+ comma: bool,
 }
 
-struct ColorLevel(Level);
+struct ColorLevel<'a>(&'a Level);
 
-impl fmt::Display for ColorLevel {
+impl<'a> fmt::Display for ColorLevel<'a> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  match self.0 {
- Level::TRACE => Color::Purple.paint("TRACE"),
- Level::DEBUG => Color::Blue.paint("DEBUG"),
- Level::INFO => Color::Green.paint("INFO"),
- Level::WARN => Color::Yellow.paint("WARN "),
- Level::ERROR => Color::Red.paint("ERROR"),
+ &Level::TRACE => Color::Purple.paint("TRACE"),
+ &Level::DEBUG => Color::Blue.paint("DEBUG"),
+ &Level::INFO => Color::Green.paint("INFO "),
+ &Level::WARN => Color::Yellow.paint("WARN "),
+ &Level::ERROR => Color::Red.paint("ERROR"),
  }
  .fmt(f)
  }
 }
 
 impl Span {
- fn new(parent: Option<Id>, _meta: &tokio_trace::Metadata) -> Self {
- Self {
+ fn new(
+ parent: Option<Id>,
+ _meta: &tokio_trace::Metadata,
+ values: &tokio_trace::field::ValueSet,
+ ) -> Self {
+ let mut span = Self {
  parent,
  kvs: Vec::new(),
- }
- }
-
- fn record(&mut self, key: &tokio_trace::field::Field, value: fmt::Arguments) {
- let v = fmt::format(value);
- self.kvs.push((key.name(), v));
+ };
+ values.record(&mut span);
+ span
  }
 }
 
-impl Event {
- fn new(meta: &tokio_trace::Metadata) -> Self {
- Self {
- target: meta.target.to_owned(),
- level: meta.level.clone(),
- message: String::new(),
- kvs: Vec::new(),
- }
+impl Record for Span {
+ fn record_debug(&mut self, field: &Field, value: &fmt::Debug) {
+ self.kvs.push((field.name(), format!("{:?}", value)))
  }
+}
 
- fn record(&mut self, key: &tokio_trace::field::Field, value: fmt::Arguments) {
- if key.name() == "message" {
- self.message = fmt::format(value);
- return;
+impl<'a> Record for Event<'a> {
+ fn record_debug(&mut self, field: &Field, value: &fmt::Debug) {
+ write!(
+ &mut self.stderr,
+ "{comma} ",
+ comma = if self.comma { "," } else { "" },
+ )
+ .unwrap();
+ let name = field.name();
+ if name == "message" {
+ write!(
+ &mut self.stderr,
+ "{}",
+ // Have to alloc here due to `ansi_term`'s API...
+ Style::new().bold().paint(format!("{:?}", value))
+ )
+ .unwrap();
+ self.comma = true;
+ } else {
+ write!(
+ &mut self.stderr,
+ "{}: {:?}",
+ Style::new().bold().paint(name),
+ value
+ )
+ .unwrap();
+ self.comma = true;
  }
-
- let v = fmt::format(value);
- self.kvs.push((key.name(), v));
  }
 }
 
 impl SloggishSubscriber {
  pub fn new(indent_amount: usize) -> Self {
  Self {
- current: tokio_trace_subscriber::CurrentSpanPerThread::new(),
+ current: CurrentSpanPerThread::new(),
  indent_amount,
  stderr: io::stderr(),
  stack: Mutex::new(vec![]),
  spans: Mutex::new(HashMap::new()),
- events: Mutex::new(HashMap::new()),
  ids: AtomicUsize::new(0),
  }
  }
@@ -155,39 +206,26 @@ impl Subscriber for SloggishSubscriber {
  true
  }
 
- fn new_span(&self, span: &tokio_trace::Metadata) -> tokio_trace::Id {
+ fn new_span(
+ &self,
+ span: &tokio_trace::Metadata,
+ values: &tokio_trace::field::ValueSet,
+ ) -> tokio_trace::Id {
  let next = self.ids.fetch_add(1, Ordering::SeqCst) as u64;
  let id = tokio_trace::Id::from_u64(next);
- if span.name.contains("event") {
- self.events
- .lock()
- .unwrap()
- .insert(id.clone(), Event::new(span));
- } else {
- self.spans
- .lock()
- .unwrap()
- .insert(id.clone(), Span::new(self.current.id(), span));
- }
+ let span = Span::new(self.current.id(), span, values);
+ self.spans.lock().unwrap().insert(id.clone(), span);
  id
  }
 
- fn record_debug(
- &self,
- span: &tokio_trace::Id,
- name: &tokio_trace::field::Field,
- value: &fmt::Debug,
- ) {
- if let Some(event) = self.events.lock().expect("mutex poisoned!").get_mut(span) {
- return event.record(name, format_args!("{:?}", value));
- };
+ fn record(&self, span: &tokio_trace::Id, values: &tokio_trace::field::ValueSet) {
  let mut spans = self.spans.lock().expect("mutex poisoned!");
  if let Some(span) = spans.get_mut(span) {
- span.record(name, format_args!("{:?}", value))
+ values.record(span);
  }
  }
 
- fn add_follows_from(&self, _span: &tokio_trace::Id, _follows: tokio_trace::Id) {
+ fn record_follows_from(&self, _span: &tokio_trace::Id, _follows: &tokio_trace::Id) {
  // unimplemented
  }
 
@@ -223,34 +261,33 @@ impl Subscriber for SloggishSubscriber {
  }
  }
 
+ fn event(&self, event: &tokio_trace::Event) {
+ let mut stderr = self.stderr.lock();
+ let indent = self.stack.lock().unwrap().len();
+ self.print_indent(&mut stderr, indent).unwrap();
+ write!(
+ &mut stderr,
+ "{timestamp} {level} {target}",
+ timestamp = humantime::format_rfc3339_seconds(SystemTime::now()),
+ level = ColorLevel(event.metadata().level()),
+ target = &event.metadata().target(),
+ )
+ .unwrap();
+ let mut recorder = Event {
+ stderr,
+ comma: false,
+ };
+ event.record(&mut recorder);
+ write!(&mut recorder.stderr, "\n").unwrap();
+ }
+
  #[inline]
  fn exit(&self, _span: &tokio_trace::Id) {
  // TODO: unify stack with current span
  self.current.exit();
  }
 
- fn drop_span(&self, id: tokio_trace::Id) {
- if let Some(event) = self.events.lock().expect("mutex poisoned").remove(&id) {
- let mut stderr = self.stderr.lock();
- let indent = self.stack.lock().unwrap().len();
- self.print_indent(&mut stderr, indent).unwrap();
- write!(
- &mut stderr,
- "{timestamp} {level} {target} {message}",
- timestamp = humantime::format_rfc3339_seconds(SystemTime::now()),
- level = ColorLevel(event.level),
- target = &event.target,
- message = Style::new().bold().paint(event.message),
- )
- .unwrap();
- self.print_kvs(
- &mut stderr,
- event.kvs.iter().map(|&(ref k, ref v)| (k, v)),
- ", ",
- )
- .unwrap();
- write!(&mut stderr, "\n").unwrap();
- }
+ fn drop_span(&self, _id: tokio_trace::Id) {
  // TODO: GC unneeded spans.
  }
 }

tokio-trace-futures/src/lib.rs

@@ -5,7 +5,7 @@ extern crate tokio;
 extern crate tokio_trace;
 
 use futures::{Async, Future, Poll, Sink, StartSend, Stream};
-use tokio_trace::{dispatcher, Dispatch, Span, Subscriber};
+use tokio_trace::{dispatcher, Dispatch, Span};
 
 pub mod executor;
 
@@ -21,11 +21,11 @@ pub trait Instrument: Sized {
 pub trait WithSubscriber: Sized {
  fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
  where
- S: Subscriber + Send + Sync + 'static,
+ S: Into<Dispatch>,
  {
  WithDispatch {
  inner: self,
- dispatch: Dispatch::new(subscriber),
+ dispatch: subscriber.into(),
  }
  }
 }