How to Manage Complex Type with tracing_subscriber::reload::Handle

[lanyeeee]

When using tracing_subscriber::reload::Handle, the type can become extremely complex
The type complexity increases based on the order of layer registration

How to properly store and use tracing_subscriber::reload::Handle for dynamic log file reloading?

Reloadable layer registered before the console layer:

Handle<Layer<Layered<Targets, Registry, Registry>, DefaultFields, Format<Full, LocalTime<Rfc3339>>, NonBlocking>, Layered<Targets, Registry, Registry>>

Reloadable layer registered after the console layer:

Handle<Layer<Layered<Layer<Layered<Targets, Registry, Registry>, DefaultFields, Format<Full, LocalTime<Rfc3339>>, fn() -> Stdout {stdout}>, Layered<Targets, Registry, Registry>, Layered<Targets, Registry, Registry>>, DefaultFields, Format<Full, LocalTime<Rfc3339>>, NonBlocking>, Layered<Layer<Layered<Targets, Registry, Registry>, DefaultFields, Format<Full, LocalTime<Rfc3339>>, fn() -> Stdout {stdout}>, Layered<Targets, Registry, Registry>, Layered<Targets, Registry, Registry>>>

Code(Reloadable layer registered before the console layer)

use std::sync::{Mutex, OnceLock};
use std::thread::sleep;
use std::time::Duration;
use time::format_description::well_known::Rfc3339;
use tracing::Level;
use tracing_appender::non_blocking::{NonBlocking, WorkerGuard};
use tracing_appender::rolling::{RollingFileAppender, Rotation};
use tracing_subscriber::filter::Targets;
use tracing_subscriber::fmt::format::{DefaultFields, Format, Full};
use tracing_subscriber::fmt::layer;
use tracing_subscriber::fmt::time::LocalTime;
use tracing_subscriber::layer::{Layered, SubscriberExt};
use tracing_subscriber::reload::Handle;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{reload, Registry};

const LOGS_DIR: &str = "logs";

type FileLayer = tracing_subscriber::fmt::Layer<
    Layered<Targets, Registry, Registry>,
    DefaultFields,
    Format<Full, LocalTime<Rfc3339>>,
    NonBlocking,
>;

type FileReloadHandle = Handle<FileLayer, Layered<Targets, Registry, Registry>>;

struct FileLogController {
    reload_handle: FileReloadHandle,
    guard: WorkerGuard,
}

static FILE_LOG_CONTROLLER: OnceLock<Mutex<FileLogController>> = OnceLock::new();

impl FileLogController {
    pub fn reload(&mut self) -> anyhow::Result<()> {
        let file_appender = RollingFileAppender::builder()
            .filename_prefix("reload")
            .filename_suffix("log")
            .rotation(Rotation::DAILY)
            .build(LOGS_DIR)?;
        let (non_blocking_appender, guard) = tracing_appender::non_blocking(file_appender);
        let file_layer = layer()
            .with_writer(non_blocking_appender)
            .with_timer(LocalTime::rfc_3339())
            .with_ansi(false)
            .with_file(true)
            .with_line_number(true);
        self.reload_handle.reload(file_layer)?;
        self.guard = guard;
        Ok(())
    }
}

fn reload_file_log() {
    FILE_LOG_CONTROLLER
        .get()
        .unwrap()
        .lock()
        .unwrap()
        .reload()
        .unwrap();
}

