mneme 0.5.0

An event-sourcing library for Rust projects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use rand::prelude::*;
use std::cell::RefCell;
use tokio::time::Duration;

thread_local! {
    static THREAD_RNG: RefCell<SmallRng> = RefCell::new(SmallRng::seed_from_u64(0));
}

#[derive(Debug, Clone, Copy)]
pub struct RetryDelay {
    base_delay_ms: u64,
    max_delay_ms: u64,
}

impl RetryDelay {
    pub fn new(base_delay_ms: u64, max_delay_ms: u64) -> Self {
        Self {
            base_delay_ms,
            max_delay_ms,
        }
    }

    pub fn base_delay_ms(&self) -> u64 {
        self.base_delay_ms
    }

    pub fn max_delay_ms(&self) -> u64 {
        self.max_delay_ms
    }

    pub fn calculate_delay(&self, retry_count: u32) -> Duration {
        // Calculate exponential delay
        let exp_delay = self.base_delay_ms * 2u64.pow(retry_count);

        // Cap at max delay
        let capped_delay = exp_delay.min(self.max_delay_ms);

        // Apply full jitter using thread-local RNG
        let jittered_delay = THREAD_RNG.with(|rng| {
            #[allow(deprecated)]
            rng.borrow_mut().gen_range(0..=capped_delay)
        });

        Duration::from_millis(jittered_delay)
    }
}

impl Default for RetryDelay {
    fn default() -> Self {
        Self {
            base_delay_ms: 100,
            max_delay_ms: 30_000, // 30 seconds max delay
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashSet;

    #[test]
    fn calculates_delay_within_bounds() {
        let retry_delay = RetryDelay::new(100, 1000);

        // Test multiple times to account for randomness
        for _ in 0..100 {
            let delay = retry_delay.calculate_delay(0);
            assert!(
                delay.as_millis() <= 100,
                "First retry delay should be <= base delay"
            );

            let delay = retry_delay.calculate_delay(1);
            assert!(
                delay.as_millis() <= 200,
                "Second retry delay should be <= 2 * base delay"
            );

            let delay = retry_delay.calculate_delay(3);
            assert!(
                delay.as_millis() <= 800,
                "Fourth retry delay should be <= 8 * base delay"
            );

            // Test max delay cap
            let delay = retry_delay.calculate_delay(5);
            assert!(
                delay.as_millis() <= 1000,
                "Delay should be capped at max_delay"
            );
        }
    }

    #[test]
    fn applies_jitter() {
        let retry_delay = RetryDelay::new(100, 1000);
        let mut delays = Vec::new();

        for _ in 0..100 {
            let delay = retry_delay.calculate_delay(1);
            delays.push(delay.as_millis());
        }

        let unique_delays = delays.iter().collect::<HashSet<_>>();
        assert!(
            unique_delays.len() > 1,
            "Jitter should produce varying delays"
        );

        assert!(
            delays.iter().all(|&d| d <= 200),
            "All delays should be <= 2 * base delay"
        );
    }

    #[test]
    fn respects_max_delay() {
        let retry_delay = RetryDelay::new(100, 500);

        for _ in 0..100 {
            let delay = retry_delay.calculate_delay(10); // Would be 102400ms without cap
            assert!(
                delay.as_millis() <= 500,
                "Delay should respect max_delay cap"
            );
        }
    }
}