Reinitialize / reset default tracing_subscriber::fmt max level

[alcroito]

Hi,

I'm trying to port my project from using the log crate to tracing + tracing_subscriber::fmt.

I would like to first initialise the global formatting subscriber with_max_level(Level::TRACE), run a bit of code, and then reinitialize (switch the max level) to Level::INFO.

According to https://docs.rs/tracing/latest/tracing/dispatcher/fn.set_global_default.html a global subscriber / dispatcher can only be set once, and it doesn't look like there's a way to reconfigure the created dispatcher (at least from my search attempts).

With log, I was able to set a different logging destination / backend using the https://docs.rs/log-reroute/latest/log_reroute/
crate.

Is it possible to achieve the same somehow with the tracing crate?

[hawkw]

You can use the reload layer in tracing-subscriber to dynamically rebuild some or all of a global subscriber at runtime. This is similar to log, where the logger can only be set a single time, but specific implementations of that global logger/subscriber (e.g. log_reroute) allow changing its behavior after it's set.

In the specific use-case you described here, though, it's possible there are other solutions that might be nicer:

I would like to first initialise the global formatting subscriber with_max_level(Level::TRACE), run a bit of code, and then reinitialize (switch the max level) to Level::INFO.

Rather than setting the max level to TRACE, running some code, and then changing the max level to INFO, I wonder if the goal you're trying to accomplish might be better served by using more granular filtering than just a max level, such as the EnvFilter type provided by tracing-subscriber. If there's particular code that you want to collect more verbose traces from, you might consider whether you can achieve this by configuring a filter that enables the TRACE level for that code's target/module path, and INFO for everything else. Alternatively, you could consider having that code run inside of a tracing span for which the more verbose level is enabled.

This would be more idiomatic than just changing the max level for the duration of some of your code. Using this kind of filtering is a much more flexible tool for controlling what diagnostics are collected from different parts of your code. This also includes setting different filter configurations at runtime based on an environment variable or command-line arguments, which can be useful if you want to debug a particular issue or understand a particular code path without always enabling the most verbose diagnostics every time your program runs.

However, the reload layer I mentioned above is still a useful tool in combination with a more advanced filter. For example, you could use reload to dynamically change the filter configuration at runtime. Also, you could implement similar functionality to log-reroute, where the location your program outputs formatted traces to can be changed at runtime.

Hope that helps! Let me know if you have any follow-up questions? :)

[alcroito]

Thank you for your thorough reply!

Indeed, the suggested granular filtering approach might be better suited for my use case. I will spend some time researching both approaches.

For anyone curious, my use case is to enable verbose logging for a piece of code that tries to find and load a application config file, and then set the max log level according to what's in the the config file.

[alcroito]

So I investigated the proposed options, and as far as i can tell i have to rely on reload rather than separate (filtering) layers, because the decision of what max level to set comes from run time, at some point after I have to log some events.

In case it helps anyone, here's the code I ended up with.
I'll switch out log::LevelFilter to the tracing equivalent after I port my code base.

use anyhow::{Context, Result};
use once_cell::sync::OnceCell;
use tracing_log::AsTrace;
use tracing_subscriber::{filter, fmt, prelude::*, reload, Registry};

static TRACING_FILTER_RELOAD_HANDLE: OnceCell<reload::Handle<filter::LevelFilter, Registry>> =
    OnceCell::new();

pub fn setup_early_logger() -> Result<()> {
    // Initialize tracing_suscriber with the default formatter and a runtime modifiable filter.
    // Set the max level to TRACE, to log which log file is found.
    // Store the reloadable filter handle in a static variable, which will be used to set the
    // final logging level after the config file is loded.
    let filter = filter::LevelFilter::TRACE;
    let (filter, reload_handle) = reload::Layer::new(filter);
    tracing_subscriber::registry()
        .with(filter)
        .with(fmt::Layer::default())
        .init();
    TRACING_FILTER_RELOAD_HANDLE
        .set(reload_handle)
        .map_err(|_| anyhow::anyhow!("Could not save tracing filter reload handle"))
}

pub fn setup_logger(log_level: &log::LevelFilter) -> Result<()> {
    // Set the logging level that was read from the config file.
    TRACING_FILTER_RELOAD_HANDLE
        .get()
        .ok_or_else(|| anyhow::anyhow!("Could not load tracing filtering reload handle"))?
        .modify(|filter| *filter = log_level.as_trace())
        .map_err(|e| anyhow::anyhow!(e))
        .context("Could not modify the global tracing filter")
}