delta-stream 0.32.0

State-aware delta synchronization and recovery for realtime Rust applications
Documentation
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RuntimeLimits {
    pub max_history_packets: usize,
    pub max_history_bytes: usize,
    pub max_pending_reorder: usize,
    pub max_client_lag: u64,
    pub max_recoveries_per_window: u32,
    pub max_encode_work_bytes: usize,
}

impl Default for RuntimeLimits {
    fn default() -> Self {
        Self {
            max_history_packets: 512,
            max_history_bytes: 16 * 1024 * 1024,
            max_pending_reorder: 128,
            max_client_lag: 10_000,
            max_recoveries_per_window: 64,
            max_encode_work_bytes: 8 * 1024 * 1024,
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct RuntimeMetrics {
    pub encoded_packets: u64,
    pub snapshots: u64,
    pub deltas: u64,
    pub compressed_packets: u64,
    pub input_bytes: u64,
    pub output_bytes: u64,
    pub recovery_replays: u64,
    pub recovery_snapshots: u64,
    pub reorder_buffered: u64,
    pub backpressure_events: u64,
    pub selector_candidates: u64,
}

impl RuntimeMetrics {
    pub fn compression_ratio(&self) -> f64 {
        if self.input_bytes == 0 {
            1.0
        } else {
            self.output_bytes as f64 / self.input_bytes as f64
        }
    }
    pub fn saving_percent(&self) -> f64 {
        (1.0 - self.compression_ratio()) * 100.0
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BackpressureDecision {
    Accept,
    SnapshotAndCatchUp,
    DropClient,
}

pub fn backpressure_decision(
    local_sequence: Option<u64>,
    publisher_sequence: u64,
    limits: RuntimeLimits,
) -> BackpressureDecision {
    let Some(local) = local_sequence else {
        return BackpressureDecision::SnapshotAndCatchUp;
    };
    let lag = publisher_sequence.saturating_sub(local);
    if lag <= limits.max_client_lag {
        BackpressureDecision::Accept
    } else if lag <= limits.max_client_lag.saturating_mul(10) {
        BackpressureDecision::SnapshotAndCatchUp
    } else {
        BackpressureDecision::DropClient
    }
}