Current function name of a log record?

[swsnr]

The systemd journal supports three standard fields for the code location of a log message:

In a systemd logger we can easily fill CODE_FILE and CODE_LINE from record.file() and record.line() respectively, but what about CODE_FUNCTION?

The record API doesn't have a corresponding field, and it looks as if Rust currently doesn't have a way to get the function name 😕

Is there any other means to get hold of the name of the function? It's not that important, but when it comes to logging the more information we have the better, and I think it'd be helpful to find the source of a log message even if you don't have the source code of the exact version at hands (e.g. in case a function got moved to another module).

[KodrAus]

Hi @lunaryorn 👋

Unfortunately without some direct support from standard library this probably isn't something we'll be able to offer directly in log.

There are other approaches that libraries like tracing do with attribute macros on functions that would have visibility of the function name, but we haven't considered supporting alternative macros directly in log. Since there's unfortunately nothing really actionable here I'll go ahead and close this one now, but we can revisit in the future if a solution opens up.

[kanashimia]

Hello @KodrAus, you can actually get the name of the current function using std::any::type_name.
As an example:

macro_rules! current_type_name {
    () => {{
        struct T;
        std::any::type_name::<T>()
            .trim_start_matches(concat!(module_path!(), "::"))
            .trim_end_matches("::T")
    }};
}

It is a hack, but it works.
There will be suffixes like ::{{closure}} or ::{{constant}} if it is called in a const block or a closure.

I think we need to at least wait for std::any::type_name to become const stable before actually having this as a feature,
but we can at least experiment with it now, as it is available on nightly.
Making this work in const contexts is very painful though.

User can already combine this with the kv feature of log to write a logger that will emit function names.
Or by customizing target:

macro_rules! make_log_funcs {
    ($d:tt, $($name:ident),*$(,)?) => {
        $(
            #[macro_export]
            macro_rules! $name {
                ($d($d tt:tt)*) => {
                    log::$name!(target: func_name!(), $d($d tt)*)
                }
            }
        )*
    };
}

make_log_funcs![$, error, warn, info, debug, trace];

Are you ok with having this as an experimental feature? I'm willing to implement it.