1 files changed, 70 insertions, 0 deletions
diff --git a/tests/filters_are_not_reevaluated_for_the_same_span.rs b/tests/filters_are_not_reevaluated_for_the_same_span.rs
new file mode 100644
index 0000000..e9b2529
--- /dev/null
+++ b/tests/filters_are_not_reevaluated_for_the_same_span.rs
@@ -0,0 +1,70 @@
+// Tests that depend on a count of the number of times their filter is evaluated
+// cant exist in the same file with other tests that add subscribers to the
+// registry. The registry was changed so that each time a new dispatcher is
+// added all filters are re-evaluated. The tests being run only in separate
+// threads with shared global state lets them interfere with each other
+#[cfg(not(feature = "std"))]
+extern crate std;
+
+use tracing::{span, Level};
+use tracing_mock::*;
+
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc,
+};
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn filters_are_not_reevaluated_for_the_same_span() {
+    // Asserts that the `span!` macro caches the result of calling
+    // `Subscriber::enabled` for each span.
+    let alice_count = Arc::new(AtomicUsize::new(0));
+    let bob_count = Arc::new(AtomicUsize::new(0));
+    let alice_count2 = alice_count.clone();
+    let bob_count2 = bob_count.clone();
+
+    let (subscriber, handle) = subscriber::mock()
+        .with_filter(move |meta| match meta.name() {
+            "alice" => {
+                alice_count2.fetch_add(1, Ordering::Relaxed);
+                false
+            }
+            "bob" => {
+                bob_count2.fetch_add(1, Ordering::Relaxed);
+                true
+            }
+            _ => false,
+        })
+        .run_with_handle();
+
+    // Since this test is in its own file anyway, we can do this. Thus, this
+    // test will work even with no-std.
+    tracing::subscriber::set_global_default(subscriber).unwrap();
+
+    // Enter "alice" and then "bob". The dispatcher expects to see "bob" but
+    // not "alice."
+    let alice = span!(Level::TRACE, "alice");
+    let bob = alice.in_scope(|| {
+        let bob = span!(Level::TRACE, "bob");
+        bob.in_scope(|| ());
+        bob
+    });
+
+    // The filter should have seen each span a single time.
+    assert_eq!(alice_count.load(Ordering::Relaxed), 1);
+    assert_eq!(bob_count.load(Ordering::Relaxed), 1);
+
+    alice.in_scope(|| bob.in_scope(|| {}));
+
+    // The subscriber should see "bob" again, but the filter should not have
+    // been called.
+    assert_eq!(alice_count.load(Ordering::Relaxed), 1);
+    assert_eq!(bob_count.load(Ordering::Relaxed), 1);
+
+    bob.in_scope(|| {});
+    assert_eq!(alice_count.load(Ordering::Relaxed), 1);
+    assert_eq!(bob_count.load(Ordering::Relaxed), 1);
+
+    handle.assert_finished();
+}