tracing: generate macro tests

There are a large number of combinations of field types which currently
are not matched by the level event macros (e.g. `info!`).

Some recent examples from #3407 is the following that doesn't work:

```rust
info!(name: "order.received.ok", order.id = 123, "order received");
```

However, the corresponding `event!` macro does work:

```rust
event!(name: "order.received.ok", Level::INFO, order.id = 123, "order received");
```

And other variants also work:

```rust
// Without `name:` directive
info!(order.id = 123, "order received");

// With another field before the dotted one
info!(name: "order.received.ok", foo = true, order.id = 123, "order received");
```

Many such cases have been fixed in the past (#2983, #2883, #2879).
However, this has been a bit like wack-a-mole, where we keep finding
issues and then fixing those issues, adding extra tests for them and
then going on our way.

Since the complexity is often in combinations (as above, only when using
the `name:` directive together with a dotted field name on the first
field), it would be useful to have some extensive tests that attempt to
cover all possible combinations.

It turns out that there are **a lot** of combiantions.

This change adds an `xtask` that generates tests for event macros (span
macros are out of scope for this change) similar to the ones found in
`tracing/tests/macros.rs`. Which is to say, tests containing macros
which should compile, but don't need to run.

Owing to the large number of combinations, the tests are split into test
files by macro (e.g. `event!`, `info!`) and directive combination (e.g.
no directives, just `name:`, `name:` and `target:`). The tests are kept
in a separate crate outside the main workspace to avoid rust-analyzer
trying to parse the files - as they are quite large. Specifically, there
are 1220 macro invocations per test file.

When run against the unmodified macros in `tracing`, there were 504
`info!` macro invocations which failed to compile, out of a total of
9760 (including all combinations of directives).

The test files are generated (no need to check them in) and then
validated by `cargo check` on CI.

The CI job has not been made blocking because none of the errors have
been fixed yet!

Author: hds

.github/workflows/CI.yml

@@ -314,6 +314,20 @@ jobs:
     - name: "Test tracing-mock with all features enabled"
       run: cargo test --all-features -p tracing-mock
 
+  check-tracing-macros-stable:
+    # Feature flag tests that run on stable Rust.
+    name: cargo check (tracing macros)
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@stable
+    - name: "Generate macro tests"
+      run: cargo run --bin xtask -- gen-macro-tests
+    - name: "Test static max level"
+      run: cargo check --tests
+      working-directory: "tracing/test_macros"
+
   # all required checks except for the main test run (which we only require
   # specific matrix combinations from)
   all_required:
@@ -326,5 +340,6 @@ jobs:
       - test-build-wasm
       - test-wasm
       - test-features-stable
+      - check-tracing-macros-stable
     steps:
       - run: exit 0

Cargo.toml

@@ -16,7 +16,8 @@ members = [
     "tracing-test",
     "tracing-appender",
     "tracing-journald",
-    "examples"
+    "examples",
+    "xtask",
 ]
 
  # This will be ignored with Rust older than 1.74, but for now that's okay;

tracing/test-macros/Cargo.toml

@@ -0,0 +1,10 @@
+[workspace]
+
+[package]
+name = "test-macros"
+version = "0.1.0"
+publish = false
+edition = "2018"
+
+[dependencies]
+tracing = { path = ".." }

tracing/test-macros/tests/.gitignore

@@ -0,0 +1 @@
+*

tracing/tests/macro_imports.rs

@@ -0,0 +1,11 @@
+[package]
+name = "xtask"
+version = "0.1.0"
+edition = "2018"
+publish = false
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+
+[lints]
+workspace = true