embystream 0.0.26

Another Emby streaming application (frontend/backend separation) written in Rust.
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

use std::time::Instant;

/// Helper for timing operations and logging slow executions.
pub struct OperationTimer {
    start: Instant,
    threshold_ms: u128,
}

impl OperationTimer {
    pub fn new(_operation: &'static str, threshold_ms: u128) -> Self {
        Self {
            start: Instant::now(),
            threshold_ms,
        }
    }

    pub fn elapsed_ms(&self) -> u128 {
        self.start.elapsed().as_millis()
    }

    pub fn is_slow(&self) -> bool {
        self.elapsed_ms() >= self.threshold_ms
    }

    pub fn finish(self) -> u128 {
        self.elapsed_ms()
    }
}

/// Macro to time an operation and log if it exceeds threshold.
#[macro_export]
macro_rules! time_operation {
    ($domain:expr, $operation:expr, $threshold_ms:expr, $code:block) => {{
        let _timer_start = std::time::Instant::now();
        let _timer_result = $code;
        let _timer_elapsed = _timer_start.elapsed().as_millis();
        if _timer_elapsed >= $threshold_ms {
            $crate::warn_log!(
                $domain,
                "slow_operation op={} elapsed_ms={} threshold_ms={}",
                $operation,
                _timer_elapsed,
                $threshold_ms
            );
        } else {
            $crate::debug_log!(
                $domain,
                "operation_complete op={} elapsed_ms={}",
                $operation,
                _timer_elapsed
            );
        }
        _timer_result
    }};
    ($domain:expr, $operation:expr, $threshold_ms:expr, $request_id:expr, $code:block) => {{
        let _timer_start = std::time::Instant::now();
        let _timer_result = $code;
        let _timer_elapsed = _timer_start.elapsed().as_millis();
        if _timer_elapsed >= $threshold_ms {
            $crate::warn_log!(
                $domain,
                "slow_operation request_id={} op={} elapsed_ms={} threshold_ms={}",
                $request_id,
                $operation,
                _timer_elapsed,
                $threshold_ms
            );
        } else {
            $crate::debug_log!(
                $domain,
                "operation_complete request_id={} op={} elapsed_ms={}",
                $request_id,
                $operation,
                _timer_elapsed
            );
        }
        _timer_result
    }};
}

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

    #[test]
    fn timer_tracks_elapsed_time() {
        let timer = OperationTimer::new("test_op", 100);
        std::thread::sleep(std::time::Duration::from_millis(10));
        let elapsed = timer.elapsed_ms();
        assert!(elapsed >= 10);
        assert!(elapsed < 50);
    }

    #[test]
    fn timer_detects_slow_operations() {
        let timer = OperationTimer::new("test_op", 5);
        std::thread::sleep(std::time::Duration::from_millis(10));
        assert!(timer.is_slow());
    }

    #[test]
    fn timer_detects_fast_operations() {
        let timer = OperationTimer::new("test_op", 1000);
        std::thread::sleep(std::time::Duration::from_millis(10));
        assert!(!timer.is_slow());
    }
}