harn-vm 0.10.89

Async bytecode virtual machine for the Harn programming language
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
75
76
77
78
79
80
81

//! LLM transaction-ledger projections for the shared runtime metrics surface.

use super::{labels, MetricsRegistry};
use crate::llm::usage::{summarize_usage_cost_certainty, LlmUsage};

impl MetricsRegistry {
    pub(crate) fn record_llm_call(
        &self,
        provider: &str,
        model: &str,
        outcome: &str,
        usage: &LlmUsage,
    ) {
        self.increment_counter(
            "harn_llm_calls_total",
            labels([
                ("provider", provider),
                ("model", model),
                ("outcome", outcome),
            ]),
            1,
        );
        let accounting_labels = labels([("provider", provider), ("model", model)]);
        let certainty = summarize_usage_cost_certainty([usage]);
        if certainty.known_cost_usd > 0.0 {
            self.increment_counter(
                "harn_llm_cost_usd_total",
                accounting_labels.clone(),
                certainty.known_cost_usd,
            );
        } else {
            self.ensure_counter("harn_llm_cost_usd_total", accounting_labels.clone());
        }
        self.increment_counter(
            "harn_llm_provider_requests_total",
            accounting_labels.clone(),
            certainty.provider_call_count as f64,
        );
        self.increment_counter(
            "harn_llm_unpriced_requests_total",
            accounting_labels.clone(),
            certainty.unpriced_calls as f64,
        );
        self.increment_counter(
            "harn_llm_usage_unknown_requests_total",
            accounting_labels,
            certainty.usage_unknown_calls as f64,
        );
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn call_metrics_preserve_physical_request_spend_certainty() {
        let metrics = MetricsRegistry::default();
        let usage = LlmUsage {
            cost_usd: None,
            known_cost_usd: 0.01,
            provider_call_count: 2,
            unpriced_calls: 1,
            usage_unknown_calls: 1,
            ..LlmUsage::known_zero_attempt()
        };

        metrics.record_llm_call("mock", "mock", "succeeded", &usage);

        let rendered = metrics.render_prometheus();
        for needle in [
            "harn_llm_calls_total{model=\"mock\",outcome=\"succeeded\",provider=\"mock\"} 1",
            "harn_llm_cost_usd_total{model=\"mock\",provider=\"mock\"} 0.01",
            "harn_llm_provider_requests_total{model=\"mock\",provider=\"mock\"} 2",
            "harn_llm_unpriced_requests_total{model=\"mock\",provider=\"mock\"} 1",
            "harn_llm_usage_unknown_requests_total{model=\"mock\",provider=\"mock\"} 1",
        ] {
            assert!(rendered.contains(needle), "missing {needle}\n{rendered}");
        }
    }
}