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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
//! DNS server related metrics.
//------------ ServerMetrics -------------------------------------------------
use std::sync::atomic::{AtomicUsize, Ordering};
/// Metrics common to all provided DNS server implementations.
///
/// Server metrics should track values that cannot be known and exposed by the
/// [`Service`] implementation.
///
/// [`Service`]: crate::net::server::service::Service
#[derive(Debug, Default)]
pub struct ServerMetrics {
/// The number of connections currently being handled.
num_connections: Option<AtomicUsize>,
/// The number of requests received but still pending responses.
num_inflight_requests: AtomicUsize,
/// The number of responses waiting to be written back to the client.
num_pending_writes: AtomicUsize,
/// The total number of requests received since this metric collection was created.
num_received_requests: AtomicUsize,
/// The total number of responses sent since this metric collection was created.
num_sent_responses: AtomicUsize,
}
impl ServerMetrics {
/// Constructs initial metrics for a connection-less server.
pub fn connection_less() -> Self {
Self {
num_connections: None,
..Default::default()
}
}
/// Constructs initial metrics for a connection-oriented server.
pub fn connection_oriented() -> Self {
Self {
num_connections: Some(AtomicUsize::new(0)),
..Default::default()
}
}
}
impl ServerMetrics {
/// The number of current connections, if applicable.
///
/// This will be zero for connection-less servers such as [`DgramServer`].
///
/// [`DgramServer`]: crate::net::server::dgram::DgramServer
pub fn num_connections(&self) -> usize {
self.num_connections
.as_ref()
.map(|atomic| atomic.load(Ordering::Relaxed))
.unwrap_or_default()
}
/// Set the number of current connections metric.
pub fn set_num_connections(&self, new_value: usize) {
if let Some(num_connections) = &self.num_connections {
num_connections.store(new_value, Ordering::Relaxed);
}
}
/// Increment the number of current connections metric.
pub fn inc_num_connections(&self) {
if let Some(num_connections) = &self.num_connections {
num_connections.fetch_add(1, Ordering::Relaxed);
}
}
/// Decrement the number of current connections metric.
pub fn dec_num_connections(&self) {
if let Some(num_connections) = &self.num_connections {
num_connections.fetch_sub(1, Ordering::Relaxed);
}
}
}
impl ServerMetrics {
/// The number of requests received but not yet responded to.
pub fn num_inflight_requests(&self) -> usize {
self.num_inflight_requests.load(Ordering::Relaxed)
}
/// Set the number of inflight requests metric.
pub fn set_num_inflight_requests(&self, new_value: usize) {
self.num_inflight_requests
.store(new_value, Ordering::Relaxed);
}
/// Increment the number of inflight requests metric.
pub fn inc_num_inflight_requests(&self) {
self.num_inflight_requests.fetch_add(1, Ordering::Relaxed);
}
/// Decrement the number of inflight requests metric.
pub fn dec_num_inflight_requests(&self) {
self.num_inflight_requests.fetch_sub(1, Ordering::Relaxed);
}
}
impl ServerMetrics {
/// The number of responses generated but not yet sent back to the client.
pub fn num_pending_writes(&self) -> usize {
self.num_pending_writes.load(Ordering::Relaxed)
}
/// Set the number of pending writes metric.
pub fn set_num_pending_writes(&self, new_value: usize) {
self.num_pending_writes.store(new_value, Ordering::Relaxed);
}
/// Increment the number of pending writes metric.
pub fn inc_num_pending_writes(&self) {
self.num_pending_writes.fetch_add(1, Ordering::Relaxed);
}
/// Decrement the number of pending writes metric.
pub fn dec_num_pending_writes(&self) {
self.num_pending_writes.fetch_sub(1, Ordering::Relaxed);
}
}
impl ServerMetrics {
/// The number of DNS requests received.
pub fn num_received_requests(&self) -> usize {
self.num_received_requests.load(Ordering::Relaxed)
}
/// Set the number of received requests metric.
pub fn set_num_received_requests(&self, new_value: usize) {
self.num_received_requests
.store(new_value, Ordering::Relaxed);
}
/// Increment the number of received requests metric.
pub fn inc_num_received_requests(&self) {
self.num_received_requests.fetch_add(1, Ordering::Relaxed);
}
/// Decrement the number of received requests metric.
pub fn dec_num_received_requests(&self) {
self.num_received_requests.fetch_sub(1, Ordering::Relaxed);
}
}
impl ServerMetrics {
/// The number of DNS responses sent.
pub fn num_sent_responses(&self) -> usize {
self.num_sent_responses.load(Ordering::Relaxed)
}
/// Set the number of sent responses metric.
pub fn set_num_sent_responses(&self, new_value: usize) {
self.num_sent_responses.store(new_value, Ordering::Relaxed);
}
/// Increment the number of sent responses metric.
pub fn inc_num_sent_responses(&self) {
self.num_sent_responses.fetch_add(1, Ordering::Relaxed);
}
/// Decrement the number of sent responses metric.
pub fn dec_num_sent_responses(&self) {
self.num_sent_responses.fetch_sub(1, Ordering::Relaxed);
}
}