1use std::fmt::Write as FmtWrite;
2use std::sync::Arc;
3use std::time::Duration;
4
5use opentelemetry_sdk::error::OTelSdkError;
6use opentelemetry_sdk::metrics::Temporality;
7use opentelemetry_sdk::metrics::data::{
8 AggregatedMetrics, Gauge, Histogram, MetricData, ResourceMetrics, Sum,
9};
10use opentelemetry_sdk::metrics::exporter::PushMetricExporter;
11use tracing::debug;
12
13#[derive(Clone)]
15pub struct PrometheusExporter {
16 data: Arc<parking_lot::Mutex<Option<String>>>,
17}
18
19impl PrometheusExporter {
20 pub fn new() -> Self {
21 debug!("Creating new Prometheus exporter");
22 Self {
23 data: Arc::new(parking_lot::Mutex::new(None)),
24 }
25 }
26
27 pub fn get_metrics(&self) -> Option<String> {
29 let guard = self.data.lock();
30 guard.clone()
31 }
32
33 fn format_metrics(metrics: &ResourceMetrics) -> String {
35 let mut output = String::new();
36
37 for scope_metrics in metrics.scope_metrics() {
38 let scope_name = scope_metrics.scope().name();
39 for metric in scope_metrics.metrics() {
40 let metric_name = format!("{}_{}", scope_name, metric.name());
41 let description = metric.description();
42
43 writeln!(output, "# HELP {} {}", metric_name, description).ok();
45
46 match metric.data() {
48 AggregatedMetrics::F64(data) => {
49 Self::format_metric_data(&metric_name, data, &mut output, |v| v);
50 }
51 AggregatedMetrics::U64(data) => {
52 Self::format_metric_data(&metric_name, data, &mut output, |v| v as f64);
53 }
54 AggregatedMetrics::I64(data) => {
55 Self::format_metric_data(&metric_name, data, &mut output, |v| v as f64);
56 }
57 }
58 }
59 }
60
61 writeln!(output, "# EOF").ok();
62 output
63 }
64
65 fn format_metric_data<T>(
66 metric_name: &str,
67 data: &MetricData<T>,
68 output: &mut String,
69 to_f64: impl Fn(T) -> f64,
70 ) where
71 T: Copy,
72 {
73 match data {
74 MetricData::Sum(sum) => {
75 writeln!(output, "# TYPE {} counter", metric_name).ok();
76 Self::format_sum(metric_name, sum, output, to_f64);
77 }
78 MetricData::Gauge(gauge) => {
79 writeln!(output, "# TYPE {} gauge", metric_name).ok();
80 Self::format_gauge(metric_name, gauge, output, to_f64);
81 }
82 MetricData::Histogram(histogram) => {
83 writeln!(output, "# TYPE {} histogram", metric_name).ok();
84 Self::format_histogram(metric_name, histogram, output, to_f64);
85 }
86 MetricData::ExponentialHistogram(_) => {
87 }
89 }
90 }
91
92 fn format_sum<T>(
93 metric_name: &str,
94 sum: &Sum<T>,
95 output: &mut String,
96 to_f64: impl Fn(T) -> f64,
97 ) where
98 T: Copy,
99 {
100 for data_point in sum.data_points() {
101 let labels = format_attributes(data_point.attributes());
102 let value = to_f64(data_point.value());
103 writeln!(output, "{}_total{} {}", metric_name, labels, value).ok();
104 }
105 }
106
107 fn format_gauge<T>(
108 metric_name: &str,
109 gauge: &Gauge<T>,
110 output: &mut String,
111 to_f64: impl Fn(T) -> f64,
112 ) where
113 T: Copy,
114 {
115 for data_point in gauge.data_points() {
116 let labels = format_attributes(data_point.attributes());
117 let value = to_f64(data_point.value());
118 writeln!(output, "{}{} {}", metric_name, labels, value).ok();
119 }
120 }
121
122 fn format_histogram<T>(
123 metric_name: &str,
124 histogram: &Histogram<T>,
125 output: &mut String,
126 to_f64: impl Fn(T) -> f64,
127 ) where
128 T: Copy,
129 {
130 for data_point in histogram.data_points() {
131 let labels_base = format_attributes(data_point.attributes());
132
133 let bounds_vec: Vec<_> = data_point.bounds().collect();
135 let mut cumulative = 0u64;
136 for (i, count) in data_point.bucket_counts().enumerate() {
137 cumulative += count;
138 let bucket_label = if i < bounds_vec.len() {
139 format!("le=\"{}\"", bounds_vec[i])
140 } else {
141 "le=\"+Inf\"".to_string()
142 };
143
144 let labels = if labels_base.is_empty() {
145 format!("{{{}}}", bucket_label)
146 } else {
147 format!(
148 "{},{}}}",
149 &labels_base[..labels_base.len() - 1],
150 bucket_label
151 )
152 };
153
154 writeln!(output, "{}_bucket{} {}", metric_name, labels, cumulative).ok();
155 }
156
157 writeln!(
159 output,
160 "{}_sum{} {}",
161 metric_name,
162 labels_base,
163 to_f64(data_point.sum())
164 )
165 .ok();
166 writeln!(
167 output,
168 "{}_count{} {}",
169 metric_name,
170 labels_base,
171 data_point.count()
172 )
173 .ok();
174 }
175 }
176}
177
178impl Default for PrometheusExporter {
179 fn default() -> Self {
180 Self::new()
181 }
182}
183
184fn format_attributes<'a>(attrs: impl Iterator<Item = &'a opentelemetry::KeyValue>) -> String {
186 let collected: Vec<_> = attrs.collect();
187 if collected.is_empty() {
188 return String::new();
189 }
190
191 let mut labels = String::from("{");
192 for (i, kv) in collected.iter().enumerate() {
193 if i > 0 {
194 labels.push(',');
195 }
196 write!(labels, "{}=\"{}\"", kv.key.as_str(), kv.value).ok();
197 }
198 labels.push('}');
199 labels
200}
201
202impl PushMetricExporter for PrometheusExporter {
203 async fn export(&self, metrics: &ResourceMetrics) -> Result<(), OTelSdkError> {
204 let formatted = Self::format_metrics(metrics);
205 let mut guard = self.data.lock();
206 *guard = Some(formatted);
207 Ok(())
208 }
209
210 fn force_flush(&self) -> Result<(), OTelSdkError> {
211 Ok(())
212 }
213
214 fn shutdown(&self) -> Result<(), OTelSdkError> {
215 Ok(())
216 }
217
218 fn shutdown_with_timeout(&self, _timeout: Duration) -> Result<(), OTelSdkError> {
219 Ok(())
220 }
221
222 fn temporality(&self) -> Temporality {
223 Temporality::Cumulative
224 }
225}
226
227static PROMETHEUS_EXPORTER: parking_lot::Mutex<Option<PrometheusExporter>> =
229 parking_lot::Mutex::new(None);
230
231pub fn set_global_exporter(exporter: PrometheusExporter) {
233 debug!("Setting global Prometheus exporter");
234 let _ = PROMETHEUS_EXPORTER.lock().replace(exporter);
235}
236
237pub fn format_prometheus_metrics(_service_name: &str) -> Result<String, String> {
239 let exporter_guard = PROMETHEUS_EXPORTER.lock();
240
241 if let Some(exporter) = exporter_guard.as_ref() {
242 exporter
243 .get_metrics()
244 .ok_or_else(|| "No metrics available yet".to_string())
245 } else {
246 Err("Prometheus exporter not initialized".to_string())
247 }
248}
249
250#[cfg(test)]
251mod tests {
252 use super::*;
253 use opentelemetry::KeyValue;
254 use opentelemetry::metrics::{Meter, MeterProvider};
255
256 fn create_test_provider_and_exporter() -> (
257 opentelemetry_sdk::metrics::SdkMeterProvider,
258 PrometheusExporter,
259 Meter,
260 ) {
261 let exporter = PrometheusExporter::new();
262 let reader = opentelemetry_sdk::metrics::PeriodicReader::builder(exporter.clone())
263 .with_interval(std::time::Duration::from_millis(50))
264 .build();
265 let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder()
266 .with_reader(reader)
267 .build();
268 let meter = provider.meter("test");
269 (provider, exporter, meter)
270 }
271
272 async fn wait_for_export() {
273 tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
274 }
275
276 #[tokio::test]
277 async fn test_counter_export() {
278 let (_provider, exporter, meter) = create_test_provider_and_exporter();
279
280 let counter = meter
281 .u64_counter("test_counter")
282 .with_description("A test counter")
283 .build();
284
285 counter.add(5, &[KeyValue::new("label1", "value1")]);
286 counter.add(3, &[KeyValue::new("label1", "value2")]);
287
288 wait_for_export().await;
289
290 let metrics = exporter.get_metrics();
291 assert!(metrics.is_some(), "Metrics should be available");
292
293 let metrics_text = metrics.unwrap();
294 assert!(
295 metrics_text.contains("# HELP test_test_counter"),
296 "Should contain HELP line"
297 );
298 assert!(
299 metrics_text.contains("# TYPE test_test_counter counter"),
300 "Should contain TYPE line"
301 );
302 assert!(
303 metrics_text.contains("test_test_counter"),
304 "Should contain metric name"
305 );
306 }
307
308 #[tokio::test]
309 async fn test_gauge_export() {
310 let (_provider, exporter, meter) = create_test_provider_and_exporter();
311
312 let gauge = meter
313 .i64_gauge("test_gauge")
314 .with_description("A test gauge")
315 .build();
316
317 gauge.record(42, &[KeyValue::new("status", "active")]);
318
319 wait_for_export().await;
320
321 let metrics = exporter.get_metrics();
322 assert!(metrics.is_some(), "Metrics should be available");
323
324 let metrics_text = metrics.unwrap();
325 assert!(
326 metrics_text.contains("# HELP test_test_gauge"),
327 "Should contain HELP line"
328 );
329 assert!(
330 metrics_text.contains("# TYPE test_test_gauge gauge"),
331 "Should contain TYPE line"
332 );
333 }
334
335 #[tokio::test]
336 async fn test_histogram_export() {
337 let (_provider, exporter, meter) = create_test_provider_and_exporter();
338
339 let histogram = meter
340 .f64_histogram("test_histogram")
341 .with_description("A test histogram")
342 .build();
343
344 histogram.record(0.5, &[KeyValue::new("method", "GET")]);
345 histogram.record(1.5, &[KeyValue::new("method", "GET")]);
346
347 wait_for_export().await;
348
349 let metrics = exporter.get_metrics();
350 assert!(metrics.is_some(), "Metrics should be available");
351
352 let metrics_text = metrics.unwrap();
353 assert!(
354 metrics_text.contains("# HELP test_test_histogram"),
355 "Should contain HELP line"
356 );
357 assert!(
358 metrics_text.contains("# TYPE test_test_histogram histogram"),
359 "Should contain TYPE line"
360 );
361 assert!(
362 metrics_text.contains("test_test_histogram_bucket"),
363 "Should contain bucket metrics"
364 );
365 assert!(
366 metrics_text.contains("test_test_histogram_sum"),
367 "Should contain sum metric"
368 );
369 assert!(
370 metrics_text.contains("test_test_histogram_count"),
371 "Should contain count metric"
372 );
373 }
374
375 #[tokio::test]
376 async fn test_multiple_labels() {
377 let (_provider, exporter, meter) = create_test_provider_and_exporter();
378
379 let counter = meter.u64_counter("multi_label_counter").build();
380
381 counter.add(
382 1,
383 &[
384 KeyValue::new("controller", "kanidm"),
385 KeyValue::new("namespace", "default"),
386 KeyValue::new("action", "reconcile"),
387 ],
388 );
389
390 wait_for_export().await;
391
392 let metrics = exporter.get_metrics();
393 assert!(metrics.is_some(), "Metrics should be available");
394
395 let metrics_text = metrics.unwrap();
396 assert!(
397 metrics_text.contains("controller="),
398 "Should contain controller label"
399 );
400 assert!(
401 metrics_text.contains("namespace="),
402 "Should contain namespace label"
403 );
404 assert!(
405 metrics_text.contains("action="),
406 "Should contain action label"
407 );
408 }
409
410 #[test]
411 fn test_format_attributes_empty() {
412 let attrs: [KeyValue; 0] = [];
413 let result = format_attributes(attrs.iter());
414 assert_eq!(result, "", "Empty attributes should return empty string");
415 }
416
417 #[test]
418 fn test_format_attributes_single() {
419 let attrs = [KeyValue::new("key", "value")];
420 let result = format_attributes(attrs.iter());
421 assert_eq!(result, r#"{key="value"}"#);
422 }
423
424 #[test]
425 fn test_format_attributes_multiple() {
426 let attrs = [
427 KeyValue::new("key1", "value1"),
428 KeyValue::new("key2", "value2"),
429 ];
430 let result = format_attributes(attrs.iter());
431 assert_eq!(result, r#"{key1="value1",key2="value2"}"#);
432 }
433
434 #[tokio::test]
435 async fn test_global_exporter() {
436 let exporter = PrometheusExporter::new();
437 set_global_exporter(exporter.clone());
438
439 let reader = opentelemetry_sdk::metrics::PeriodicReader::builder(exporter)
440 .with_interval(std::time::Duration::from_millis(50))
441 .build();
442 let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder()
443 .with_reader(reader)
444 .build();
445 let meter = provider.meter("global_test");
446
447 let counter = meter.u64_counter("global_counter").build();
448 counter.add(1, &[]);
449
450 wait_for_export().await;
451
452 let result = format_prometheus_metrics("test");
453 assert!(result.is_ok(), "Should get metrics from global exporter");
454 }
455}