pingap-core 0.13.1

Core for pingap
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

use bytes::BytesMut;
use criterion::{Criterion, criterion_group, criterion_main};
use http::HeaderValue;
use pingap_core::{Ctx, format_duration};
use pingap_core::{
    convert_header, get_host, get_super_ts, now_ms, real_now_ms,
    remove_query_from_header,
};
use pingora::http::RequestHeader;
use std::hint::black_box;

#[allow(clippy::unwrap_used)]
fn bench_remove_query_from_header(c: &mut Criterion) {
    c.bench_function("remove query from header", |b| {
        let req =
            RequestHeader::build("GET", b"/?apikey=123&name=pingap", None)
                .unwrap();
        b.iter(|| {
            let mut new_req = req.clone();
            remove_query_from_header(&mut new_req, "apikey").unwrap();
            assert_eq!("/?name=pingap", new_req.uri.to_string());
        });
    });
}

#[allow(clippy::unwrap_used)]
fn bench_get_host(c: &mut Criterion) {
    c.bench_function("get uri host", |b| {
        let mut req =
            RequestHeader::build("GET", b"/?apikey=123&name=pingap", None)
                .unwrap();
        req.append_header("Host", "pingap.io").unwrap();
        b.iter(|| {
            let host = get_host(&req);
            assert_eq!(host, Some("pingap.io"));
        });
    });
}

#[allow(clippy::unwrap_used)]
fn bench_convert_header_value(c: &mut Criterion) {
    c.bench_function("convert header value", |b| {
        let value = HeaderValue::from_static("123123");
        b.iter(|| {
            let header = convert_header("x-trace-id: 123123").unwrap().unwrap();
            assert_eq!(header.0, "x-trace-id");
            assert_eq!(header.1, value);
        });
    });
}

fn bench_get_super_ts(c: &mut Criterion) {
    c.bench_function("get super ts", |b| {
        b.iter(|| {
            black_box(get_super_ts());
        });
    });
}

fn bench_now_ms(c: &mut Criterion) {
    c.bench_function("now ms", |b| {
        b.iter(|| {
            black_box(now_ms());
        });
    });
}

fn bench_real_now_ms(c: &mut Criterion) {
    c.bench_function("real now ms", |b| {
        b.iter(|| {
            let _ = real_now_ms();
        });
    });
}

fn bench_format_duration(c: &mut Criterion) {
    let mut group = c.benchmark_group("format duration");

    group.bench_function("< 1s", |b| {
        b.iter(|| {
            let mut buf = BytesMut::new();
            format_duration(&mut buf, 999);
            if buf.len() != 5 {
                panic!("buf: {:?}", buf);
            }
        });
    });

    group.bench_function("< 1m", |b| {
        b.iter(|| {
            let mut buf = BytesMut::new();
            format_duration(&mut buf, 9999);
            if buf.len() != 4 {
                panic!("buf: {:?}", buf);
            }
        });
    });

    group.finish();
}

fn bench_get_variable(c: &mut Criterion) {
    c.bench_function("get variable", |b| {
        let mut ctx = Ctx::new();
        ctx.add_variable("test", "123");
        ctx.add_variable("test2", "456");
        ctx.add_variable("test3", "789");
        ctx.add_variable("test4", "101");
        ctx.add_variable("test5", "121");
        b.iter(|| {
            let value = black_box(ctx.get_variable("test5"));
            if value.is_none() {
                panic!("value is none");
            }
        });
    });
}
criterion_group!(
    benches,
    bench_remove_query_from_header,
    bench_get_host,
    bench_convert_header_value,
    bench_get_super_ts,
    bench_now_ms,
    bench_real_now_ms,
    bench_format_duration,
    bench_get_variable,
);
criterion_main!(benches);