Struct RotatingFileSinkBuilder 

pub struct RotatingFileSinkBuilder<ArgBP, ArgRP> { /* private fields */ }

Note

The generics here are designed to check for required fields at compile time, users should not specify them manually and/or depend on them. If the generic concrete types or the number of generic types are changed in the future, it may not be considered as a breaking change.

Implementations

impl<ArgBP, ArgRP> RotatingFileSinkBuilder<ArgBP, ArgRP>

pub fn base_path<P>( self, base_path: P, ) -> RotatingFileSinkBuilder<PathBuf, ArgRP>

where P: Into<PathBuf>,

Specifies the base path of the log file.

The path needs to be suffixed with an extension, if you expect the rotated eventual file names to contain the extension.

If there is an extension, the different rotation policies will insert relevant information in the front of the extension. If there is not an extension, it will be appended to the end.

Supposes the given base path is /path/to/base_file.log, the eventual file names may look like the following:

• /path/to/base_file_1.log
• /path/to/base_file_2.log
• /path/to/base_file_2022-03-23.log
• /path/to/base_file_2022-03-24.log
• /path/to/base_file_2022-03-23_03.log
• /path/to/base_file_2022-03-23_04.log

This parameter is required.

Examples found in repository

examples/02-file.rs (line 34)

fn configure_rotating_daily_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_daily.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Daily { hour: 0, minute: 0 })
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_daily.log`, and the file will be rotated daily at 00:00");

    Ok(())
}

fn configure_rotating_size_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_size.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::FileSize(1024))
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_size.log`, and the file will be rotated when its size reaches 1024 bytes");

    Ok(())
}

fn configure_rotating_hourly_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_hourly.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Hourly)
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_hourly.log`, and the file will be rotated every hour");

    Ok(())
}

fn configure_rotating_period_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_period.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Period(Duration::from_secs(
            60 * 90, // 90 minutes
        )))
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_period.log`, and the file will be rotated every 1.5 hours");

    Ok(())
}

pub fn rotation_policy( self, rotation_policy: RotationPolicy, ) -> RotatingFileSinkBuilder<ArgBP, RotationPolicy>

Specifies the rotation policy.

This parameter is required.

Examples found in repository

examples/02-file.rs (line 35)

fn configure_rotating_daily_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_daily.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Daily { hour: 0, minute: 0 })
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_daily.log`, and the file will be rotated daily at 00:00");

    Ok(())
}

fn configure_rotating_size_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_size.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::FileSize(1024))
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_size.log`, and the file will be rotated when its size reaches 1024 bytes");

    Ok(())
}

fn configure_rotating_hourly_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_hourly.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Hourly)
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_hourly.log`, and the file will be rotated every hour");

    Ok(())
}

fn configure_rotating_period_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_period.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Period(Duration::from_secs(
            60 * 90, // 90 minutes
        )))
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_period.log`, and the file will be rotated every 1.5 hours");

    Ok(())
}

pub fn max_files(self, max_files: usize) -> Self

Specifies the maximum number of files.

If the number of existing files reaches this parameter, the oldest file will be deleted on the next rotation.

Specify 0 for no limit.

This parameter is optional, and defaults to 0.

pub fn rotate_on_open(self, rotate_on_open: bool) -> Self

Specifies whether to rotate files once when constructing RotatingFileSink.

For the RotationPolicy::Daily, RotationPolicy::Hourly, and RotationPolicy::Period rotation policies, it may truncate the contents of the existing file if the parameter is true, since the file name is a time point and not an index.

This parameter is optional, and defaults to false.

pub fn capacity(self, capacity: usize) -> Self

Specifies the internal buffer capacity.

This parameter is optional, and defaults to the value consistent with std.

pub fn level_filter(self, level_filter: LevelFilter) -> Self

Specifies a log level filter.

This parameter is optional, and defaults to LevelFilter::All.

pub fn formatter<F>(self, formatter: F) -> Self

where F: Formatter + 'static,

Specifies a formatter.

This parameter is optional, and defaults to FullFormatter.

pub fn error_handler<F: Into<ErrorHandler>>(self, handler: F) -> Self

Specifies an error handler.

This parameter is optional, and defaults to ErrorHandler::default().

impl RotatingFileSinkBuilder<PathBuf, RotationPolicy>

pub fn build(self) -> Result<RotatingFileSink>

Builds a RotatingFileSink.

Error

If the argument rotation_policy is invalid, or an error occurs opening the file, Error::CreateDirectory or Error::OpenFile will be returned.

pub fn build_arc(self) -> Result<Arc<RotatingFileSink>>

Builds a Arc<RotatingFileSink>.

This is a shorthand method for .build().map(Arc::new).

Examples found in repository

examples/02-file.rs (line 36)

fn configure_rotating_daily_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_daily.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Daily { hour: 0, minute: 0 })
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_daily.log`, and the file will be rotated daily at 00:00");

    Ok(())
}

fn configure_rotating_size_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_size.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::FileSize(1024))
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_size.log`, and the file will be rotated when its size reaches 1024 bytes");

    Ok(())
}

fn configure_rotating_hourly_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_hourly.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Hourly)
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_hourly.log`, and the file will be rotated every hour");

    Ok(())
}

fn configure_rotating_period_file_logger() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("rotating_period.log");

    let file_sink = RotatingFileSink::builder()
        .base_path(path)
        .rotation_policy(RotationPolicy::Period(Duration::from_secs(
            60 * 90, // 90 minutes
        )))
        .build_arc()?;
    let new_logger = Logger::builder().sink(file_sink).build_arc()?;
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `rotating_period.log`, and the file will be rotated every 1.5 hours");

    Ok(())
}