kitsune2_bootstrap_srv 0.5.0-dev.5

p2p / dht communication WAN discovery bootstrapping server
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
94
95
96
97
98
99
100
101
102
103
104

//! Bridges iroh-relay metrics to OpenTelemetry.
//!
//! The iroh relay server tracks metrics using `iroh_metrics::Counter` atomics.
//! This module registers OTEL observable counters whose callbacks read those
//! atomics at export time, so the metrics flow into whatever OTLP backend is
//! configured via `--otlp_endpoint`.

use iroh_relay::server::Metrics;
use opentelemetry::metrics::ObservableCounter;
use std::sync::Arc;

/// Holds the OTEL instrument handles returned by registration.
///
/// The observable counter callbacks remain active for as long as this struct
/// is alive. Drop it to unregister the callbacks.
#[must_use]
pub struct RelayOtelMetrics {
    _instruments: Vec<ObservableCounter<u64>>,
}

/// Register OTEL observable counters that bridge iroh-relay metrics.
///
/// Each counter reads the corresponding `iroh_metrics::Counter` atomic
/// when the OTEL SDK triggers an export. When no OTLP endpoint is
/// configured the meter is a no-op and the overhead is negligible.
pub fn register(metrics: Arc<Metrics>) -> RelayOtelMetrics {
    let meter = opentelemetry::global::meter("iroh-relay");

    // A small helper to cut down on the per-metric boilerplate.
    macro_rules! counter {
        ($name:expr, $desc:expr, $field:ident) => {{
            let m = metrics.clone();
            meter
                .u64_observable_counter($name)
                .with_description($desc)
                .with_callback(move |observer| {
                    observer.observe(m.$field.get(), &[]);
                })
                .build()
        }};
        ($name:expr, $desc:expr, $unit:expr, $field:ident) => {{
            let m = metrics.clone();
            meter
                .u64_observable_counter($name)
                .with_description($desc)
                .with_unit($unit)
                .with_callback(move |observer| {
                    observer.observe(m.$field.get(), &[]);
                })
                .build()
        }};
    }

    let instruments = vec![
        counter!(
            "relay.bytes_sent",
            "Total bytes sent through the relay",
            "By",
            bytes_sent
        ),
        counter!(
            "relay.bytes_recv",
            "Total bytes received by the relay",
            "By",
            bytes_recv
        ),
        counter!("relay.accepts", "Total relay connections accepted", accepts),
        counter!(
            "relay.disconnects",
            "Total relay client disconnections",
            disconnects
        ),
        counter!(
            "relay.unique_client_keys",
            "Total unique client keys seen",
            unique_client_keys
        ),
        counter!(
            "relay.send_packets_dropped",
            "Total send packets dropped",
            send_packets_dropped
        ),
        counter!(
            "relay.other_packets_dropped",
            "Total non-send packets dropped",
            other_packets_dropped
        ),
        counter!(
            "relay.bytes_rx_ratelimited",
            "Total bytes rate-limited on receive",
            "By",
            bytes_rx_ratelimited_total
        ),
        counter!(
            "relay.conns_rx_ratelimited",
            "Total connections that had frames rate-limited",
            conns_rx_ratelimited_total
        ),
    ];

    RelayOtelMetrics {
        _instruments: instruments,
    }
}