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