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