fraiseql-server 2.2.0

HTTP server for FraiseQL v2 GraphQL engine
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
150
151
152
153

//! HTTP metrics middleware.
//!
//! Tracks HTTP request counts and response status codes.

use std::{
    sync::{Arc, atomic::Ordering},
    time::Instant,
};

use axum::{body::Body, extract::State, http::Request, middleware::Next, response::Response};

use crate::metrics_server::MetricsCollector;

/// Metrics middleware that tracks HTTP requests and response status codes.
///
/// # Metrics Tracked
///
/// - `http_requests_total`: Total number of HTTP requests
/// - `http_responses_2xx`: Successful responses (200-299)
/// - `http_responses_4xx`: Client errors (400-499)
/// - `http_responses_5xx`: Server errors (500-599)
///
/// # Example
///
/// ```text
/// // Requires: running Axum application with a MetricsCollector instance.
/// use axum::{Router, middleware};
/// use fraiseql_server::middleware::metrics_middleware;
///
/// let app = Router::new()
///     .route("/", get(handler))
///     .layer(middleware::from_fn_with_state(metrics.clone(), metrics_middleware));
/// ```
pub async fn metrics_middleware(
    State(metrics): State<Arc<MetricsCollector>>,
    request: Request<Body>,
    next: Next,
) -> Response {
    // Increment total requests counter
    metrics.http_requests_total.fetch_add(1, Ordering::Relaxed);

    // Execute the request with timing
    let start = Instant::now();
    let response = next.run(request).await;
    #[allow(clippy::cast_possible_truncation)]
    // Reason: microsecond counter cannot exceed u64 in any practical uptime
    let elapsed_us = start.elapsed().as_micros() as u64;
    metrics.http_request_duration.observe_us(elapsed_us);

    // Record response status
    let status = response.status();
    match status.as_u16() {
        200..=299 => {
            metrics.http_responses_2xx.fetch_add(1, Ordering::Relaxed);
        },
        400..=499 => {
            metrics.http_responses_4xx.fetch_add(1, Ordering::Relaxed);
        },
        500..=599 => {
            metrics.http_responses_5xx.fetch_add(1, Ordering::Relaxed);
        },
        _ => {
            // Other status codes (1xx, 3xx) - not tracked separately
        },
    }

    response
}

#[cfg(test)]
mod tests {
    #![allow(clippy::unwrap_used)] // Reason: test code, panics acceptable
    #![allow(clippy::cast_precision_loss)] // Reason: test metrics reporting
    #![allow(clippy::cast_sign_loss)] // Reason: test data uses small positive integers
    #![allow(clippy::cast_possible_truncation)] // Reason: test data values are bounded
    #![allow(clippy::cast_possible_wrap)] // Reason: test data values are bounded
    #![allow(clippy::missing_panics_doc)] // Reason: test helpers
    #![allow(clippy::missing_errors_doc)] // Reason: test helpers
    #![allow(missing_docs)] // Reason: test code
    #![allow(clippy::items_after_statements)] // Reason: test helpers defined near use site

    use axum::{
        Router,
        body::Body,
        http::{Request, StatusCode},
        middleware,
        routing::get,
    };
    use tower::ServiceExt;

    use super::*;

    async fn ok_handler() -> StatusCode {
        StatusCode::OK
    }

    async fn bad_request_handler() -> StatusCode {
        StatusCode::BAD_REQUEST
    }

    async fn internal_error_handler() -> StatusCode {
        StatusCode::INTERNAL_SERVER_ERROR
    }

    #[tokio::test]
    async fn test_metrics_middleware_counts_requests() {
        let metrics = Arc::new(MetricsCollector::new());

        let app = Router::new()
            .route("/ok", get(ok_handler))
            .layer(middleware::from_fn_with_state(metrics.clone(), metrics_middleware));

        let request = Request::builder().uri("/ok").body(Body::empty()).unwrap();

        let _response = app.oneshot(request).await.unwrap();

        assert_eq!(metrics.http_requests_total.load(Ordering::Relaxed), 1);
        assert_eq!(metrics.http_responses_2xx.load(Ordering::Relaxed), 1);
    }

    #[tokio::test]
    async fn test_metrics_middleware_tracks_4xx() {
        let metrics = Arc::new(MetricsCollector::new());

        let app = Router::new()
            .route("/bad", get(bad_request_handler))
            .layer(middleware::from_fn_with_state(metrics.clone(), metrics_middleware));

        let request = Request::builder().uri("/bad").body(Body::empty()).unwrap();

        let _response = app.oneshot(request).await.unwrap();

        assert_eq!(metrics.http_requests_total.load(Ordering::Relaxed), 1);
        assert_eq!(metrics.http_responses_4xx.load(Ordering::Relaxed), 1);
        assert_eq!(metrics.http_responses_2xx.load(Ordering::Relaxed), 0);
    }

    #[tokio::test]
    async fn test_metrics_middleware_tracks_5xx() {
        let metrics = Arc::new(MetricsCollector::new());

        let app = Router::new()
            .route("/error", get(internal_error_handler))
            .layer(middleware::from_fn_with_state(metrics.clone(), metrics_middleware));

        let request = Request::builder().uri("/error").body(Body::empty()).unwrap();

        let _response = app.oneshot(request).await.unwrap();

        assert_eq!(metrics.http_requests_total.load(Ordering::Relaxed), 1);
        assert_eq!(metrics.http_responses_5xx.load(Ordering::Relaxed), 1);
    }
}