1use crate::{Event, RegisterType, SqliteExporter};
2use metrics::{
3 Counter, CounterFn, Gauge, GaugeFn, GaugeValue, Histogram, HistogramFn, Key, KeyName, Recorder,
4 SharedString, Unit,
5};
6use std::sync::mpsc::SyncSender;
7use std::sync::Arc;
8use std::time::SystemTime;
9
10pub(crate) struct Handle {
11 sender: SyncSender<Event>,
12 key: Key,
13}
14impl CounterFn for Handle {
15 fn increment(&self, value: u64) {
16 match SystemTime::UNIX_EPOCH.elapsed() {
17 Ok(timestamp) => {
18 if let Err(_e) = self.sender.try_send(Event::IncrementCounter(
19 timestamp,
20 self.key.clone(),
21 value,
22 )) {
23 #[cfg(feature = "log_dropped_metrics")]
24 error!(
25 "Error sending metric to SQLite thread: {}, dropping metric",
26 _e
27 );
28 }
29 }
30 Err(_e) => {
31 #[cfg(feature = "log_dropped_metrics")]
32 error!("Failed to get system time: {}, dropping metric", _e);
33 }
34 }
35 }
36
37 fn absolute(&self, value: u64) {
38 match SystemTime::UNIX_EPOCH.elapsed() {
39 Ok(timestamp) => {
40 if let Err(_e) =
41 self.sender
42 .try_send(Event::AbsoluteCounter(timestamp, self.key.clone(), value))
43 {
44 #[cfg(feature = "log_dropped_metrics")]
45 error!(
46 "Error sending metric to SQLite thread: {}, dropping metric",
47 _e
48 );
49 }
50 }
51 Err(_e) => {
52 #[cfg(feature = "log_dropped_metrics")]
53 error!("Failed to get system time: {}, dropping metric", _e);
54 }
55 }
56 }
57}
58impl GaugeFn for Handle {
59 fn increment(&self, value: f64) {
60 match SystemTime::UNIX_EPOCH.elapsed() {
61 Ok(timestamp) => {
62 if let Err(_e) = self.sender.try_send(Event::UpdateGauge(
63 timestamp,
64 self.key.clone(),
65 GaugeValue::Increment(value),
66 )) {
67 #[cfg(feature = "log_dropped_metrics")]
68 error!(
69 "Error sending metric to SQLite thread: {}, dropping metric",
70 _e
71 );
72 }
73 }
74 Err(_e) => {
75 #[cfg(feature = "log_dropped_metrics")]
76 error!("Failed to get system time: {}, dropping metric", _e);
77 }
78 }
79 }
80
81 fn decrement(&self, value: f64) {
82 match SystemTime::UNIX_EPOCH.elapsed() {
83 Ok(timestamp) => {
84 if let Err(_e) = self.sender.try_send(Event::UpdateGauge(
85 timestamp,
86 self.key.clone(),
87 GaugeValue::Decrement(value),
88 )) {
89 #[cfg(feature = "log_dropped_metrics")]
90 error!(
91 "Error sending metric to SQLite thread: {}, dropping metric",
92 _e
93 );
94 }
95 }
96 Err(_e) => {
97 #[cfg(feature = "log_dropped_metrics")]
98 error!("Failed to get system time: {}, dropping metric", _e);
99 }
100 }
101 }
102
103 fn set(&self, value: f64) {
104 match SystemTime::UNIX_EPOCH.elapsed() {
105 Ok(timestamp) => {
106 if let Err(_e) = self.sender.try_send(Event::UpdateGauge(
107 timestamp,
108 self.key.clone(),
109 GaugeValue::Absolute(value),
110 )) {
111 #[cfg(feature = "log_dropped_metrics")]
112 error!(
113 "Error sending metric to SQLite thread: {}, dropping metric",
114 _e
115 );
116 }
117 }
118 Err(_e) => {
119 #[cfg(feature = "log_dropped_metrics")]
120 error!("Failed to get system time: {}, dropping metric", _e);
121 }
122 }
123 }
124}
125impl HistogramFn for Handle {
126 fn record(&self, value: f64) {
127 match SystemTime::UNIX_EPOCH.elapsed() {
128 Ok(timestamp) => {
129 if let Err(_e) =
130 self.sender
131 .try_send(Event::UpdateHistogram(timestamp, self.key.clone(), value))
132 {
133 #[cfg(feature = "log_dropped_metrics")]
134 error!(
135 "Error sending metric to SQLite thread: {}, dropping metric",
136 _e
137 );
138 }
139 }
140 Err(_e) => {
141 #[cfg(feature = "log_dropped_metrics")]
142 error!("Failed to get system time: {}, dropping metric", _e);
143 }
144 }
145 }
146}
147impl Recorder for SqliteExporter {
148 fn describe_counter(&self, key: KeyName, unit: Option<Unit>, description: SharedString) {
149 if let Err(e) = self.sender.try_send(Event::DescribeKey(
150 RegisterType::Counter,
151 key,
152 unit,
153 description,
154 )) {
155 error!("Error sending metric description: {:?}", e);
156 }
157 }
158
159 fn describe_gauge(&self, key: KeyName, unit: Option<Unit>, description: SharedString) {
160 if let Err(e) = self.sender.try_send(Event::DescribeKey(
161 RegisterType::Gauge,
162 key,
163 unit,
164 description,
165 )) {
166 error!("Error sending metric description: {:?}", e);
167 }
168 }
169
170 fn describe_histogram(&self, key: KeyName, unit: Option<Unit>, description: SharedString) {
171 if let Err(e) = self.sender.try_send(Event::DescribeKey(
172 RegisterType::Histogram,
173 key,
174 unit,
175 description,
176 )) {
177 error!("Error sending metric description: {:?}", e);
178 }
179 }
180
181 fn register_counter(&self, key: &Key) -> Counter {
183 let sender = self.sender.clone();
184 let handle = Arc::new(Handle {
185 sender,
186 key: key.clone(),
187 });
188 if let Err(e) = self.sender.try_send(Event::RegisterKey(
189 RegisterType::Counter,
190 key.clone(),
191 handle.clone(),
192 )) {
193 error!("Error sending metric registration: {:?}", e);
194 }
195 Counter::from_arc(handle)
196 }
197
198 fn register_gauge(&self, key: &Key) -> Gauge {
199 let sender = self.sender.clone();
200 let handle = Arc::new(Handle {
201 sender,
202 key: key.clone(),
203 });
204 if let Err(e) = self.sender.try_send(Event::RegisterKey(
205 RegisterType::Gauge,
206 key.clone(),
207 handle.clone(),
208 )) {
209 error!("Error sending metric registration: {:?}", e);
210 }
211 Gauge::from_arc(handle)
212 }
213
214 fn register_histogram(&self, key: &Key) -> Histogram {
215 let sender = self.sender.clone();
216 let handle = Arc::new(Handle {
217 sender,
218 key: key.clone(),
219 });
220 if let Err(e) = self.sender.try_send(Event::RegisterKey(
221 RegisterType::Histogram,
222 key.clone(),
223 handle.clone(),
224 )) {
225 error!("Error sending metric registration: {:?}", e);
226 }
227 Histogram::from_arc(handle)
228 }
229}