axum-server-timing 3.0.1

An axum layer to inject the Server-Timing HTTP header into the response.
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

use crate::{ServerTimingExtension, ServerTimingLayer};
use axum::{
    http::{HeaderMap, HeaderValue},
    routing::get,
    Extension, Router,
};
use std::time::Duration;

#[test]
fn service_name() {
    let name = "svc1";
    let obj = ServerTimingLayer::new(name);
    assert_eq!(obj.app, name);
}

#[test]
fn service_desc() {
    let name = "svc1";
    let desc = "desc1";
    let obj = ServerTimingLayer::new(name).with_description(desc);
    assert_eq!(obj.app, name);
    assert_eq!(obj.description, Some(desc));
}

#[tokio::test]
async fn header_exists_on_response() {
    let name = "svc1";
    let app = Router::new()
        .route("/", get(|| async move { "" }))
        .layer(ServerTimingLayer::new(name));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3001").await.unwrap();
    tokio::spawn(async { axum::serve(listener, app.into_make_service()).await });
    //test request
    let resp = reqwest::get("http://localhost:3001/").await.unwrap();
    let hdr = resp.headers().get("server-timing");
    println!("{hdr:?}");
    assert!(hdr.is_some());
}

#[tokio::test]
async fn header_value() {
    let name = "svc1";
    let app = Router::new()
        .route(
            "/",
            get(|| async move {
                tokio::time::sleep(Duration::from_millis(100)).await;
                ""
            }),
        )
        .layer(ServerTimingLayer::new(name));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3002").await.unwrap();
    tokio::spawn(async { axum::serve(listener, app.into_make_service()).await });

    //test request
    let resp = reqwest::get("http://localhost:3002/").await.unwrap();
    if let Some(hdr) = resp.headers().get("server-timing") {
        let val = &hdr.to_str().unwrap()[9..];
        let val_num: f32 = val.parse().unwrap();
        assert!((100f32..300f32).contains(&val_num), "{val_num}");
    } else {
        panic!("no header found");
    }
}

#[tokio::test]
async fn support_existing_header() {
    let name = "svc1";
    let app = Router::new()
        .route(
            "/",
            get(|| async move {
                tokio::time::sleep(Duration::from_millis(100)).await;
                let mut hdr = HeaderMap::new();
                hdr.insert("server-timing", HeaderValue::from_static("inner;dur=23"));
                (hdr, "")
            }),
        )
        .layer(ServerTimingLayer::new(name));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3003").await.unwrap();
    tokio::spawn(async { axum::serve(listener, app.into_make_service()).await });

    //test request
    let resp = reqwest::get("http://localhost:3003/").await.unwrap();
    let hdr = resp.headers().get("server-timing").unwrap();
    let hdr_str = hdr.to_str().unwrap();
    assert!(hdr_str.contains("svc1"));
    assert!(hdr_str.contains("inner"));
    println!("{hdr:?}");
}

#[tokio::test]
async fn extension_works() {
    let name = "service";
    let app = Router::new()
        .route(
            "/",
            get(
                |Extension(timing): Extension<ServerTimingExtension>| async move {
                    // lock and unlock in one statement, so the mutex is not kept through the async call
                    timing.lock().unwrap().record("step1".to_string(), None);
                    tokio::time::sleep(Duration::from_millis(100)).await;

                    // second call, and again lock the mutex since it was released before the async call
                    timing.lock().unwrap().record("step2".to_string(), None);
                    "".to_string()
                },
            ),
        )
        .layer(ServerTimingLayer::new(name));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3004").await.unwrap();
    tokio::spawn(async { axum::serve(listener, app.into_make_service()).await });
    //test request
    let resp = reqwest::get("http://localhost:3004/").await.unwrap();
    let hdr = resp.headers().get("server-timing");
    println!("{hdr:?}");
    assert!(hdr.is_some());
}