tracing: add static level tests for spans and instrumented fns (tokio…

…-rs#1872)

The current tests for the compile-time maximum level were not being run
in `--release` mode, and did not previously assert anything about
`Span`s.

This also adds some test cases for various `#[instrument]`-ed functions.

.github/workflows/check_features.yml

@@ -127,6 +127,9 @@ jobs:
     - name: "Test static max level"
       run: cargo test
       working-directory: "tracing/test_static_max_level_features"
+    - name: "Test static max level (release)"
+      run: cargo test --release
+      working-directory: "tracing/test_static_max_level_features"
     - name: "Test tracing-core no-std support"
       run: cargo test --no-default-features
       working-directory: tracing

tracing/test_static_max_level_features/Cargo.toml

@@ -15,4 +15,7 @@ tracing-core = { path = "../../tracing-core" }
 
 [dependencies.tracing]
 path = ".."
-features = ["max_level_debug", "release_max_level_info"]
+features = ["max_level_debug", "release_max_level_info"]
+
+[dev-dependencies]
+tokio-test = "0.2.0"

tracing/test_static_max_level_features/tests/test.rs

@@ -1,20 +1,37 @@
+#[path = "../../../tracing-futures/tests/support.rs"]
+// this is only needed for `block_on_future`
+#[allow(dead_code)]
+mod support;
+use support::*;
+
+use std::future::Future;
+use std::pin::Pin;
 use std::sync::{Arc, Mutex};
 use tracing::span::{Attributes, Record};
-use tracing::{debug, error, info, span, trace, warn, Collect, Event, Id, Level, Metadata};
+use tracing::{
+    debug, error, info, instrument, span, trace, warn, Collect, Event, Id, Level, Metadata,
+};
 use tracing_core::span::Current;
 
 struct State {
     last_level: Mutex<Option<Level>>,
 }
 
+const EXPECTED_DEBUG: Option<Level> = if cfg!(debug_assertions) {
+    Some(Level::DEBUG)
+} else {
+    None
+};
+
 struct TestCollector(Arc<State>);
 
 impl Collect for TestCollector {
     fn enabled(&self, _: &Metadata) -> bool {
         true
     }
 
-    fn new_span(&self, _span: &Attributes) -> Id {
+    fn new_span(&self, span: &Attributes) -> Id {
+        *self.0.last_level.lock().unwrap() = Some(span.metadata().level().clone());
         span::Id::from_u64(42)
     }
 
@@ -35,13 +52,20 @@ impl Collect for TestCollector {
     }
 }
 
+#[track_caller]
+fn last(state: &State, expected: Option<Level>) {
+    let lvl = state.last_level.lock().unwrap().take();
+    assert_eq!(lvl, expected);
+}
+
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
 #[test]
-fn test_static_max_level_features() {
+fn test_static_max_level_events() {
     let me = Arc::new(State {
         last_level: Mutex::new(None),
     });
     let a = me.clone();
+
     tracing::collect::with_default(TestCollector(me), || {
         error!("");
         last(&a, Some(Level::ERROR));
@@ -50,25 +74,73 @@ fn test_static_max_level_features() {
         info!("");
         last(&a, Some(Level::INFO));
         debug!("");
-        last(&a, Some(Level::DEBUG));
+        last(&a, EXPECTED_DEBUG);
         trace!("");
         last(&a, None);
+    });
+}
 
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn test_static_max_level_spans() {
+    let me = Arc::new(State {
+        last_level: Mutex::new(None),
+    });
+    let a = me.clone();
+
+    tracing::collect::with_default(TestCollector(me), || {
         span!(Level::ERROR, "");
-        last(&a, None);
+        last(&a, Some(Level::ERROR));
         span!(Level::WARN, "");
-        last(&a, None);
+        last(&a, Some(Level::WARN));
         span!(Level::INFO, "");
-        last(&a, None);
+        last(&a, Some(Level::INFO));
         span!(Level::DEBUG, "");
-        last(&a, None);
+        last(&a, EXPECTED_DEBUG);
         span!(Level::TRACE, "");
         last(&a, None);
     });
 }
 
-fn last(state: &State, expected: Option<Level>) {
-    let mut lvl = state.last_level.lock().unwrap();
-    assert_eq!(*lvl, expected);
-    *lvl = None;
+#[instrument(level = "debug")]
+#[inline(never)] // this makes it a bit easier to look at the asm output
+fn instrumented_fn() {}
+
+#[instrument(level = "debug")]
+async fn instrumented_async_fn() {}
+
+#[allow(clippy::manual_async_fn)]
+#[instrument(level = "debug")]
+fn instrumented_manual_async() -> impl Future<Output = ()> {
+    async move {}
+}
+
+#[instrument(level = "debug")]
+fn instrumented_manual_box_pin() -> Pin<Box<dyn Future<Output = ()>>> {
+    Box::pin(async move {})
+}
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[test]
+fn test_static_max_level_instrument() {
+    let me = Arc::new(State {
+        last_level: Mutex::new(None),
+    });
+    let a = me.clone();
+
+    tracing::collect::with_default(TestCollector(me), || {
+        block_on_future(async {
+            instrumented_fn();
+            last(&a, EXPECTED_DEBUG);
+
+            instrumented_async_fn().await;
+            last(&a, EXPECTED_DEBUG);
+
+            instrumented_manual_async().await;
+            last(&a, EXPECTED_DEBUG);
+
+            instrumented_manual_box_pin().await;
+            last(&a, EXPECTED_DEBUG);
+        })
+    });
 }