commonware-resolver 2026.4.0

Resolve data identified by a fixed-length key.
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
82
83
84
85
86
87
88
89
90
91
92
93

use commonware_runtime::{
    telemetry::metrics::{histogram, status},
    Clock, Metrics as RuntimeMetrics,
};
use prometheus_client::metrics::{gauge::Gauge, histogram::Histogram};
use std::sync::Arc;

/// Metrics for the peer actor.
pub struct Metrics<E: RuntimeMetrics + Clock> {
    /// Current number of pending fetch requests
    pub fetch_pending: Gauge,
    /// Current number of active fetch requests
    pub fetch_active: Gauge,
    /// Current number of serves currently in flight
    pub serve_processing: Gauge,
    /// Current number of blocked peers
    pub peers_blocked: Gauge,
    /// Number of fetches by status
    pub fetch: status::Counter,
    /// Number of canceled fetches by status
    pub cancel: status::Counter,
    /// Number of serves by status
    pub serve: status::Counter,
    /// Histogram of successful serves
    pub serve_duration: histogram::Timed<E>,
    /// Histogram of successful fetches
    pub fetch_duration: histogram::Timed<E>,
}

impl<E: RuntimeMetrics + Clock> Metrics<E> {
    /// Create and return a new set of metrics, registered with the given context.
    pub fn init(context: E) -> Self {
        let fetch_pending = Gauge::default();
        context.register(
            "fetch_pending",
            "Current number of pending fetch requests",
            fetch_pending.clone(),
        );
        let fetch_active = Gauge::default();
        context.register(
            "fetch_active",
            "Current number of active fetch requests",
            fetch_active.clone(),
        );
        let serve_processing = Gauge::default();
        context.register(
            "serve_processing",
            "Current number of serves currently processing",
            serve_processing.clone(),
        );
        let peers_blocked = Gauge::default();
        context.register(
            "peers_blocked",
            "Current number of blocked peers",
            peers_blocked.clone(),
        );
        let fetch = status::Counter::default();
        context.register("fetch", "Number of fetches by status", fetch.clone());
        let cancel = status::Counter::default();
        context.register(
            "cancel",
            "Number of canceled fetches by status",
            cancel.clone(),
        );
        let serve = status::Counter::default();
        context.register("serve", "Number of serves by status", serve.clone());
        let serve_duration = Histogram::new(histogram::Buckets::LOCAL);
        context.register(
            "serve_duration",
            "Histogram of successful serves",
            serve_duration.clone(),
        );
        let fetch_duration = Histogram::new(histogram::Buckets::NETWORK);
        context.register(
            "fetch_duration",
            "Histogram of successful fetches",
            fetch_duration.clone(),
        );
        let clock = Arc::new(context);

        Self {
            fetch_pending,
            fetch_active,
            serve_processing,
            peers_blocked,
            fetch,
            cancel,
            serve,
            fetch_duration: histogram::Timed::new(fetch_duration, clock.clone()),
            serve_duration: histogram::Timed::new(serve_duration, clock),
        }
    }
}