Forward Filtered::downcast_raw to wrapped Layer

tracing-subscriber/src/filter/layer_filters.rs

@@ -386,7 +386,7 @@ where
             id if id == TypeId::of::<MagicPlfDowncastMarker>() => {
                 Some(&self.id as *const _ as *const ())
             }
-            _ => None,
+            _ => self.layer.downcast_raw(id),
         }
     }
 }

tracing-subscriber/tests/layer_filters/downcast_raw.rs

@@ -0,0 +1,68 @@
+use tracing::Subscriber;
+use tracing_subscriber::filter::Targets;
+use tracing_subscriber::prelude::*;
+use tracing_subscriber::Layer;
+
+#[test]
+fn downcast_ref_to_inner_layer_and_filter() {
+    // Test that a filtered layer gives downcast_ref access to
+    // both the layer and the filter.
+
+    struct WrappedLayer;
+
+    impl<S> Layer<S> for WrappedLayer
+    where
+        S: Subscriber,
+        S: for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
+    {
+    }
+
+    let layer = WrappedLayer;
+    let filter = Targets::new().with_default(tracing::Level::INFO);
+    let registry = tracing_subscriber::registry().with(layer.with_filter(filter));
+    let dispatch = tracing::dispatcher::Dispatch::new(registry);
+
+    // The filter is available
+    assert!(dispatch.downcast_ref::<Targets>().is_some());
+    // The wrapped layer is available
+    assert!(dispatch.downcast_ref::<WrappedLayer>().is_some());
+}
+
+#[test]
+fn forward_downcast_raw_to_layer() {
+    // Test that a filtered layer still gives its wrapped layer a chance to
+    // return a custom struct from downcast_raw.
+    // https://github.com/tokio-rs/tracing/issues/1618
+
+    struct WrappedLayer {
+        with_context: WithContext,
+    }
+
+    struct WithContext;
+
+    impl<S> Layer<S> for WrappedLayer
+    where
+        S: Subscriber,
+        S: for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
+    {
+        unsafe fn downcast_raw(&self, id: std::any::TypeId) -> Option<*const ()> {
+            match id {
+                id if id == std::any::TypeId::of::<Self>() => Some(self as *const _ as *const ()),
+                id if id == std::any::TypeId::of::<WithContext>() => {
+                    Some(&self.with_context as *const _ as *const ())
+                }
+                _ => None,
+            }
+        }
+    }
+
+    let layer = WrappedLayer {
+        with_context: WithContext,
+    };
+    let filter = Targets::new().with_default(tracing::Level::INFO);
+    let registry = tracing_subscriber::registry().with(layer.with_filter(filter));
+    let dispatch = tracing::dispatcher::Dispatch::new(registry);
+
+    // Types from a custom implementation of `downcast_raw` are available
+    assert!(dispatch.downcast_ref::<WithContext>().is_some());
+}

tracing-subscriber/tests/layer_filters/main.rs

@@ -3,6 +3,7 @@
 mod support;
 use self::support::*;
 mod boxed;
+mod downcast_raw;
 mod filter_scopes;
 mod targets;
 mod trees;