hyper-fast 0.3.5

Hyper and rust based very fast HTTP Web framework (much faster than actix and other frameworks).
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

use std::sync::atomic::Ordering;

use metered::atomic::AtomicInt;
use metered::clear::Clear;
use metered::Enter;
use metered::metric::{Advice, Counter, Metric, OnResult};
use metered::time_source::{Instant, StdInstant};
use serde::{Serialize, Serializer};

pub trait CounterIncrementer: Default + Clear + Serialize {
    fn increment_by(&self, number: u64);
}

impl CounterIncrementer for AtomicInt<u64> {
    fn increment_by(&self, number: u64) {
        self.inner.fetch_add(number, Ordering::Relaxed);
    }
}

#[derive(Clone, Debug)]
pub struct TotalTimeElapsed<A: CounterIncrementer = AtomicInt<u64>, C: Instant = StdInstant>(pub A, pub std::marker::PhantomData<C>);

impl<A: CounterIncrementer, C: Instant, R> Metric<R> for TotalTimeElapsed<A, C> {}

impl<A: CounterIncrementer, C: Instant> Enter for TotalTimeElapsed<A, C> {
    type E = C;
    fn enter(&self) -> Self::E {
        C::now()
    }
}

impl<A: CounterIncrementer, C: Instant> Default for TotalTimeElapsed<A, C> {
    fn default() -> Self {
        TotalTimeElapsed(A::default(), std::marker::PhantomData)
    }
}

impl<A: CounterIncrementer, C: Instant, R> OnResult<R> for TotalTimeElapsed<A, C> {
    fn on_result(&self, enter: C, _: &R) -> Advice {
        let elapsed = enter.elapsed_time();
        self.0.increment_by(elapsed);
        Advice::Return
    }
}

impl<A: CounterIncrementer, C: Instant> Clear for TotalTimeElapsed<A, C> {
    fn clear(&self) {
        self.0.clear()
    }
}

impl<A: CounterIncrementer, C: Instant> Serialize for TotalTimeElapsed<A, C> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
    {
        Serialize::serialize(&self.0, serializer)
    }
}

#[derive(Clone, Default, Debug, Serialize)]
pub struct ErrorCounter<C: Counter = AtomicInt<u64>>(pub C);

impl<C: Counter> Enter for ErrorCounter<C> {
    type E = ();
    fn enter(&self) {}
}

impl CounterIncrementer for ErrorCounter {
    fn increment_by(&self, number: u64) {
        self.0.inner.fetch_add(number, Ordering::Relaxed);
    }
}

impl<C: Counter, T, E> Metric<Result<T, E>> for ErrorCounter<C> {}

impl<C: Counter, T, E> OnResult<Result<T, E>> for ErrorCounter<C> {
    fn on_result(&self, _: (), r: &Result<T, E>) -> Advice {
        if r.is_err() {
            self.0.incr();
        };
        Advice::Return
    }
}

impl<C: Counter> Clear for ErrorCounter<C> {
    fn clear(&self) {
        self.0.clear()
    }
}

// pub fn register_prometheus_counter(registry: &Registry, name: String, help: String) -> anyhow::Result<PrometheusCounter> {
//     let metric_options = Opts::new(name, help);
//     let metric_counter = PrometheusCounter::with_opts(metric_options)?;
//     registry.register(Box::new(metric_counter.clone()))?;
//     Ok(metric_counter)
// }
//
// pub fn get_percentile_metrics(
//     registry_name: &str,
//     mut label_map: HashMap<String, String>,
//     percentile_map: &HashMap<String, u64>,
// ) -> anyhow::Result<String> {
//     let mut metric_text = String::default();
//     for (metric, value) in percentile_map {
//         // if *value == 0 {
//         //     continue;
//         // }
//         label_map.insert("quantile".to_string(), metric.clone());
//         let registry = Registry::new_custom(Some(registry_name.to_string()), Some(label_map.clone()))?;
//         let metric_counter = register_prometheus_counter(&registry, "quantile".to_string(), "Percentile Metrics".to_string())?;
//         metric_counter.inc_by(*value as f64);
//         metric_text.push_str(&get_prometheus_text(&registry)?)
//     }
//     Ok(metric_text)
// }
//
// pub fn get_prometheus_text(registry: &Registry) -> anyhow::Result<String> {
//     let mut buffer = vec![];
//     let encoder = TextEncoder::new();
//     let metric_families = registry.gather();
//     encoder
//         .encode(&metric_families, &mut buffer)
//         .with_context(|| "Unable to encode prometheus buffer")?;
//
//     String::from_utf8(buffer).with_context(|| "Unable to convert prometheus buffer to text")
// }
//
// pub fn get_average_latency(total_time_taken: &TotalTimeElapsed, hits: &HitCount) -> u64 {
//     if hits.0.get() > 0 {
//         total_time_taken.0.get() / hits.0.get()
//     } else {
//         0
//     }
// }