Struct AsyncSink 

pub struct AsyncSink { /* private fields */ }

Opt-in non-blocking wrapper around one sink.

emit rejects immediately with LogError::Capacity when either bound is exhausted. Call Self::flush or Self::shutdown at an explicit lifecycle boundary; dropping the last owner also shuts down and joins the worker.

Implementations

impl AsyncSink

pub fn new( config: AsyncSinkConfig, sink: Arc<dyn LogSink>, ) -> Result<Self, LogError>

Starts one bounded worker around sink.

Examples found in repository

examples/async_file.rs (lines 33-39)

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(())
}

pub fn flush(&self) -> Result<(), LogError>

Waits until every event admitted before this call has been delivered.

pub fn shutdown(&self) -> Result<(), LogError>

Drains admitted events, terminates the worker and rejects future emits.

This waits for the wrapped sink. Use only with a sink whose own I/O has a bounded completion contract; Rust cannot terminate arbitrary blocking sink code safely.

Examples found in repository

examples/async_file.rs (line 47)

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(())
}

pub fn stats(&self) -> AsyncSinkStats

Returns bounded queue and delivery counters without waiting for I/O.

Trait Implementations

impl Drop for AsyncSink

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl LogSink for AsyncSink

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

Writes one event or reports a controlled failure.

fn accepts_sensitive(&self) -> bool

Reports whether this sink is an explicitly encrypted sensitive boundary.

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

Stable bounded metric label for this sink implementation.