rustapi_core/middleware/
request_id.rs

1//! Request ID middleware
2//!
3//! Generates a unique UUID for each request and makes it available via the `RequestId` extractor.
4
5use super::layer::{BoxedNext, MiddlewareLayer};
6use crate::error::{ApiError, Result};
7use crate::extract::FromRequestParts;
8use crate::request::Request;
9use crate::response::Response;
10use std::future::Future;
11use std::pin::Pin;
12
13/// A unique identifier for a request
14#[derive(Debug, Clone, PartialEq, Eq, Hash)]
15pub struct RequestId(pub String);
16
17impl RequestId {
18    /// Create a new RequestId with a generated UUID
19    pub fn new() -> Self {
20        Self(generate_uuid())
21    }
22
23    /// Create a RequestId from an existing string
24    pub fn from_string(id: String) -> Self {
25        Self(id)
26    }
27
28    /// Get the request ID as a string slice
29    pub fn as_str(&self) -> &str {
30        &self.0
31    }
32}
33
34impl Default for RequestId {
35    fn default() -> Self {
36        Self::new()
37    }
38}
39
40impl std::fmt::Display for RequestId {
41    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
42        write!(f, "{}", self.0)
43    }
44}
45
46/// Extractor for RequestId from request extensions
47///
48/// This extractor retrieves the request ID that was generated by `RequestIdLayer`.
49/// Returns an error if the RequestIdLayer middleware was not applied.
50///
51/// # Example
52///
53/// ```rust,ignore
54/// use rustapi_core::middleware::RequestId;
55///
56/// async fn handler(request_id: RequestId) -> impl IntoResponse {
57///     format!("Request ID: {}", request_id)
58/// }
59/// ```
60impl FromRequestParts for RequestId {
61    fn from_request_parts(req: &Request) -> Result<Self> {
62        req.extensions().get::<RequestId>().cloned().ok_or_else(|| {
63            ApiError::internal(
64                "RequestId not found. Did you forget to add RequestIdLayer middleware?",
65            )
66        })
67    }
68}
69
70/// Middleware layer that generates a unique request ID for each request
71#[derive(Clone, Default)]
72pub struct RequestIdLayer;
73
74impl RequestIdLayer {
75    /// Create a new RequestIdLayer
76    pub fn new() -> Self {
77        Self
78    }
79}
80
81impl MiddlewareLayer for RequestIdLayer {
82    fn call(
83        &self,
84        mut req: Request,
85        next: BoxedNext,
86    ) -> Pin<Box<dyn Future<Output = Response> + Send + 'static>> {
87        Box::pin(async move {
88            // Generate a unique request ID
89            let request_id = RequestId::new();
90
91            // Store in request extensions
92            req.extensions_mut().insert(request_id.clone());
93
94            // Call the next handler
95            let mut response = next(req).await;
96
97            // Add request ID to response headers
98            if let Ok(header_value) = request_id.0.parse() {
99                response.headers_mut().insert("x-request-id", header_value);
100            }
101
102            response
103        })
104    }
105
106    fn clone_box(&self) -> Box<dyn MiddlewareLayer> {
107        Box::new(self.clone())
108    }
109}
110
111/// Generate a UUID v4 string
112///
113/// This is a simple implementation that doesn't require external dependencies.
114fn generate_uuid() -> String {
115    use std::time::{SystemTime, UNIX_EPOCH};
116
117    // Get current time for entropy
118    let now = SystemTime::now()
119        .duration_since(UNIX_EPOCH)
120        .unwrap_or_default();
121
122    // Use time and a counter for uniqueness
123    let time_part = now.as_nanos();
124
125    // Generate random-ish bytes using time and thread ID
126    let thread_id = std::thread::current().id();
127    let thread_hash = format!("{:?}", thread_id);
128
129    // Create a simple hash combining time and thread info
130    let mut bytes = [0u8; 16];
131
132    // Fill with time-based entropy
133    let time_bytes = time_part.to_le_bytes();
134    for (i, &b) in time_bytes.iter().enumerate().take(16) {
135        bytes[i] = b;
136    }
137
138    // Mix in thread hash
139    for (i, b) in thread_hash.bytes().enumerate() {
140        bytes[i % 16] ^= b;
141    }
142
143    // Add some additional entropy from a simple counter
144    static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
145    let count = COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
146    let count_bytes = count.to_le_bytes();
147    for (i, &b) in count_bytes.iter().enumerate() {
148        bytes[(i + 8) % 16] ^= b;
149    }
150
151    // Set version (4) and variant bits for UUID v4 format
152    bytes[6] = (bytes[6] & 0x0f) | 0x40; // Version 4
153    bytes[8] = (bytes[8] & 0x3f) | 0x80; // Variant 1
154
155    // Format as UUID string
156    format!(
157        "{:02x}{:02x}{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}-{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
158        bytes[0], bytes[1], bytes[2], bytes[3],
159        bytes[4], bytes[5],
160        bytes[6], bytes[7],
161        bytes[8], bytes[9],
162        bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]
163    )
164}
165
166#[cfg(test)]
167mod tests {
168    use super::*;
169    use crate::middleware::layer::{BoxedNext, LayerStack};
170    use bytes::Bytes;
171    use http::{Extensions, Method, StatusCode};
172    use proptest::prelude::*;
173    use proptest::test_runner::TestCaseError;
174    use std::collections::{HashMap, HashSet};
175    use std::sync::Arc;
176
177    /// Create a test request with the given method and path
178    fn create_test_request(method: Method, path: &str) -> Request {
179        let uri: http::Uri = path.parse().unwrap();
180        let builder = http::Request::builder().method(method).uri(uri);
181
182        let req = builder.body(()).unwrap();
183        let (parts, _) = req.into_parts();
184
185        Request::new(
186            parts,
187            Bytes::new(),
188            Arc::new(Extensions::new()),
189            HashMap::new(),
190        )
191    }
192
193    #[test]
194    fn test_request_id_generation() {
195        let id1 = RequestId::new();
196        let id2 = RequestId::new();
197
198        // IDs should be different
199        assert_ne!(id1.0, id2.0);
200
201        // IDs should be valid UUID format (36 chars with hyphens)
202        assert_eq!(id1.0.len(), 36);
203        assert_eq!(id2.0.len(), 36);
204    }
205
206    #[test]
207    fn test_request_id_display() {
208        let id = RequestId::from_string("test-id-123".to_string());
209        assert_eq!(format!("{}", id), "test-id-123");
210    }
211
212    // **Feature: phase3-batteries-included, Property 3: Request ID uniqueness**
213    //
214    // For any set of N concurrent requests processed with RequestIdLayer enabled,
215    // the System SHALL generate N distinct UUID values, each accessible via the
216    // `RequestId` extractor.
217    //
218    // **Validates: Requirements 1.3**
219    proptest! {
220        #![proptest_config(ProptestConfig::with_cases(100))]
221
222        #[test]
223        fn prop_request_id_uniqueness(
224            num_requests in 1usize..100usize,
225        ) {
226            let rt = tokio::runtime::Runtime::new().unwrap();
227            let result: Result<(), TestCaseError> = rt.block_on(async {
228                let mut stack = LayerStack::new();
229                stack.push(Box::new(RequestIdLayer::new()));
230
231                // Collect all generated request IDs
232                let collected_ids = Arc::new(std::sync::Mutex::new(Vec::new()));
233
234                // Process multiple requests through the middleware
235                for _ in 0..num_requests {
236                    let ids = collected_ids.clone();
237
238                    // Create a handler that extracts and stores the request ID
239                    let handler: BoxedNext = Arc::new(move |req: Request| {
240                        let ids = ids.clone();
241                        Box::pin(async move {
242                            // Extract the request ID from extensions
243                            if let Some(request_id) = req.extensions().get::<RequestId>() {
244                                ids.lock().unwrap().push(request_id.0.clone());
245                            }
246
247                            http::Response::builder()
248                                .status(StatusCode::OK)
249                                .body(http_body_util::Full::new(Bytes::from("ok")))
250                                .unwrap()
251                        }) as Pin<Box<dyn Future<Output = Response> + Send + 'static>>
252                    });
253
254                    let request = create_test_request(Method::GET, "/test");
255                    let _response = stack.execute(request, handler).await;
256                }
257
258                // Verify all IDs are unique
259                let ids = collected_ids.lock().unwrap();
260                prop_assert_eq!(ids.len(), num_requests, "Should have collected {} IDs", num_requests);
261
262                let unique_ids: HashSet<_> = ids.iter().collect();
263                prop_assert_eq!(
264                    unique_ids.len(),
265                    num_requests,
266                    "All {} request IDs should be unique, but found {} unique IDs",
267                    num_requests,
268                    unique_ids.len()
269                );
270
271                // Verify all IDs are valid UUID format (36 chars with hyphens)
272                for id in ids.iter() {
273                    prop_assert_eq!(id.len(), 36, "Request ID should be 36 characters (UUID format)");
274                    // Check UUID format: 8-4-4-4-12
275                    let parts: Vec<&str> = id.split('-').collect();
276                    prop_assert_eq!(parts.len(), 5, "UUID should have 5 parts separated by hyphens");
277                    prop_assert_eq!(parts[0].len(), 8);
278                    prop_assert_eq!(parts[1].len(), 4);
279                    prop_assert_eq!(parts[2].len(), 4);
280                    prop_assert_eq!(parts[3].len(), 4);
281                    prop_assert_eq!(parts[4].len(), 12);
282                }
283
284                Ok(())
285            });
286            result?;
287        }
288    }
289
290    #[test]
291    fn test_request_id_extractor() {
292        let rt = tokio::runtime::Runtime::new().unwrap();
293        rt.block_on(async {
294            let mut stack = LayerStack::new();
295            stack.push(Box::new(RequestIdLayer::new()));
296
297            let extracted_id = Arc::new(std::sync::Mutex::new(None));
298            let extracted_id_clone = extracted_id.clone();
299
300            let handler: BoxedNext = Arc::new(move |req: Request| {
301                let extracted_id = extracted_id_clone.clone();
302                Box::pin(async move {
303                    // Use the FromRequestParts implementation
304                    if let Ok(request_id) = RequestId::from_request_parts(&req) {
305                        *extracted_id.lock().unwrap() = Some(request_id.0.clone());
306                    }
307
308                    http::Response::builder()
309                        .status(StatusCode::OK)
310                        .body(http_body_util::Full::new(Bytes::from("ok")))
311                        .unwrap()
312                }) as Pin<Box<dyn Future<Output = Response> + Send + 'static>>
313            });
314
315            let request = create_test_request(Method::GET, "/test");
316            let _response = stack.execute(request, handler).await;
317
318            // Verify the request ID was extracted
319            let id = extracted_id.lock().unwrap();
320            assert!(id.is_some(), "Request ID should have been extracted");
321            assert_eq!(
322                id.as_ref().unwrap().len(),
323                36,
324                "Request ID should be UUID format"
325            );
326        });
327    }
328
329    #[test]
330    fn test_request_id_extractor_without_middleware() {
331        // Test that extractor returns error when middleware is not applied
332        let request = create_test_request(Method::GET, "/test");
333        let result = RequestId::from_request_parts(&request);
334        assert!(
335            result.is_err(),
336            "Should return error when RequestIdLayer is not applied"
337        );
338    }
339}
rustapi_core/middleware/request_id.rs

rustapi_core/middleware/
request_id.rs
