Struct RotatingFileSink 

pub struct RotatingFileSink { /* private fields */ }

A sink with a file as the target, split files according to the rotation policy.

A service program running for a long time may continuously write logs to a single file, which makes the logs hard to view and manage. RotatingFileSink is designed for this usage scenario. It automatically splits logs into one or more files and can be configured to automatically delete old files to save disk space. The operation of splitting logs into multiple files and optionally deleting old files is called rotation. The rotation policy determines when and how log files are created or deleted.

Examples

See ./examples directory.

Implementations

impl RotatingFileSink

pub fn builder() -> RotatingFileSinkBuilder<(), ()>

Gets a builder of RotatingFileSink with default parameters:

Parameter	Default Value
level_filter	LevelFilter::All
formatter	FullFormatter
error_handler	ErrorHandler::default()
base_path	must be specified
rotation_policy	must be specified
max_files	0
rotate_on_open	false
capacity	consistent with std

Examples found in repository

examples/02-file.rs (line 33)

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 new<P>( base_path: P, rotation_policy: RotationPolicy, max_files: usize, rotate_on_open: bool, ) -> Result<Self>

where P: Into<PathBuf>,

👎Deprecated since 0.3.0: it may be removed in the future, use RotatingFileSink::builder() instead

Constructs a RotatingFileSink.

The parameter max_files 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. Pass 0 for no limit.

The parameter rotate_on_open 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.

Error

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

Panics

Panics if the parameter rotation_policy is invalid. See the documentation of RotationPolicy for requirements.

Trait Implementations

impl Drop for RotatingFileSink

fn drop(&mut self)

Executes the destructor for this type.

impl GetSinkProp for RotatingFileSink

fn prop(&self) -> &SinkProp

Gets the SinkProp from a sink.

impl Sink for RotatingFileSink

fn log(&self, record: &Record<'_>) -> Result<()>

Logs a record.

fn flush(&self) -> Result<()>

Flushes any buffered records.

fn should_log(&self, level: Level) -> bool

Determines if a log message with the specified level would be logged.

fn flush_on_exit(&self) -> Result<()>

Flushes any buffered records at program exit.