Struct SyncEngineConfig 

pub struct SyncEngineConfig {

    pub redis_url: Option<String>,
    pub redis_prefix: Option<String>,
    pub sql_url: Option<String>,
    pub l1_max_bytes: usize,
    pub max_payload_bytes: usize,
    pub backpressure_warn: f64,
    pub backpressure_critical: f64,
    pub batch_flush_ms: u64,
    pub batch_flush_count: usize,
    pub batch_flush_bytes: usize,
    pub cuckoo_warmup_batch_size: usize,
    pub wal_path: Option<String>,
    pub wal_max_items: Option<u64>,
    pub wal_drain_batch_size: usize,
    pub cf_snapshot_interval_secs: u64,
    pub cf_snapshot_insert_threshold: u64,
    pub redis_eviction_enabled: bool,
    pub redis_eviction_start: f64,
    pub redis_eviction_target: f64,
    pub merkle_calc_enabled: bool,
    pub merkle_calc_jitter_ms: u64,
    pub enable_cdc_stream: bool,
    pub cdc_stream_maxlen: u64,
    pub redis_timeout_ms: u64,
    pub redis_response_timeout_ms: u64,
}

Configuration for the sync engine.

All fields have sensible defaults. At minimum, you should configure redis_url and sql_url for production use.

Fields

redis_url: Option<String>

Redis connection string (e.g., “redis://localhost:6379”)

redis_prefix: Option<String>

Redis key prefix for namespacing (e.g., “myapp:” → keys become “myapp:user.alice”) Allows sync-engine to coexist with other data in the same Redis instance.

sql_url: Option<String>

SQL connection string (e.g., “sqlite:sync.db” or “mysql://user:pass@host/db”)

l1_max_bytes: usize

L1 cache max size in bytes (default: 256 MB)

max_payload_bytes: usize

Maximum payload size in bytes (default: 16 MB)

Payloads larger than this will be rejected with an error. This prevents a single large item (e.g., 1TB file) from exhausting the L1 cache. Set to 0 for unlimited (not recommended).

Important: This is a safety limit. Developers should choose a value appropriate for their use case. For binary blobs, consider using external object storage (S3, GCS) and storing only references here.

backpressure_warn: f64

Backpressure thresholds

backpressure_critical: f64

batch_flush_ms: u64

Batch flush settings

batch_flush_count: usize

batch_flush_bytes: usize

cuckoo_warmup_batch_size: usize

Cuckoo filter warmup

wal_path: Option<String>

WAL path (SQLite file for durability during MySQL outages)

wal_max_items: Option<u64>

WAL max items before backpressure

wal_drain_batch_size: usize

WAL drain batch size

cf_snapshot_interval_secs: u64

CF snapshot interval in seconds (0 = disabled)

cf_snapshot_insert_threshold: u64

CF snapshot after N inserts (0 = disabled)

redis_eviction_enabled: bool

Redis eviction: enable proactive eviction before Redis LRU kicks in

redis_eviction_start: f64

Redis eviction: pressure threshold to start evicting (0.0-1.0, default: 0.75)

redis_eviction_target: f64

Redis eviction: target pressure after eviction (0.0-1.0, default: 0.60)

merkle_calc_enabled: bool

Merkle calculation: enable merkle tree updates on this instance.

In a multi-instance deployment with shared SQL, only a few nodes need to run merkle calculations for resilience. Set to false on most nodes. Default: true (single-instance default)

merkle_calc_jitter_ms: u64

Merkle calculation: jitter range in milliseconds.

Adds random delay (0 to N ms) before merkle batch calculation to reduce contention when multiple instances are calculating. Default: 0 (no jitter)

enable_cdc_stream: bool

CDC Stream: Enable Change Data Capture output to Redis Stream.

When enabled, every Put/Delete writes to {redis_prefix}__local__:cdc. This enables external replication agents to tail changes. Default: false (opt-in feature)

cdc_stream_maxlen: u64

CDC Stream: Maximum entries before approximate trimming (MAXLEN ~).

Consumers that fall behind this limit rely on Merkle repair. Default: 100,000 entries

redis_timeout_ms: u64

Redis command timeout in milliseconds.

Maximum time to wait for a Redis command to complete before timing out. Under high load, increase this value to avoid spurious timeouts. Default: 5000 (5 seconds)

redis_response_timeout_ms: u64

Redis response timeout in milliseconds.

Maximum time to wait for Redis to respond after sending a command. Default: 5000 (5 seconds)

Trait Implementations

impl Clone for SyncEngineConfig

fn clone(&self) -> SyncEngineConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SyncEngineConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SyncEngineConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SyncEngineConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.