iocaine 2.4.1

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

// 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() {
                    if pair.name.is_none() || pair.value.is_none() {
                        continue;
                    }
                    labels.insert(
                        pair.name.as_ref().unwrap().to_string(),
                        Value::String(pair.value.as_ref().unwrap().to_string()),
                    );
                }

                if let Some(counter) = metric.get_counter().0.as_ref().unwrap().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).unwrap();
        writer.write_all(&result)?;

        Ok(())
    }

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