Struct LogDb 

pub struct LogDb { /* private fields */ }

The main log interface providing read and write operations.

LogDb is the primary entry point for interacting with OpenData Log. It provides methods to append records, scan entries, and count records within a key’s log.

Read Operations

Read operations are provided via the LogRead trait, which LogDb implements. This allows generic code to work with either LogDb or LogDbReader.

Thread Safety

LogDb is designed to be shared across threads. All methods take &self and internal synchronization is handled automatically.

Visibility and Durability

Appended records are not immediately visible to reads. The flush() method ensures all pending data is durably persisted to storage, but does not block on reader synchronization. Instead, read operations (scan, list_keys, list_segments) synchronize themselves by waiting for the reader view to catch up to the coordinator’s current flushed watermark before returning results. This means:

• After flush(), subsequent reads are guaranteed to see all flushed data.
• Data that becomes visible through background flush activity (without an explicit flush() call) may not yet be durable.

In the future, stronger guarantees such as a “read-durable” mode may be introduced, where the read view advances only after data is confirmed durable.

Writer Semantics

Currently, each log supports a single writer. Multi-writer support may be added in the future, but would require each key to have a single writer to maintain monotonic ordering within that key’s log.

Example

let config = Config { storage: StorageConfig::InMemory, ..Default::default() };
let log = LogDb::open(config).await?;

// Append records
let records = vec![
    Record { key: Bytes::from("user:123"), value: Bytes::from("event-a") },
    Record { key: Bytes::from("user:456"), value: Bytes::from("event-b") },
];
log.try_append(records).await?;
log.flush().await?;

// Scan entries for a specific key
let mut iter = log.scan(Bytes::from("user:123"), ..).await?;
while let Some(entry) = iter.next().await? {
    println!("seq={}: {:?}", entry.sequence, entry.value);
}

Implementations

impl LogDb

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

Opens or creates a log with the given configuration.

This is the primary entry point for creating a LogDb instance. The configuration specifies the storage backend and other settings.

Arguments

• config - Configuration specifying storage backend and settings.

Errors

Returns an error if the storage backend cannot be initialized.

Example

use log::{LogDb, Config};

let log = LogDb::open(test_config()).await?;

pub async fn try_append( &self, records: Vec<Record>, ) -> AppendResult<AppendOutput>

Appends records to the log without blocking.

Records are assigned sequence numbers in the order they appear in the input vector. All records in a single append call are written atomically.

Fails immediately with AppendError::QueueFull if the write queue is full. The returned error contains the original batch so callers can retry without cloning.

Durability is not awaited. Call flush() after appending to ensure records are persisted.

Arguments

• records - The records to append. Each record specifies its target key and value.

Returns

On success, returns an AppendOutput containing the starting sequence number assigned to the batch.

Example

let records = vec![
    Record { key: Bytes::from("events"), value: Bytes::from("event-1") },
    Record { key: Bytes::from("events"), value: Bytes::from("event-2") },
];
let result = log.try_append(records).await?;
println!("Appended at seq {}", result.start_sequence);

pub async fn append_timeout( &self, records: Vec<Record>, timeout: Duration, ) -> AppendResult<AppendOutput>

Appends records to the log, blocking up to timeout for queue space.

Records are assigned sequence numbers in the order they appear in the input vector. All records in a single append call are written atomically.

Returns AppendError::Timeout if the queue does not drain within the deadline. The returned error contains the original batch for retry.

Durability is not awaited. Call flush() after appending to ensure records are persisted.

Arguments

• records - The records to append.
• timeout - Maximum duration to wait for queue space.

Returns

On success, returns an AppendOutput containing the starting sequence number assigned to the batch.

Example

use std::time::Duration;

let records = vec![
    Record { key: Bytes::from("events"), value: Bytes::from("critical-event") },
];
let result = log.append_timeout(records, Duration::from_secs(5)).await?;
println!("Started at sequence {}", result.start_sequence);

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

Flushes all pending writes to durable storage.

This method ensures that all acknowledged writes are durably persisted to storage.

pub async fn close(self) -> Result<()>

Closes the log, flushing any pending data and releasing resources.

All appended data is flushed to durable storage before the log is closed. For SlateDB-backed storage, this also releases the database fence.

Trait Implementations

impl LogRead for LogDb

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.