fn main() -> anyhow::Result<()> {
    let lib_module_path = module_path!();
    let lib_target = lib_module_path.split("::").next().unwrap();

    let target_filter = Targets::new().with_target(lib_target, Level::TRACE);

    let console_layer = layer()
        .with_writer(std::io::stdout)
        .with_timer(LocalTime::rfc_3339())
        .with_file(true)
        .with_line_number(true);

    let file_appender = RollingFileAppender::builder()
        .filename_prefix("main")
        .filename_suffix("log")
        .rotation(Rotation::DAILY)
        .build(LOGS_DIR)?;
    let (non_blocking_appender, guard) = tracing_appender::non_blocking(file_appender);
    let file_layer = layer()
        .with_writer(non_blocking_appender)
        .with_timer(LocalTime::rfc_3339())
        .with_ansi(false)
        .with_file(true)
        .with_line_number(true);
    let (reloadable_file_layer, reload_handle) = reload::Layer::new(file_layer);

    Registry::default()
        .with(target_filter)
        .with(reloadable_file_layer)
        .with(console_layer)
        .init();

    FILE_LOG_CONTROLLER.get_or_init(|| {
        Mutex::new(FileLogController {
            reload_handle,
            guard,
        })
    });

    std::thread::spawn(|| {
        sleep(Duration::from_secs(5));
        reload_file_log()
    });

    for i in 0..10 {
        tracing::info!("hello {}", i);
        sleep(Duration::from_secs(1));
    }

    Ok(())
}

Did I do something wrong?

[lanyeeee]

I tried using a callback function to reload, it worked, but doesn't feel very elegant.

use std::sync::{Mutex, OnceLock};
use std::thread::sleep;
use std::time::Duration;
use tracing::Level;
use tracing_appender::non_blocking::WorkerGuard;
use tracing_appender::rolling::{RollingFileAppender, Rotation};
use tracing_subscriber::filter::Targets;
use tracing_subscriber::fmt::layer;
use tracing_subscriber::fmt::time::LocalTime;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;
use tracing_subscriber::{reload, Layer, Registry};

const LOGS_DIR: &str = "logs";

static RELOAD_FN: OnceLock<Box<dyn Fn() + Send + Sync>> = OnceLock::new();
static GUARD: OnceLock<Mutex<WorkerGuard>> = OnceLock::new();

fn reload_file_log() {
    RELOAD_FN.get().unwrap()();
}

fn main() -> anyhow::Result<()> {
    let lib_module_path = module_path!();
    let lib_target = lib_module_path.split("::").next().unwrap();

    let target_filter = Targets::new().with_target(lib_target, Level::TRACE);

    let console_layer = layer()
        .with_writer(std::io::stdout)
        .with_timer(LocalTime::rfc_3339())
        .with_file(true)
        .with_line_number(true)
        .boxed();

    let file_appender = RollingFileAppender::builder()
        .filename_prefix("main")
        .filename_suffix("log")
        .rotation(Rotation::DAILY)
        .build(LOGS_DIR)?;
    let (non_blocking_appender, guard) = tracing_appender::non_blocking(file_appender);
    GUARD.get_or_init(move || Mutex::new(guard));
    let file_layer = layer()
        .with_writer(non_blocking_appender)
        .with_timer(LocalTime::rfc_3339())
        .with_ansi(false)
        .with_file(true)
        .with_line_number(true)
        .boxed();
    let (reloadable_file_layer, reload_handle) = reload::Layer::new(file_layer);

    Registry::default()
        .with(target_filter)
        .with(console_layer)
        .with(reloadable_file_layer)
        .init();

    RELOAD_FN.get_or_init(move || {
        Box::new(move || {
            let file_appender = RollingFileAppender::builder()
                .filename_prefix("reload")
                .filename_suffix("log")
                .rotation(Rotation::DAILY)
                .build(LOGS_DIR)
                .unwrap();
            let (non_blocking_appender, guard) = tracing_appender::non_blocking(file_appender);
            let file_layer = layer()
                .with_writer(non_blocking_appender)
                .with_timer(LocalTime::rfc_3339())
                .with_ansi(false)
                .with_file(true)
                .with_line_number(true)
                .boxed();
            reload_handle.reload(file_layer).unwrap();
            *GUARD.get().unwrap().lock().unwrap() = guard;
        })
    });

    std::thread::spawn(|| {
        sleep(Duration::from_secs(5));
        reload_file_log()
    });

    for i in 0..10 {
        tracing::info!("hello {}", i);
        sleep(Duration::from_secs(1));
    }

    Ok(())
}