iocaine 3.0.0

The deadliest poison known to AI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

// SPDX-FileCopyrightText: 2025 Gergely Nagy
// SPDX-FileContributor: Gergely Nagy
//
// SPDX-License-Identifier: MIT

use prometheus::{
    Encoder, Result,
    proto::{MetricFamily, MetricType},
};
use serde_json::{Map, Value};
use std::io::Write;

#[derive(Debug, Default)]
pub struct HRT;

impl HRT {
    #[must_use]
    pub fn new() -> Self {
        Self
    }
}

impl Encoder for HRT {
    fn encode<W: Write>(&self, metric_families: &[MetricFamily], writer: &mut W) -> Result<()> {
        let mut map = Map::new();

        for metric_family in metric_families {
            let name = metric_family.name();

            if metric_family.get_field_type() != MetricType::COUNTER {
                continue;
            }

            let mut metrics = Vec::new();
            for metric in metric_family.get_metric() {
                let mut metric_map = Map::new();

                let mut labels = Map::new();
                for pair in metric.get_label() {
                    let (Some(name), Some(value)) = (pair.name.as_ref(), pair.value.as_ref())
                    else {
                        continue;
                    };
                    labels.insert(name.to_string(), Value::String(value.to_string()));
                }

                let Some(counter) = metric.get_counter().0.as_ref() else {
                    continue;
                };

                if let Some(counter) = counter.value {
                    metric_map.insert("labels".to_owned(), Value::Object(labels));

                    metric_map.insert(
                        "value".to_owned(),
                        Value::Number(serde_json::Number::from_f64(counter).unwrap()),
                    );
                    metrics.push(Value::Object(metric_map));
                }
            }
            map.insert(name.to_owned(), Value::Array(metrics));
        }

        let result =
            serde_json::to_vec(&map).map_err(|e| prometheus::Error::Msg(format!("{e}")))?;
        writer.write_all(&result)?;

        Ok(())
    }

    fn format_type(&self) -> &'static str {
        "application/json"
    }
}