rapina 0.11.0

A fast, type-safe web framework for Rust inspired by FastAPI
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use std::sync::{Arc, OnceLock};
use std::time::Instant;

/// Per-request context passed through the middleware stack and into handlers.
///
/// Created automatically for each incoming connection. Available via
/// `req.extensions().get::<RequestContext>()` inside handlers and middleware.
///
/// The trace ID is generated lazily on first access, so requests that never
/// read the trace ID (e.g. when no tracing middleware is registered) avoid
/// the UUID v4 allocation entirely.
#[derive(Debug, Clone)]
pub struct RequestContext {
    trace_id: Arc<OnceLock<String>>,
    /// Timestamp recorded when the request context was created, used to
    /// calculate request duration.
    pub start_time: Instant,
}

impl RequestContext {
    pub fn new() -> Self {
        Self {
            trace_id: Arc::new(OnceLock::new()),
            start_time: Instant::now(),
        }
    }

    pub fn with_trace_id(trace_id: String) -> Self {
        let cell = Arc::new(OnceLock::new());
        let _ = cell.set(trace_id);
        Self {
            trace_id: cell,
            start_time: Instant::now(),
        }
    }

    /// Returns the trace ID for this request, generating a UUID v4 on first access.
    pub fn trace_id(&self) -> &str {
        self.trace_id
            .get_or_init(|| uuid::Uuid::new_v4().to_string())
    }

    pub fn elapsed(&self) -> std::time::Duration {
        self.start_time.elapsed()
    }
}

impl Default for RequestContext {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::thread;
    use std::time::Duration;

    #[test]
    fn test_new_generates_uuid() {
        let ctx = RequestContext::new();
        // UUID v4 format: 8-4-4-4-12 hex chars
        assert_eq!(ctx.trace_id().len(), 36);
        assert!(ctx.trace_id().chars().filter(|c| *c == '-').count() == 4);
    }

    #[test]
    fn test_new_generates_unique_ids() {
        let ctx1 = RequestContext::new();
        let ctx2 = RequestContext::new();
        assert_ne!(ctx1.trace_id(), ctx2.trace_id());
    }

    #[test]
    fn test_with_trace_id() {
        let custom_id = "custom-trace-123".to_string();
        let ctx = RequestContext::with_trace_id(custom_id.clone());
        assert_eq!(ctx.trace_id(), custom_id);
    }

    #[test]
    fn test_elapsed_increases() {
        let ctx = RequestContext::new();
        let elapsed1 = ctx.elapsed();
        thread::sleep(Duration::from_millis(10));
        let elapsed2 = ctx.elapsed();
        assert!(elapsed2 > elapsed1);
    }

    #[test]
    fn test_default_is_new() {
        let ctx = RequestContext::default();
        assert_eq!(ctx.trace_id().len(), 36);
    }

    #[test]
    fn test_clone_shares_trace_id() {
        let ctx1 = RequestContext::new();
        let ctx2 = ctx1.clone();
        // Arc<OnceLock> ensures both sides share the same cell,
        // so whichever initializes first wins.
        assert_eq!(ctx1.trace_id(), ctx2.trace_id());
    }

    #[test]
    fn test_trace_id_is_lazy() {
        let ctx = RequestContext::new();
        // The internal OnceLock should not be initialized until trace_id() is called
        assert!(
            ctx.trace_id.get().is_none(),
            "trace_id should not be initialized before first access"
        );
        let id = ctx.trace_id();
        assert_eq!(id.len(), 36, "trace_id should be a valid UUID after access");
        assert!(
            ctx.trace_id.get().is_some(),
            "trace_id should be initialized after first access"
        );
    }

    #[test]
    fn test_trace_id_stable_across_calls() {
        let ctx = RequestContext::new();
        let id1 = ctx.trace_id();
        let id2 = ctx.trace_id();
        assert_eq!(
            id1, id2,
            "trace_id should return the same value on repeated calls"
        );
    }

    #[test]
    fn test_with_trace_id_is_eager() {
        let ctx = RequestContext::with_trace_id("pre-set".to_string());
        assert!(
            ctx.trace_id.get().is_some(),
            "with_trace_id should eagerly set the value"
        );
        assert_eq!(ctx.trace_id(), "pre-set");
    }

    #[test]
    fn test_debug() {
        let ctx = RequestContext::with_trace_id("test-id".to_string());
        let debug_str = format!("{:?}", ctx);
        assert!(debug_str.contains("test-id"));
    }
}