Line data Source code
1 : //! We re-export those from prometheus crate to
2 : //! make sure that we use the same dep version everywhere.
3 : //! Otherwise, we might not see all metrics registered via
4 : //! a default registry.
5 : #![deny(clippy::undocumented_unsafe_blocks)]
6 :
7 : use once_cell::sync::Lazy;
8 : use prometheus::core::{
9 : Atomic, AtomicU64, Collector, GenericCounter, GenericCounterVec, GenericGauge, GenericGaugeVec,
10 : };
11 : pub use prometheus::opts;
12 : pub use prometheus::register;
13 : pub use prometheus::Error;
14 : pub use prometheus::{core, default_registry, proto};
15 : pub use prometheus::{exponential_buckets, linear_buckets};
16 : pub use prometheus::{register_counter_vec, Counter, CounterVec};
17 : pub use prometheus::{register_gauge, Gauge};
18 : pub use prometheus::{register_gauge_vec, GaugeVec};
19 : pub use prometheus::{register_histogram, Histogram};
20 : pub use prometheus::{register_histogram_vec, HistogramVec};
21 : pub use prometheus::{register_int_counter, IntCounter};
22 : pub use prometheus::{register_int_counter_vec, IntCounterVec};
23 : pub use prometheus::{register_int_gauge, IntGauge};
24 : pub use prometheus::{register_int_gauge_vec, IntGaugeVec};
25 : pub use prometheus::{Encoder, TextEncoder};
26 : use prometheus::{Registry, Result};
27 :
28 : pub mod launch_timestamp;
29 : mod wrappers;
30 : pub use wrappers::{CountedReader, CountedWriter};
31 : mod hll;
32 : pub mod metric_vec_duration;
33 : pub use hll::{HyperLogLog, HyperLogLogVec};
34 : #[cfg(target_os = "linux")]
35 : pub mod more_process_metrics;
36 :
37 : pub type UIntGauge = GenericGauge<AtomicU64>;
38 : pub type UIntGaugeVec = GenericGaugeVec<AtomicU64>;
39 :
40 : #[macro_export]
41 : macro_rules! register_uint_gauge_vec {
42 : ($NAME:expr, $HELP:expr, $LABELS_NAMES:expr $(,)?) => {{
43 : let gauge_vec = UIntGaugeVec::new($crate::opts!($NAME, $HELP), $LABELS_NAMES).unwrap();
44 : $crate::register(Box::new(gauge_vec.clone())).map(|_| gauge_vec)
45 : }};
46 : }
47 :
48 : #[macro_export]
49 : macro_rules! register_uint_gauge {
50 : ($NAME:expr, $HELP:expr $(,)?) => {{
51 : let gauge = $crate::UIntGauge::new($NAME, $HELP).unwrap();
52 : $crate::register(Box::new(gauge.clone())).map(|_| gauge)
53 : }};
54 : }
55 :
56 : /// Special internal registry, to collect metrics independently from the default registry.
57 : /// Was introduced to fix deadlock with lazy registration of metrics in the default registry.
58 : static INTERNAL_REGISTRY: Lazy<Registry> = Lazy::new(Registry::new);
59 :
60 : /// Register a collector in the internal registry. MUST be called before the first call to `gather()`.
61 : /// Otherwise, we can have a deadlock in the `gather()` call, trying to register a new collector
62 : /// while holding the lock.
63 0 : pub fn register_internal(c: Box<dyn Collector>) -> Result<()> {
64 0 : INTERNAL_REGISTRY.register(c)
65 0 : }
66 :
67 : /// Gathers all Prometheus metrics and records the I/O stats just before that.
68 : ///
69 : /// Metrics gathering is a relatively simple and standalone operation, so
70 : /// it might be fine to do it this way to keep things simple.
71 0 : pub fn gather() -> Vec<prometheus::proto::MetricFamily> {
72 0 : update_rusage_metrics();
73 0 : let mut mfs = prometheus::gather();
74 0 : let mut internal_mfs = INTERNAL_REGISTRY.gather();
75 0 : mfs.append(&mut internal_mfs);
76 0 : mfs
77 0 : }
78 :
79 0 : static DISK_IO_BYTES: Lazy<IntGaugeVec> = Lazy::new(|| {
80 0 : register_int_gauge_vec!(
81 0 : "libmetrics_disk_io_bytes_total",
82 0 : "Bytes written and read from disk, grouped by the operation (read|write)",
83 0 : &["io_operation"]
84 0 : )
85 0 : .expect("Failed to register disk i/o bytes int gauge vec")
86 0 : });
87 :
88 0 : static MAXRSS_KB: Lazy<IntGauge> = Lazy::new(|| {
89 0 : register_int_gauge!(
90 0 : "libmetrics_maxrss_kb",
91 0 : "Memory usage (Maximum Resident Set Size)"
92 0 : )
93 0 : .expect("Failed to register maxrss_kb int gauge")
94 0 : });
95 :
96 : pub const DISK_WRITE_SECONDS_BUCKETS: &[f64] = &[
97 : 0.000_050, 0.000_100, 0.000_500, 0.001, 0.003, 0.005, 0.01, 0.05, 0.1, 0.3, 0.5,
98 : ];
99 :
100 0 : pub fn set_build_info_metric(revision: &str, build_tag: &str) {
101 0 : let metric = register_int_gauge_vec!(
102 0 : "libmetrics_build_info",
103 0 : "Build/version information",
104 0 : &["revision", "build_tag"]
105 0 : )
106 0 : .expect("Failed to register build info metric");
107 0 : metric.with_label_values(&[revision, build_tag]).set(1);
108 0 : }
109 :
110 : // Records I/O stats in a "cross-platform" way.
111 : // Compiles both on macOS and Linux, but current macOS implementation always returns 0 as values for I/O stats.
112 : // An alternative is to read procfs (`/proc/[pid]/io`) which does not work under macOS at all, hence abandoned.
113 : //
114 : // Uses https://www.freebsd.org/cgi/man.cgi?query=getrusage to retrieve the number of block operations
115 : // performed by the process.
116 : // We know the size of the block, so we can determine the I/O bytes out of it.
117 : // The value might be not 100% exact, but should be fine for Prometheus metrics in this case.
118 0 : fn update_rusage_metrics() {
119 0 : let rusage_stats = get_rusage_stats();
120 0 :
121 0 : const BYTES_IN_BLOCK: i64 = 512;
122 0 : DISK_IO_BYTES
123 0 : .with_label_values(&["read"])
124 0 : .set(rusage_stats.ru_inblock * BYTES_IN_BLOCK);
125 0 : DISK_IO_BYTES
126 0 : .with_label_values(&["write"])
127 0 : .set(rusage_stats.ru_oublock * BYTES_IN_BLOCK);
128 0 : MAXRSS_KB.set(rusage_stats.ru_maxrss);
129 0 : }
130 :
131 0 : fn get_rusage_stats() -> libc::rusage {
132 0 : let mut rusage = std::mem::MaybeUninit::uninit();
133 0 :
134 0 : // SAFETY: kernel will initialize the struct for us
135 0 : unsafe {
136 0 : let ret = libc::getrusage(libc::RUSAGE_SELF, rusage.as_mut_ptr());
137 0 : assert!(ret == 0, "getrusage failed: bad args");
138 0 : rusage.assume_init()
139 0 : }
140 0 : }
141 :
142 : /// Create an [`IntCounterPairVec`] and registers to default registry.
143 : #[macro_export(local_inner_macros)]
144 : macro_rules! register_int_counter_pair_vec {
145 : ($NAME1:expr, $HELP1:expr, $NAME2:expr, $HELP2:expr, $LABELS_NAMES:expr $(,)?) => {{
146 : match (
147 : $crate::register_int_counter_vec!($NAME1, $HELP1, $LABELS_NAMES),
148 : $crate::register_int_counter_vec!($NAME2, $HELP2, $LABELS_NAMES),
149 : ) {
150 : (Ok(inc), Ok(dec)) => Ok($crate::IntCounterPairVec::new(inc, dec)),
151 : (Err(e), _) | (_, Err(e)) => Err(e),
152 : }
153 : }};
154 : }
155 : /// Create an [`IntCounterPair`] and registers to default registry.
156 : #[macro_export(local_inner_macros)]
157 : macro_rules! register_int_counter_pair {
158 : ($NAME1:expr, $HELP1:expr, $NAME2:expr, $HELP2:expr $(,)?) => {{
159 : match (
160 : $crate::register_int_counter!($NAME1, $HELP1),
161 : $crate::register_int_counter!($NAME2, $HELP2),
162 : ) {
163 : (Ok(inc), Ok(dec)) => Ok($crate::IntCounterPair::new(inc, dec)),
164 : (Err(e), _) | (_, Err(e)) => Err(e),
165 : }
166 : }};
167 : }
168 :
169 : /// A Pair of [`GenericCounterVec`]s. Like an [`GenericGaugeVec`] but will always observe changes
170 : pub struct GenericCounterPairVec<P: Atomic> {
171 : inc: GenericCounterVec<P>,
172 : dec: GenericCounterVec<P>,
173 : }
174 :
175 : /// A Pair of [`GenericCounter`]s. Like an [`GenericGauge`] but will always observe changes
176 : pub struct GenericCounterPair<P: Atomic> {
177 : inc: GenericCounter<P>,
178 : dec: GenericCounter<P>,
179 : }
180 :
181 : impl<P: Atomic> GenericCounterPairVec<P> {
182 86 : pub fn new(inc: GenericCounterVec<P>, dec: GenericCounterVec<P>) -> Self {
183 86 : Self { inc, dec }
184 86 : }
185 :
186 : /// `get_metric_with_label_values` returns the [`GenericCounterPair<P>`] for the given slice
187 : /// of label values (same order as the VariableLabels in Desc). If that combination of
188 : /// label values is accessed for the first time, a new [`GenericCounterPair<P>`] is created.
189 : ///
190 : /// An error is returned if the number of label values is not the same as the
191 : /// number of VariableLabels in Desc.
192 904 : pub fn get_metric_with_label_values(&self, vals: &[&str]) -> Result<GenericCounterPair<P>> {
193 904 : Ok(GenericCounterPair {
194 904 : inc: self.inc.get_metric_with_label_values(vals)?,
195 904 : dec: self.dec.get_metric_with_label_values(vals)?,
196 : })
197 904 : }
198 :
199 : /// `with_label_values` works as `get_metric_with_label_values`, but panics if an error
200 : /// occurs.
201 408 : pub fn with_label_values(&self, vals: &[&str]) -> GenericCounterPair<P> {
202 408 : self.get_metric_with_label_values(vals).unwrap()
203 408 : }
204 :
205 22 : pub fn remove_label_values(&self, res: &mut [Result<()>; 2], vals: &[&str]) {
206 22 : res[0] = self.inc.remove_label_values(vals);
207 22 : res[1] = self.dec.remove_label_values(vals);
208 22 : }
209 : }
210 :
211 : impl<P: Atomic> GenericCounterPair<P> {
212 2 : pub fn new(inc: GenericCounter<P>, dec: GenericCounter<P>) -> Self {
213 2 : Self { inc, dec }
214 2 : }
215 :
216 : /// Increment the gauge by 1, returning a guard that decrements by 1 on drop.
217 412 : pub fn guard(&self) -> GenericCounterPairGuard<P> {
218 412 : self.inc.inc();
219 412 : GenericCounterPairGuard(self.dec.clone())
220 412 : }
221 :
222 : /// Increment the gauge by n, returning a guard that decrements by n on drop.
223 0 : pub fn guard_by(&self, n: P::T) -> GenericCounterPairGuardBy<P> {
224 0 : self.inc.inc_by(n);
225 0 : GenericCounterPairGuardBy(self.dec.clone(), n)
226 0 : }
227 :
228 : /// Increase the gauge by 1.
229 : #[inline]
230 1654 : pub fn inc(&self) {
231 1654 : self.inc.inc();
232 1654 : }
233 :
234 : /// Decrease the gauge by 1.
235 : #[inline]
236 1552 : pub fn dec(&self) {
237 1552 : self.dec.inc();
238 1552 : }
239 :
240 : /// Add the given value to the gauge. (The value can be
241 : /// negative, resulting in a decrement of the gauge.)
242 : #[inline]
243 0 : pub fn inc_by(&self, v: P::T) {
244 0 : self.inc.inc_by(v);
245 0 : }
246 :
247 : /// Subtract the given value from the gauge. (The value can be
248 : /// negative, resulting in an increment of the gauge.)
249 : #[inline]
250 0 : pub fn dec_by(&self, v: P::T) {
251 0 : self.dec.inc_by(v);
252 0 : }
253 : }
254 :
255 : impl<P: Atomic> Clone for GenericCounterPair<P> {
256 3186 : fn clone(&self) -> Self {
257 3186 : Self {
258 3186 : inc: self.inc.clone(),
259 3186 : dec: self.dec.clone(),
260 3186 : }
261 3186 : }
262 : }
263 :
264 : /// Guard returned by [`GenericCounterPair::guard`]
265 : pub struct GenericCounterPairGuard<P: Atomic>(GenericCounter<P>);
266 :
267 : impl<P: Atomic> Drop for GenericCounterPairGuard<P> {
268 412 : fn drop(&mut self) {
269 412 : self.0.inc();
270 412 : }
271 : }
272 : /// Guard returned by [`GenericCounterPair::guard_by`]
273 : pub struct GenericCounterPairGuardBy<P: Atomic>(GenericCounter<P>, P::T);
274 :
275 : impl<P: Atomic> Drop for GenericCounterPairGuardBy<P> {
276 0 : fn drop(&mut self) {
277 0 : self.0.inc_by(self.1);
278 0 : }
279 : }
280 :
281 : /// A Pair of [`IntCounterVec`]s. Like an [`IntGaugeVec`] but will always observe changes
282 : pub type IntCounterPairVec = GenericCounterPairVec<AtomicU64>;
283 :
284 : /// A Pair of [`IntCounter`]s. Like an [`IntGauge`] but will always observe changes
285 : pub type IntCounterPair = GenericCounterPair<AtomicU64>;
286 :
287 : /// A guard for [`IntCounterPair`] that will decrement the gauge on drop
288 : pub type IntCounterPairGuard = GenericCounterPairGuard<AtomicU64>;
|
