Struct FileSink 

pub struct FileSink { /* private fields */ }

A sink with a file as the target.

It writes logs to a single file. If you want to automatically rotate into multiple files, see RotatingFileSink.

The file and directories will be created recursively if they do not exist.

Examples

See ./examples directory.

Implementations

impl FileSink

pub fn builder() -> FileSinkBuilder<()>

Gets a builder of FileSink with default parameters:

Parameter	Default Value
level_filter	LevelFilter::All
formatter	FullFormatter
error_handler	ErrorHandler::default()
path	must be specified
truncate	false
capacity	consistent with std

Examples found in repository

examples/02-file.rs (line 21)

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

    let file_sink = FileSink::builder().path(path).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 `all.log`");

    Ok(())
}

examples/07-async.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("async.log");
    let file_sink = FileSink::builder().path(path).build_arc()?;

    // AsyncPoolSink is a combined sink which wraps other sinks
    let async_pool_sink = AsyncPoolSink::builder().sink(file_sink).build_arc()?;

    let async_logger = Logger::builder()
        .sink(async_pool_sink)
        .flush_level_filter(LevelFilter::All)
        .build_arc()?;

    info!(logger: async_logger, "Hello, async!");

    Ok(())
}

examples/03-logger.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // `spdlog-rs` has a global default logger and logs will be processed by it
    // by default, You can configure it.
    let default_logger = spdlog::default_logger();
    default_logger.set_level_filter(LevelFilter::All);

    // Or completely replace it with a new one.
    let path = env::current_exe()?.with_file_name("all.log");
    let file_sink = FileSink::builder().path(path).build_arc()?;

    let new_logger = Logger::builder()
        .level_filter(LevelFilter::All)
        .flush_level_filter(LevelFilter::MoreSevereEqual(Level::Warn))
        .sink(file_sink.clone())
        .build_arc()?;
    new_logger.set_flush_period(Some(Duration::from_secs(3)));
    spdlog::set_default_logger(new_logger);

    info!("this log will be written to the file `all.log`");

    // In addition to having the global default logger, more loggers are allowed to
    // be configured, stored and used independently.
    let db = AppDatabase::new(file_sink)?;
    db.write_i32(114514);

    Ok(())
}

struct AppDatabase {
    logger: Logger,
}

impl AppDatabase {
    fn new(all_log_sink: Arc<dyn Sink>) -> Result<Self, Box<dyn std::error::Error>> {
        let path = env::current_exe()?.with_file_name("db.log");
        let db_file_sink = FileSink::builder().path(path).build_arc()?;

        let logger = Logger::builder()
            .name("database")
            .level_filter(LevelFilter::All)
            .flush_level_filter(LevelFilter::MoreSevereEqual(Level::Warn))
            .sinks([all_log_sink, db_file_sink])
            .build()?;
        Ok(Self { logger })
    }

pub fn new<P>(path: P, truncate: bool) -> Result<FileSink>

where P: AsRef<Path>,

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

Constructs a FileSink.

If the parameter truncate is true, the existing contents of the file will be discarded.

Error

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

Trait Implementations

impl Drop for FileSink

fn drop(&mut self)

Executes the destructor for this type.

impl GetSinkProp for FileSink

fn prop(&self) -> &SinkProp

Gets the SinkProp from a sink.

impl Sink for FileSink

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.