kaniop_operator/
prometheus_exporter.rs

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/// In-memory Prometheus text format exporter
14#[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    /// Get the latest metrics in Prometheus text format
28    pub fn get_metrics(&self) -> Option<String> {
29        self.data.lock().unwrap().clone()
30    }
31
32    /// Convert OpenTelemetry metrics to Prometheus text format
33    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                // Write HELP line
43                writeln!(output, "# HELP {} {}", metric_name, description).ok();
44
45                // Write TYPE line and data based on metric type
46                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                // Skip exponential histograms for now
86            }
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            // Write bucket counts
132            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            // Write sum and count
156            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
182/// Format OpenTelemetry attributes as Prometheus labels
183fn 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
224/// Global Prometheus exporter instance
225static PROMETHEUS_EXPORTER: Mutex<Option<PrometheusExporter>> = Mutex::new(None);
226
227/// Set the global Prometheus exporter instance
228pub fn set_global_exporter(exporter: PrometheusExporter) {
229    debug!("Setting global Prometheus exporter");
230    *PROMETHEUS_EXPORTER.lock().unwrap() = Some(exporter);
231}
232
233/// Format Prometheus metrics from the global exporter
234pub 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}