From 986225473f8468b8bf27054c798269eeb8a698d7 Mon Sep 17 00:00:00 2001
From: Jeremy Fitzhardinge <jsgf@fb.com>
Date: Fri, 3 Sep 2021 12:31:56 -0700
Subject: [PATCH 1/2] 0.1: add Layer implementations for various containers

Add Layer<S> impls for:
- Box<L>
- Box<dyn Layer<S>>
- Arc<L>
- Arc<dyn Layer<S>>

where L: Layer<S>
---
 tracing-subscriber/src/layer.rs | 268 ++++++++++++++++++++++++++++++++
 1 file changed, 268 insertions(+)

diff --git a/tracing-subscriber/src/layer.rs b/tracing-subscriber/src/layer.rs
index 5b35bfb2ff..114acc8f88 100644
--- a/tracing-subscriber/src/layer.rs
+++ b/tracing-subscriber/src/layer.rs
@@ -13,6 +13,8 @@ use std::{
     any::{type_name, TypeId},
     fmt,
     marker::PhantomData,
+    ops::Deref,
+    sync::Arc,
 };
 
 /// A composable handler for `tracing` events.
@@ -917,6 +919,272 @@ where
     }
 }
 
+impl<L, S> Layer<S> for Arc<L>
+where
+    L: Layer<S>,
+    S: Subscriber,
+{
+    #[inline]
+    fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().new_span(attrs, id, ctx)
+    }
+
+    #[inline]
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.deref().register_callsite(metadata)
+    }
+
+    #[inline]
+    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+        self.deref().enabled(metadata, ctx)
+    }
+
+    #[inline]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.deref().max_level_hint()
+    }
+
+    #[inline]
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+        self.deref().on_record(span, values, ctx)
+    }
+
+    #[inline]
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_follows_from(span, follows, ctx)
+    }
+
+    #[inline]
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+        self.deref().on_event(event, ctx)
+    }
+
+    #[inline]
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_enter(id, ctx)
+    }
+
+    #[inline]
+    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_exit(id, ctx)
+    }
+
+    #[inline]
+    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+        self.deref().on_close(id, ctx)
+    }
+
+    #[inline]
+    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_id_change(old, new, ctx)
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        self.deref().downcast_raw(id)
+    }
+}
+
+impl<S> Layer<S> for Arc<dyn Layer<S>>
+where
+    S: Subscriber,
+{
+    #[inline]
+    fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().new_span(attrs, id, ctx)
+    }
+
+    #[inline]
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.deref().register_callsite(metadata)
+    }
+
+    #[inline]
+    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+        self.deref().enabled(metadata, ctx)
+    }
+
+    #[inline]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.deref().max_level_hint()
+    }
+
+    #[inline]
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+        self.deref().on_record(span, values, ctx)
+    }
+
+    #[inline]
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_follows_from(span, follows, ctx)
+    }
+
+    #[inline]
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+        self.deref().on_event(event, ctx)
+    }
+
+    #[inline]
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_enter(id, ctx)
+    }
+
+    #[inline]
+    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_exit(id, ctx)
+    }
+
+    #[inline]
+    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+        self.deref().on_close(id, ctx)
+    }
+
+    #[inline]
+    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_id_change(old, new, ctx)
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        self.deref().downcast_raw(id)
+    }
+}
+
+impl<L, S> Layer<S> for Box<L>
+where
+    L: Layer<S>,
+    S: Subscriber,
+{
+    #[inline]
+    fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().new_span(attrs, id, ctx)
+    }
+
+    #[inline]
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.deref().register_callsite(metadata)
+    }
+
+    #[inline]
+    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+        self.deref().enabled(metadata, ctx)
+    }
+
+    #[inline]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.deref().max_level_hint()
+    }
+
+    #[inline]
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+        self.deref().on_record(span, values, ctx)
+    }
+
+    #[inline]
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_follows_from(span, follows, ctx)
+    }
+
+    #[inline]
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+        self.deref().on_event(event, ctx)
+    }
+
+    #[inline]
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_enter(id, ctx)
+    }
+
+    #[inline]
+    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_exit(id, ctx)
+    }
+
+    #[inline]
+    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+        self.deref().on_close(id, ctx)
+    }
+
+    #[inline]
+    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_id_change(old, new, ctx)
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        self.deref().downcast_raw(id)
+    }
+}
+
+impl<S> Layer<S> for Box<dyn Layer<S>>
+where
+    S: Subscriber,
+{
+    #[inline]
+    fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().new_span(attrs, id, ctx)
+    }
+
+    #[inline]
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.deref().register_callsite(metadata)
+    }
+
+    #[inline]
+    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+        self.deref().enabled(metadata, ctx)
+    }
+
+    #[inline]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.deref().max_level_hint()
+    }
+
+    #[inline]
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+        self.deref().on_record(span, values, ctx)
+    }
+
+    #[inline]
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_follows_from(span, follows, ctx)
+    }
+
+    #[inline]
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+        self.deref().on_event(event, ctx)
+    }
+
+    #[inline]
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_enter(id, ctx)
+    }
+
+    #[inline]
+    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_exit(id, ctx)
+    }
+
+    #[inline]
+    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+        self.deref().on_close(id, ctx)
+    }
+
+    #[inline]
+    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
+        self.deref().on_id_change(old, new, ctx)
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        self.deref().downcast_raw(id)
+    }
+}
+
 impl<'a, L, S> LookupSpan<'a> for Layered<L, S>
 where
     S: Subscriber + LookupSpan<'a>,

