Struct FileSink 

pub struct FileSink { /* private fields */ }

Synchronous bounded JSONL sink; callers choose it only outside hot paths.

Implementations

impl FileSink

pub fn new(config: FileSinkConfig) -> Result<Self, LogError>

Creates a sink after validating nonzero size and bounded retention.

Examples found in repository

examples/async_file.rs (lines 24-30)

fn main() -> Result<(), LogError> {
    let directory = std::path::PathBuf::from("target/appcore-log-example");
    std::fs::create_dir_all(&directory).map_err(|_| LogError::Io)?;

    let path = directory.join("async.jsonl");
    let file = Arc::new(FileSink::new(FileSinkConfig {
        path: path.clone(),
        max_bytes: LOG_SIZE_8_MIB,
        sync_each_write: true,
        retention: 2,
        archive: None,
    })?);

    // This queue retains at most 256 events and 1 MiB, including active I/O.
    let asynchronous = Arc::new(AsyncSink::new(
        AsyncSinkConfig {
            max_events: 256,
            max_bytes: 1024 * 1024,
        },
        file,
    )?);
    let dispatcher = LogDispatcher::new(LogPolicy::default(), vec![asynchronous.clone()]);
    let log = dispatcher.event(0, "application");

    log.info("application started");
    log.warn("storage response is slow");

    // The lifecycle owner drains durable writes before exiting.
    asynchronous.shutdown()?;
    let path = std::fs::canonicalize(path).map_err(|_| LogError::Io)?;
    println!("log written to {}", path.display());
    Ok(())
}

Trait Implementations

impl LogSink for FileSink

fn emit(&self, event: &LogEvent) -> Result<(), LogError>

Writes one event or reports a controlled failure.

fn name(&self) -> &'static str

Stable bounded metric label for this sink implementation.

fn accepts_sensitive(&self) -> bool

Reports whether this sink is an explicitly encrypted sensitive boundary.