Skip to main content

kaniop_operator/
prometheus_exporter.rs

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/// In-memory Prometheus text format exporter
14#[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    /// Get the latest metrics in Prometheus text format
28    pub fn get_metrics(&self) -> Option<String> {
29        let guard = self.data.lock();
30        guard.clone()
31    }
32
33    /// Convert OpenTelemetry metrics to Prometheus text format
34    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                // Write HELP line
44                writeln!(output, "# HELP {} {}", metric_name, description).ok();
45
46                // Write TYPE line and data based on metric type
47                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                // Skip exponential histograms for now
88            }
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            // Write bucket counts
134            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            // Write sum and count
158            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
184/// Format OpenTelemetry attributes as Prometheus labels
185fn 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
227/// Global Prometheus exporter instance
228static PROMETHEUS_EXPORTER: parking_lot::Mutex<Option<PrometheusExporter>> =
229    parking_lot::Mutex::new(None);
230
231/// Set the global Prometheus exporter instance
232pub fn set_global_exporter(exporter: PrometheusExporter) {
233    debug!("Setting global Prometheus exporter");
234    let _ = PROMETHEUS_EXPORTER.lock().replace(exporter);
235}
236
237/// Format Prometheus metrics from the global exporter
238pub 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}