1use http::{Request, Response};
16use metrics::{histogram, increment_counter, Label};
17use std::{
18 marker::PhantomData,
19 sync::{
20 atomic::{AtomicU64, Ordering},
21 Arc, Mutex,
22 },
23};
24use tower_http::{
25 classify::{ServerErrorsAsFailures, SharedClassifier},
26 trace::{
27 DefaultMakeSpan, DefaultOnEos, OnBodyChunk, OnFailure, OnRequest, OnResponse, TraceLayer,
28 },
29};
30use tracing;
31
32pub type MetricsTraceLayer<B, F> = TraceLayer<
43 SharedClassifier<ServerErrorsAsFailures>,
44 DefaultMakeSpan,
45 MetricsRecorder<B, F>,
46 MetricsRecorder<B, F>,
47 MetricsRecorder<B, F>,
48 DefaultOnEos,
49 MetricsRecorder<B, F>,
50>;
51
52pub struct MetricsRecorder<B, F>
54where
55 F: Fn(&B) -> u64,
56{
57 pub labels: Arc<Mutex<Vec<Label>>>,
59 pub size: Arc<AtomicU64>,
61 pub chunk_len: Arc<F>,
63 _phantom: PhantomData<B>,
64}
65
66impl<B, F> Clone for MetricsRecorder<B, F>
67where
68 F: Fn(&B) -> u64,
69{
70 fn clone(&self) -> Self {
71 Self {
72 labels: self.labels.clone(),
73 size: self.size.clone(),
74 chunk_len: self.chunk_len.clone(),
75 _phantom: self._phantom.clone(),
76 }
77 }
78}
79
80impl<B, F> MetricsRecorder<B, F>
81where
82 F: Fn(&B) -> u64,
83{
84 pub fn new(f: F) -> Self {
88 Self {
89 labels: Arc::new(Mutex::new(Vec::new())),
90 size: Arc::new(AtomicU64::new(0)),
91 chunk_len: Arc::new(f),
92 _phantom: PhantomData,
93 }
94 }
95}
96
97impl<B, F> OnBodyChunk<B> for MetricsRecorder<B, F>
98where
99 F: Fn(&B) -> u64,
100{
101 fn on_body_chunk(&mut self, chunk: &B, _latency: std::time::Duration, _span: &tracing::Span) {
102 let _ = self
103 .size
104 .fetch_add(self.chunk_len.as_ref()(chunk), Ordering::SeqCst);
105 }
106}
107
108impl<B, FailureClass, F> OnFailure<FailureClass> for MetricsRecorder<B, F>
109where
110 F: Fn(&B) -> u64,
111{
112 fn on_failure(
113 &mut self,
114 _failure_classification: FailureClass,
115 _latency: std::time::Duration,
116 _span: &tracing::Span,
117 ) {
118 let labels = self.labels.lock().expect("Failed to unlock labels").clone();
119 increment_counter!("http_request_failure_counter", labels);
120 }
121}
122
123impl<B, RB, F> OnResponse<RB> for MetricsRecorder<B, F>
124where
125 F: Fn(&B) -> u64,
126{
127 fn on_response(
128 self,
129 _response: &Response<RB>,
130 latency: std::time::Duration,
131 _span: &tracing::Span,
132 ) {
133 let labels = self.labels.lock().expect("Failed to unlock labels").clone();
134 histogram!(
135 "http_request_time_micros_hist",
136 latency.as_micros() as f64,
137 labels.clone()
138 );
139 histogram!(
140 "http_request_size_bytes_hist",
141 self.size.as_ref().load(Ordering::SeqCst) as f64,
142 labels
143 )
144 }
145}
146
147fn make_request_lables(path: String, host: String, method: String) -> Vec<Label> {
148 vec![
149 Label::new("path", path),
150 Label::new("host", host),
151 Label::new("method", method),
152 ]
153}
154
155impl<B, RB, F> OnRequest<RB> for MetricsRecorder<B, F>
156where
157 F: Fn(&B) -> u64,
158{
159 fn on_request(&mut self, request: &Request<RB>, _span: &tracing::Span) {
160 let path = request.uri().path().to_lowercase();
161 let host = request.uri().host().unwrap_or("").to_lowercase();
162 let method = request.method().to_string();
163
164 let labels = make_request_lables(path, host, method);
165 let mut labels_lock = self.labels.lock().expect("Failed to unlock labels");
166 (*labels_lock.as_mut()) = labels.clone();
167 increment_counter!("http_request_counter", labels);
168 }
169}
170
171pub fn make_layer<B, F>(f: F) -> MetricsTraceLayer<B, F>
175where
176 F: Fn(&B) -> u64,
177{
178 let metrics_recorder = MetricsRecorder::new(f);
179 let layer = TraceLayer::new_for_http()
180 .on_body_chunk(metrics_recorder.clone())
181 .on_request(metrics_recorder.clone())
182 .on_response(metrics_recorder.clone())
183 .on_failure(metrics_recorder.clone());
184 layer
185}