5     layer::{Context, Layer},
17 /// [`Layer`]s.
19 /// [`Layer`]: crate::Layer
23     /// The layer.
24     layer: L,  field
26     /// The inner value that `self.layer` was layered onto.
28     /// If this is also a `Layer`, then this `Layered` will implement `Layer`.
34     // level hints when per-layer filters are in use.
41     /// Does `self.layer` have per-layer filters?
46     ///   `Layered`s have per-layer filters.
48     /// Otherwise, if it's a `Layered` with one per-layer filter in one branch,
49     /// but a non-per-layer-filtered layer in the other branch, this will be
51     /// per-layer filter `Interest`s and max level hints with its non-filtered
52     /// `Layer`.
55     /// Does `self.inner` have per-layer filters?
67     L: Layer<S>,
91     L: Layer<S>,
95         self.pick_interest(self.layer.register_callsite(metadata), || {  in register_callsite()
101         if self.layer.enabled(metadata, self.ctx()) {  in enabled()
102             // if the outer layer enables the callsite metadata, ask the subscriber.  in enabled()
105             // otherwise, the callsite is disabled by the layer  in enabled()
107             // If per-layer filters are in use, and we are short-circuiting  in enabled()
109             // per-layer filter `enabled` state.  in enabled()
119             self.layer.max_level_hint(),  in max_level_hint()
127         self.layer.on_new_span(span, &id, self.ctx());  in new_span()
133         self.layer.on_record(span, values, self.ctx());  in record()
138         self.layer.on_follows_from(span, follows, self.ctx());  in record_follows_from()
142         if self.layer.event_enabled(event, self.ctx()) {  in event_enabled()
143             // if the outer layer enables the event, ask the inner subscriber.  in event_enabled()
146             // otherwise, the event is disabled by this layer  in event_enabled()
153         self.layer.on_event(event, self.ctx());  in event()
158         self.layer.on_enter(span, self.ctx());  in enter()
163         self.layer.on_exit(span, self.ctx());  in exit()
169             self.layer.on_id_change(old, &new, self.ctx())  in clone_span()
196             self.layer.on_close(id, self.ctx());  in try_close()
210         // Unlike the implementation of `Layer` for `Layered`, we don't have to  in downcast_raw()
213         // going to contain something that doesn't have per-layer filters (the  in downcast_raw()
216         // `Interest`/level hint, even if it includes a `Layer` that has  in downcast_raw()
217         // per-layer filters, because it will only ever contain layers where  in downcast_raw()
218         // _one_ child has per-layer filters.  in downcast_raw()
220         // The complex per-layer filter detection logic is only relevant to  in downcast_raw()
221         // *trees* of layers, which involve the `Layer` implementation for  in downcast_raw()
228         // `Layer`).  in downcast_raw()
235         self.layer  in downcast_raw()
241 impl<S, A, B> Layer<S> for Layered<A, B, S>
243     A: Layer<S>,
244     B: Layer<S>,
248         self.layer.on_register_dispatch(subscriber);  in on_register_dispatch()
253         self.layer.on_layer(subscriber);  in on_layer()
258         self.pick_interest(self.layer.register_callsite(metadata), || {  in register_callsite()
264         if self.layer.enabled(metadata, ctx.clone()) {  in enabled()
265             // if the outer subscriber enables the callsite metadata, ask the inner layer.  in enabled()
268             // otherwise, the callsite is disabled by this layer  in enabled()
275             self.layer.max_level_hint(),  in max_level_hint()
284         self.layer.on_new_span(attrs, id, ctx);  in on_new_span()
290         self.layer.on_record(span, values, ctx);  in on_record()
296         self.layer.on_follows_from(span, follows, ctx);  in on_follows_from()
301         if self.layer.event_enabled(event, ctx.clone()) {  in event_enabled()
302             // if the outer layer enables the event, ask the inner subscriber.  in event_enabled()
305             // otherwise, the event is disabled by this layer  in event_enabled()
313         self.layer.on_event(event, ctx);  in on_event()
319         self.layer.on_enter(id, ctx);  in on_enter()
325         self.layer.on_exit(id, ctx);  in on_exit()
331         self.layer.on_close(id, ctx);  in on_close()
337         self.layer.on_id_change(old, new, ctx);  in on_id_change()
346             // Oh, we're looking for per-layer filters!  in downcast_raw()
353             // "per-layer filtered" if *both* the outer layer and the inner  in downcast_raw()
354             // layer/subscriber have per-layer filters. Otherwise, this `Layered  in downcast_raw()
355             // should *not* be considered per-layer filtered (even if one or the  in downcast_raw()
356             // other has per layer filters). If only one `Layer` is per-layer  in downcast_raw()
359             // aggregate (which is the value from the &non-per-layer-filtered*  in downcast_raw()
364             // `Layered`s where one side is per-layer filtered and the other  in downcast_raw()
367             // the non-per-layer-filtered layers, since both branches would  in downcast_raw()
373                 self.layer.downcast_raw(id).and(self.inner.downcast_raw(id))  in downcast_raw()
378                 .layer  in downcast_raw()
412     A: Layer<S>,
415     pub(super) fn new(layer: A, inner: B, inner_has_layer_filter: bool) -> Self {  in new()
423         let has_layer_filter = filter::layer_has_plf(&layer);  in new()
425             layer,  in new()
439         // If the outer layer has disabled the callsite, return now so that  in pick_interest()
440         // the inner layer/subscriber doesn't get its hopes up.  in pick_interest()
442             // If per-layer filters are in use, and we are short-circuiting  in pick_interest()
444             // per-layer filter interest state.  in pick_interest()
453         // informed that the callsite exists regardless of the outer layer's  in pick_interest()
462         // If there is a per-layer filter in the `inner` stack, and it returns  in pick_interest()
464         // layer didn't return `never`. This means that _some_ layer still wants  in pick_interest()
465         // to see that callsite, even though the inner stack's per-layer filter  in pick_interest()
467         // `enabled` is called so that the per-layer filter can skip that  in pick_interest()
468         // span/event, while the `outer` layer still gets to see it.  in pick_interest()
499         // If the layer is `Option::None`, then we  in pick_level_hint()
500         // want to short-circuit the layer underneath, if it  in pick_level_hint()
501         // returns `None`, to override the `None` layer returning  in pick_level_hint()
508         // we check for per-layer filters, which  in pick_level_hint()
514         if super::layer_is_none(&self.layer) {  in pick_level_hint()
518         // Similarly, if the layer on the inside is `None` and it returned an  in pick_level_hint()
550         s.field("layer", &self.layer)  in fmt()