start on fake Slog example

Cargo.toml

@@ -3,4 +3,4 @@
 members = [
     "tokio-trace",
     "tokio-trace-slog"
-]
+]

tokio-trace/Cargo.toml

@@ -10,3 +10,4 @@ lazy_static = "1"
 
 [dev-dependencies]
 env_logger = "0.5"
+ansi_term = "0.11"

tokio-trace/examples/sloggish.rs

@@ -0,0 +1,49 @@
+#[macro_use]
+extern crate tokio_trace_prototype as tokio_trace;
+extern crate ansi_term;
+use ansi_term::Style;
+
+use std::{
+    io::Write,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+struct SloggishSubscriber {
+    indent: AtomicUsize,
+    indent_amount: usize,
+}
+
+impl SloggishSubscriber {
+    fn print_kvs<I>(&self, writer: &mut dyn Write, kvs: I) -> fmt::Result<()>
+    where
+        I: IntoIterator<Item=(&'static str, &dyn tokio_trace::Value)>,
+    {
+        for (k, v) in kvs {
+            write!(writer, "{}: {:?}", Style::new().bold().paint(k), v)?;
+        }
+        Ok(())
+    }
+
+    fn print_meta(&self, writer: &mut dyn Write, meta: &tokio_trace::StaticMeta) {
+        write!(writer, "")
+    }
+}
+
+impl tokio_trace::Subscriber for SloggishSubscriber {
+    #[inline]
+    fn observe_event<'event>(&self, event: &'event Event<'event>) {
+    }
+
+    #[inline]
+    fn enter(&self, span: &Span, at: Instant) {
+        self.
+    }
+
+    #[inline]
+    fn exit(&self, span: &Span, at: Instant) {
+    }
+}
+
+fn main() {
+
+}

tokio-trace/src/dedup.rs

@@ -0,0 +1,45 @@
+use std::iter::Peekable;
+
+pub trait IteratorDedup: Iterator + Sized {
+    fn dedup_by<F, K>(self, f: F) -> DedupBy<Self, F, K>
+    where
+        F: Fn(&Self::Item) -> K,
+        K: PartialEq,
+    {
+        DedupBy {
+            f,
+            inner: self.peekable(),
+            emit: true,
+        }
+    }
+}
+
+impl<I> IteratorDedup for I
+where
+    I: Iterator + Sized,
+{}
+
+pub struct DedupBy<I: Iterator, F> {
+    f: F,
+    inner: Peekable<I>,
+    emit: bool,
+}
+
+impl<I> Iterator for DedupBy<I>
+where I: Iterator, <I as Iterator>::Item: PartialEq {
+    type Item = <I as Iterator>::Item;
+    fn next(&mut self) -> Option<<I as Iterator>::Item> {
+        let result =
+            if self.emit {
+                self.inner.next()
+            } else {
+                let first = match self.inner.next() {
+                    None => return None,
+                    Some(first) => first,
+                };
+                self.inner.find(|item| first != *item)
+            };
+        self.emit = result.as_ref() != self.inner.peek();
+        result
+    }
+}

tokio-trace/src/lib.rs

@@ -15,6 +15,8 @@ use std::{
     slice,
 };
 
+use self::dedup::IteratorDedup;
+
 #[doc(hidden)]
 #[macro_export]
 macro_rules! static_meta {
@@ -91,6 +93,7 @@ thread_local! {
 
 pub mod subscriber;
 mod dispatcher;
+mod dedup;
 
 pub use dispatcher::{Dispatcher, Builder as DispatcherBuilder};
 
@@ -162,7 +165,6 @@ impl<'event> Event<'event> {
         self.field_names()
             .enumerate()
             .filter_map(move |(idx, &name)| self.field_values.get(idx).map(|&val| (name, val)))
-            .chain(self.parent.fields())
     }
 
     pub fn debug_fields(&'event self) -> DebugFields<'event, Self> {
@@ -174,6 +176,10 @@ impl<'event> Event<'event> {
             next: Some(&self.parent)
         }
     }
+
+    pub fn all_fields<'a>(&'a self) -> impl Iterator<Item = (&'static str, &'a dyn Value)> {
+        self.fields().chain(self.parents().flat_map(|parent| parent.fields())).dedup()
+    }
 }
 
 impl<'event> Drop for Event<'event> {