Struct LogDbReader 

pub struct LogDbReader { /* private fields */ }

A read-only view of the log.

LogDbReader provides access to all read operations via the LogRead trait, but not write operations. This is useful for:

• Consumers that should not have write access
• Sharing read access across multiple components
• Separating read and write concerns in your application

Obtaining a LogDbReader

A LogDbReader is created by calling LogDbReader::open:

let config = ReaderConfig { storage: StorageConfig::default(), ..Default::default() };
let reader = LogDbReader::open(config).await?;

Thread Safety

LogDbReader is designed to be cloned and shared across threads. All methods take &self and are safe to call concurrently.

Example

use log::{LogDbReader, LogRead, LogEntry};
use bytes::Bytes;
use std::time::Duration;

async fn consume_events(reader: LogDbReader, key: Bytes) -> log::Result<()> {
    let mut checkpoint: u64 = 0;

    loop {
        let mut iter = reader.scan(key.clone(), checkpoint..).await?;
        while let Some(entry) = iter.next().await? {
            println!("entry: {:?}", entry);
            checkpoint = entry.sequence + 1;
        }

        // Check how far behind we are
        let lag = reader.count(key.clone(), checkpoint..).await?;
        if lag == 0 {
            // Caught up, wait for new entries
            tokio::time::sleep(Duration::from_millis(100)).await;
        }
    }
}

Implementations

impl LogDbReader

pub async fn open(config: ReaderConfig) -> Result<Self>

Opens a read-only view of the log with the given configuration.

This creates a LogDbReader that can scan and count entries but cannot append new records. Use this when you only need read access to the log.

When refresh_interval is set, the reader periodically discovers new data written by other processes.

Arguments

• config - Reader configuration including storage and refresh settings.

Errors

Returns an error if the storage backend cannot be initialized.

Example

use log::{LogDbReader, LogRead, ReaderConfig};
use common::StorageConfig;
use bytes::Bytes;

let config = ReaderConfig {
    storage: StorageConfig::default(),
    ..Default::default()
};
let reader = LogDbReader::open(config).await?;

// Reader will automatically discover new data
let mut iter = reader.scan(Bytes::from("orders"), ..).await?;
while let Some(entry) = iter.next().await? {
    println!("seq={}: {:?}", entry.sequence, entry.value);
}

// Gracefully shut down when done
reader.close().await;

pub async fn close(self)

Closes the reader, stopping the background refresh task.

This method consumes self and gracefully shuts down the background refresh task. It waits up to 5 seconds for the task to complete.

Trait Implementations

impl LogRead for LogDbReader

fn scan_with_options<'life0, 'async_trait>( &'life0 self, key: Bytes, seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, options: ScanOptions, ) -> Pin<Box<dyn Future<Output = Result<LogIterator>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Scans entries for a key within a sequence number range with custom options.

fn count_with_options<'life0, 'async_trait>( &'life0 self, _key: Bytes, _seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, _options: CountOptions, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Counts entries for a key within a sequence number range with custom options.

fn list_keys<'life0, 'async_trait>( &'life0 self, segment_range: impl 'async_trait + RangeBounds<SegmentId> + Send, ) -> Pin<Box<dyn Future<Output = Result<LogKeyIterator>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists distinct keys within a segment range.

fn list_segments<'life0, 'async_trait>( &'life0 self, seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, ) -> Pin<Box<dyn Future<Output = Result<Vec<Segment>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Lists segments overlapping a sequence number range.

fn scan<'life0, 'async_trait>( &'life0 self, key: Bytes, seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, ) -> Pin<Box<dyn Future<Output = Result<LogIterator>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Scans entries for a key within a sequence number range.

fn count<'life0, 'async_trait>( &'life0 self, key: Bytes, seq_range: impl 'async_trait + RangeBounds<Sequence> + Send, ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Counts entries for a key within a sequence number range.