From ec74cca91bb3763aa3bd58432bce39384839b217 Mon Sep 17 00:00:00 2001
From: Jeremy Fitzhardinge <jsgf@fb.com>
Date: Fri, 3 Sep 2021 12:50:55 -0700
Subject: [PATCH 2/2] Use a macro, it's cleaner.

---
 tracing-subscriber/src/layer.rs | 297 +++++++-------------------------
 1 file changed, 63 insertions(+), 234 deletions(-)

diff --git a/tracing-subscriber/src/layer.rs b/tracing-subscriber/src/layer.rs
index 114acc8f88..cbddb9dd70 100644
--- a/tracing-subscriber/src/layer.rs
+++ b/tracing-subscriber/src/layer.rs
@@ -919,137 +919,84 @@ where
     }
 }
 
-impl<L, S> Layer<S> for Arc<L>
-where
-    L: Layer<S>,
-    S: Subscriber,
-{
-    #[inline]
-    fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().new_span(attrs, id, ctx)
-    }
+macro_rules! layer_impl_body {
+    () => {
+        #[inline]
+        fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+            self.deref().new_span(attrs, id, ctx)
+        }
 
-    #[inline]
-    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
-        self.deref().register_callsite(metadata)
-    }
+        #[inline]
+        fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+            self.deref().register_callsite(metadata)
+        }
 
-    #[inline]
-    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
-        self.deref().enabled(metadata, ctx)
-    }
+        #[inline]
+        fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+            self.deref().enabled(metadata, ctx)
+        }
 
-    #[inline]
-    fn max_level_hint(&self) -> Option<LevelFilter> {
-        self.deref().max_level_hint()
-    }
+        #[inline]
+        fn max_level_hint(&self) -> Option<LevelFilter> {
+            self.deref().max_level_hint()
+        }
 
-    #[inline]
-    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
-        self.deref().on_record(span, values, ctx)
-    }
+        #[inline]
+        fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+            self.deref().on_record(span, values, ctx)
+        }
 
-    #[inline]
-    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_follows_from(span, follows, ctx)
-    }
+        #[inline]
+        fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+            self.deref().on_follows_from(span, follows, ctx)
+        }
 
-    #[inline]
-    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
-        self.deref().on_event(event, ctx)
-    }
+        #[inline]
+        fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+            self.deref().on_event(event, ctx)
+        }
 
-    #[inline]
-    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_enter(id, ctx)
-    }
+        #[inline]
+        fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+            self.deref().on_enter(id, ctx)
+        }
 
-    #[inline]
-    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_exit(id, ctx)
-    }
+        #[inline]
+        fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+            self.deref().on_exit(id, ctx)
+        }
 
-    #[inline]
-    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
-        self.deref().on_close(id, ctx)
-    }
+        #[inline]
+        fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+            self.deref().on_close(id, ctx)
+        }
 
