chore(tests): Improve logging in smoke tests

Workaround until cucumber-rs/cucumber#353 gets fixed.

Author: RemiBardon

CONTRIBUTING.md

@@ -54,7 +54,12 @@ This has the added benefit of updating the version of Rust used to run the tests
 task smoke-test
 ```
 
-As explained in [ADR: Write tests with the Gherkin syntax](./ADRs/2024-01-11-a-write-tests-in-gherkin.md), we are using Gherkin and Cucumber to run the tests. Therefore, you won't be able to filter tests using `cargo test`. To do so, add a `@testing` tag to a `Feature`, `Rule` or `Scenario` (non-exhaustive) and then use `task smoke-test -- --tags '@testing'` to run only matching `Scenario`s.
+As explained in [ADR: Write tests with the Gherkin syntax](./ADRs/2024-01-11-a-write-tests-in-gherkin.md), we are using Gherkin and Cucumber to run the tests. Therefore, you won't be able to filter tests using `cargo test`. To do so, add a `@debug` tag to a `Feature`, `Rule` or `Scenario` (non-exhaustive) and then use `task smoke-test -- --tags '@debug'` to run only matching `Scenario`s.
+
+> [!TIP]
+> You will get more logs if you use `@debug`. Also, `@debug` can be used without manually
+> putting it in a feature file, like so:
+> `task smoke-test -- --tags '@dns-record-checks or @debug'`.
 
 ### Integration testing
 

crates/rest-api/tests/behavior.rs

@@ -9,42 +9,70 @@ mod prelude;
 
 use cucumber::World as _;
 use tracing_subscriber::{
-    filter::{self, LevelFilter},
-    fmt::format::{self, Format},
-    layer::{Layer, SubscriberExt as _},
+    filter::{self, FilterExt, FilterFn, LevelFilter},
+    fmt::format::{self, FmtSpan, Format},
+    layer::SubscriberExt as _,
+    Layer,
 };
 
 use crate::{prelude::*, test_world::TestWorld};
 
 #[tokio::main]
 async fn main() {
+    fn default_format<F, T>(format: Format<F, T>) -> Format<F, ()> {
+        format
+            .without_time()
+            .with_ansi(true)
+            .with_source_location(false)
+            .with_target(true)
+    }
+    #[allow(unused)]
+    fn normal<F, T>(format: Format<F, T>) -> Format<F, ()> {
+        default_format(format)
+    }
+    #[allow(unused)]
+    fn compact<F, T>(format: Format<F, T>) -> Format<format::Compact, ()> {
+        default_format(format.compact())
+    }
+    let map_format = normal;
+
     TestWorld::cucumber()
         // .init_tracing()
         .configure_and_init_tracing(
             format::DefaultFields::new(),
-            Format::default(),
+            map_format(Format::default()),
             |fmt_layer| {
                 let targets = vec![
                     ("sea_orm_migration", LevelFilter::WARN),
+                    ("sea_orm", LevelFilter::INFO),
                     ("sqlx::query", LevelFilter::ERROR),
                     ("globset", LevelFilter::WARN),
+                    ("cucumber::tracing", LevelFilter::OFF),
                 ];
 
                 let args = std::env::args().collect::<Vec<_>>();
-                let running_few_scenarios = args.contains(&"@testing".to_owned());
-                let debug = args.contains(&"@debug".to_owned());
+                let debug = args.iter().any(|s| s.contains("@debug"));
 
-                let default_level = if running_few_scenarios || debug {
+                let default_level = if debug {
                     LevelFilter::TRACE
                 } else {
                     LevelFilter::WARN
                 };
 
+                let targets_layer = filter::Targets::new()
+                    .with_default(default_level)
+                    .with_targets(targets);
+                let span_filter =
+                    FilterFn::new(|metadata| metadata.is_span() || !metadata.fields().is_empty());
+                let event_span_layer = tracing_subscriber::fmt::layer()
+                    .map_event_format(map_format)
+                    .with_span_events(FmtSpan::CLOSE)
+                    .with_filter(span_filter.clone());
+
                 tracing_subscriber::registry().with(
-                    filter::Targets::new()
-                        .with_default(default_level)
-                        .with_targets(targets)
-                        .and_then(fmt_layer),
+                    targets_layer
+                        .and_then(event_span_layer)
+                        .and_then(fmt_layer.with_filter(span_filter.not())),
                 )
             },
         )