enter! macro

[yaahc]

Right now there is some mandatory boilerplate whenever using span!.

let span = span!(...);
let _something = span.enter();

It cannot be written as

span!(...).enter(); // temporary value freed at end of statement

// or

let span = span!(...);
let _ = span.enter(); // silently fails to do anything, guard is dropped immediately here

In order for it to work you must bind the span to a temporary and you must bind the guard to another ignored temporary and that cannot be _ because of rust drop semantics.

The Idea

Here enters the enter! macro.

enter!(span!(...));

which should just expand to the first example.

[hawkw]

I like the idea of having an enter! macro that takes an expression expanding to a Span, rather than taking the arguments and forwarding them to the span! macro, as it means we don't need to have enter_trace!, enter_debug!, and so on.

Should be quite easy to add a macro like this:

macro_rules! enter {
    ($span:expr) => {
        let span = $span;
        let _guard = span.enter();
    }
}

[singpolyma-shopify]

Will this expand to inline statements or to a block? (If a block, it would still drop the guard right away, yes?)

My only concern here would be "polluting" the local namespace with these two extra variables that the programmer didn't create on purpose.

[yaahc]

Aren't rust macros hygenic? I thought that their variables were inaccessible from outside of the macros scope.

[singpolyma-shopify]

@yaahallo right, that was the first part of my question. If this is rendered as a scope then the guard would be dropped right away.

[yaahc]

Ooh, my understanding of declarative macro hygiene is that tracks which identifiers came from inside a macro and disallows using those identifiers outside the macros, it does not logically add { } around the output of the macro to prevent identifiers from escaping.

https://rust-lang.github.io/rustc-guide/macro-expansion.html#hygiene

The best part is the struct in the compiler that tracks the context about where these identifiers are defined is called Span. It's turtles all the way down I guess.

[hawkw]

Will this expand to inline statements or to a block? (If a block, it would still drop the guard right away, yes?)

In order for this to provide the expected behaviour, this would have to expand to inline statements.
I don't remember OTTOMH whether macro hygiene would permit this or not; if it does not, I think tokio-rs/tokio#1162 might be the only viable solution for #192.

[yaahc]

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=e77fe2ec7e262deff89b78551c7217ce

It works fine in all the ways we need.

[hawkw]

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=e77fe2ec7e262deff89b78551c7217ce

It works fine in all the ways we need.

In that case...

[hawkw]

@yaahallo is this something you're interested in implementing?

[yaahc]

/// Macro for explicitly entering a span.
///
/// ```rust
/// use tracing_macros::enter;
/// use tracing::{span, Level};
/// let yak = 2;
/// {
///     enter!(span!(Level::ERROR, "shave", yak = yak));
///     // ... do things within the span
/// }
/// // ... do things after closing and exiting the span
/// ```
#[macro_export]
macro_rules! enter {
    ( $cmd:expr ) => {
        let span = $cmd;
        let _enter = span.enter();
    };
}