-    #[inline]
-    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_id_change(old, new, ctx)
-    }
+        #[inline]
+        fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
+            self.deref().on_id_change(old, new, ctx)
+        }
 
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
-        self.deref().downcast_raw(id)
-    }
+        #[doc(hidden)]
+        #[inline]
+        unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+            self.deref().downcast_raw(id)
+        }
+    };
 }
 
-impl<S> Layer<S> for Arc<dyn Layer<S>>
+impl<L, S> Layer<S> for Arc<L>
 where
+    L: Layer<S>,
     S: Subscriber,
 {
-    #[inline]
-    fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().new_span(attrs, id, ctx)
-    }
-
-    #[inline]
-    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
-        self.deref().register_callsite(metadata)
-    }
-
-    #[inline]
-    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
-        self.deref().enabled(metadata, ctx)
-    }
-
-    #[inline]
-    fn max_level_hint(&self) -> Option<LevelFilter> {
-        self.deref().max_level_hint()
-    }
-
-    #[inline]
-    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
-        self.deref().on_record(span, values, ctx)
-    }
-
-    #[inline]
-    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_follows_from(span, follows, ctx)
-    }
-
-    #[inline]
-    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
-        self.deref().on_event(event, ctx)
-    }
-
-    #[inline]
-    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_enter(id, ctx)
-    }
-
-    #[inline]
-    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_exit(id, ctx)
-    }
-
-    #[inline]
-    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
-        self.deref().on_close(id, ctx)
-    }
-
-    #[inline]
-    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_id_change(old, new, ctx)
-    }
+    layer_impl_body! {}
+}
 
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
-        self.deref().downcast_raw(id)
-    }
+impl<S> Layer<S> for Arc<dyn Layer<S>>
+where
+    S: Subscriber,
+{
+    layer_impl_body! {}
 }
 
 impl<L, S> Layer<S> for Box<L>
@@ -1057,132 +1004,14 @@ where
     L: Layer<S>,
     S: Subscriber,
 {
-    #[inline]
-    fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().new_span(attrs, id, ctx)
-    }
-
-    #[inline]
-    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
-        self.deref().register_callsite(metadata)
-    }
-
-    #[inline]
-    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
-        self.deref().enabled(metadata, ctx)
-    }
-
-    #[inline]
-    fn max_level_hint(&self) -> Option<LevelFilter> {
-        self.deref().max_level_hint()
-    }
-
-    #[inline]
-    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
-        self.deref().on_record(span, values, ctx)
-    }
-
-    #[inline]
-    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_follows_from(span, follows, ctx)
-    }
-
-    #[inline]
-    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
-        self.deref().on_event(event, ctx)
-    }
-
-    #[inline]
-    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_enter(id, ctx)
-    }
-
-    #[inline]
-    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_exit(id, ctx)
-    }
-
-    #[inline]
-    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
-        self.deref().on_close(id, ctx)
-    }
-
-    #[inline]
-    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_id_change(old, new, ctx)
-    }
-
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
-        self.deref().downcast_raw(id)
-    }
+    layer_impl_body! {}
 }
 
 impl<S> Layer<S> for Box<dyn Layer<S>>
 where
     S: Subscriber,
 {
-    #[inline]
-    fn new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().new_span(attrs, id, ctx)
-    }
-
-    #[inline]
-    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
-        self.deref().register_callsite(metadata)
-    }
-
-    #[inline]
-    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
-        self.deref().enabled(metadata, ctx)
-    }
-
-    #[inline]
-    fn max_level_hint(&self) -> Option<LevelFilter> {
-        self.deref().max_level_hint()
-    }
-
-    #[inline]
-    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
-        self.deref().on_record(span, values, ctx)
-    }
-
-    #[inline]
-    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_follows_from(span, follows, ctx)
-    }
-
-    #[inline]
-    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
-        self.deref().on_event(event, ctx)
-    }
-
-    #[inline]
-    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_enter(id, ctx)
-    }
-
-    #[inline]
-    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_exit(id, ctx)
-    }
-
-    #[inline]
-    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
-        self.deref().on_close(id, ctx)
-    }
-
-    #[inline]
-    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
-        self.deref().on_id_change(old, new, ctx)
-    }
-
-    #[doc(hidden)]
-    #[inline]
-    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
-        self.deref().downcast_raw(id)
-    }
+    layer_impl_body! {}
 }
 
 impl<'a, L, S> LookupSpan<'a> for Layered<L, S>