i2pd-exporter 2.2.0

Prometheus exporter for i2pd (C++ via I2PControl). Not for Java I2P.
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

// I2PControl API type definitions

use serde::Deserialize;
use serde_aux::prelude::*;

// Result structure for the 'RouterInfo' method, containing various metrics
#[derive(Debug, Deserialize, Default)]
pub struct RouterInfoResult {
    #[serde(rename = "i2p.router.status")]
    #[serde(default, deserialize_with = "deserialize_option_number_from_string")]
    pub router_status: Option<u8>,
    #[serde(rename = "i2p.router.version")]
    pub router_version: Option<String>,
    #[serde(rename = "i2p.router.uptime")]
    #[serde(default, deserialize_with = "deserialize_option_number_from_string")]
    pub router_uptime: Option<u64>,
    #[serde(rename = "i2p.router.net.bw.inbound.1s")]
    pub bw_inbound_1s: Option<f64>,
    #[serde(rename = "i2p.router.net.bw.inbound.15s")]
    pub bw_inbound_15s: Option<f64>,
    #[serde(rename = "i2p.router.net.bw.outbound.1s")]
    pub bw_outbound_1s: Option<f64>,
    #[serde(rename = "i2p.router.net.bw.outbound.15s")]
    pub bw_outbound_15s: Option<f64>,
    #[serde(rename = "i2p.router.net.bw.transit.15s")]
    pub bw_transit_15s: Option<f64>,
    #[serde(rename = "i2p.router.net.status")]
    pub net_status: Option<u8>,
    #[serde(rename = "i2p.router.net.status.v6")]
    pub net_status_v6: Option<u8>,
    #[serde(rename = "i2p.router.net.error")]
    pub net_error: Option<u8>,
    #[serde(rename = "i2p.router.net.error.v6")]
    pub net_error_v6: Option<u8>,
    #[serde(rename = "i2p.router.net.testing")]
    #[serde(default, deserialize_with = "deserialize_option_number_from_string")]
    pub net_testing: Option<u8>,
    #[serde(rename = "i2p.router.net.testing.v6")]
    #[serde(default, deserialize_with = "deserialize_option_number_from_string")]
    pub net_testing_v6: Option<u8>,
    #[serde(rename = "i2p.router.net.tunnels.participating")]
    pub tunnels_participating: Option<u64>,
    #[serde(rename = "i2p.router.net.tunnels.inbound")]
    pub tunnels_inbound: Option<u64>,
    #[serde(rename = "i2p.router.net.tunnels.outbound")]
    pub tunnels_outbound: Option<u64>,
    #[serde(rename = "i2p.router.net.tunnels.successrate")]
    pub tunnels_successrate: Option<f64>,
    #[serde(rename = "i2p.router.net.tunnels.totalsuccessrate")]
    pub tunnels_total_successrate: Option<f64>,
    #[serde(rename = "i2p.router.net.tunnels.queue")]
    pub tunnels_queue: Option<u64>,
    #[serde(rename = "i2p.router.net.tunnels.tbmqueue")]
    pub tunnels_tbmqueue: Option<u64>,
    #[serde(rename = "i2p.router.netdb.activepeers")]
    pub netdb_activepeers: Option<u64>,
    #[serde(rename = "i2p.router.netdb.knownpeers")]
    pub netdb_knownpeers: Option<u64>,
    #[serde(rename = "i2p.router.netdb.floodfills")]
    pub netdb_floodfills: Option<u64>,
    #[serde(rename = "i2p.router.netdb.leasesets")]
    pub netdb_leasesets: Option<u64>,
    #[serde(rename = "i2p.router.net.total.received.bytes")]
    pub net_total_received_bytes: Option<f64>,
    #[serde(rename = "i2p.router.net.total.sent.bytes")]
    pub net_total_sent_bytes: Option<f64>,
    #[serde(rename = "i2p.router.net.total.transit.bytes")]
    pub net_total_transit_bytes: Option<f64>,
}

impl RouterInfoResult {
    // Merge data from another RouterInfoResult, preferring values from `other` when present.
    pub fn merge_from(&mut self, other: RouterInfoResult) {
        if let Some(v) = other.router_status {
            self.router_status = Some(v);
        }
        if let Some(v) = other.router_version {
            self.router_version = Some(v);
        }
        if let Some(v) = other.router_uptime {
            self.router_uptime = Some(v);
        }
        if let Some(v) = other.bw_inbound_1s {
            self.bw_inbound_1s = Some(v);
        }
        if let Some(v) = other.bw_inbound_15s {
            self.bw_inbound_15s = Some(v);
        }
        if let Some(v) = other.bw_outbound_1s {
            self.bw_outbound_1s = Some(v);
        }
        if let Some(v) = other.bw_outbound_15s {
            self.bw_outbound_15s = Some(v);
        }
        if let Some(v) = other.bw_transit_15s {
            self.bw_transit_15s = Some(v);
        }
        if let Some(v) = other.net_status {
            self.net_status = Some(v);
        }
        if let Some(v) = other.net_status_v6 {
            self.net_status_v6 = Some(v);
        }
        if let Some(v) = other.net_error {
            self.net_error = Some(v);
        }
        if let Some(v) = other.net_error_v6 {
            self.net_error_v6 = Some(v);
        }
        if let Some(v) = other.net_testing {
            self.net_testing = Some(v);
        }
        if let Some(v) = other.net_testing_v6 {
            self.net_testing_v6 = Some(v);
        }
        if let Some(v) = other.tunnels_participating {
            self.tunnels_participating = Some(v);
        }
        if let Some(v) = other.tunnels_inbound {
            self.tunnels_inbound = Some(v);
        }
        if let Some(v) = other.tunnels_outbound {
            self.tunnels_outbound = Some(v);
        }
        if let Some(v) = other.tunnels_successrate {
            self.tunnels_successrate = Some(v);
        }
        if let Some(v) = other.tunnels_total_successrate {
            self.tunnels_total_successrate = Some(v);
        }
        if let Some(v) = other.tunnels_queue {
            self.tunnels_queue = Some(v);
        }
        if let Some(v) = other.tunnels_tbmqueue {
            self.tunnels_tbmqueue = Some(v);
        }
        if let Some(v) = other.netdb_activepeers {
            self.netdb_activepeers = Some(v);
        }
        if let Some(v) = other.netdb_knownpeers {
            self.netdb_knownpeers = Some(v);
        }
        if let Some(v) = other.netdb_floodfills {
            self.netdb_floodfills = Some(v);
        }
        if let Some(v) = other.netdb_leasesets {
            self.netdb_leasesets = Some(v);
        }
        if let Some(v) = other.net_total_received_bytes {
            self.net_total_received_bytes = Some(v);
        }
        if let Some(v) = other.net_total_sent_bytes {
            self.net_total_sent_bytes = Some(v);
        }
        if let Some(v) = other.net_total_transit_bytes {
            self.net_total_transit_bytes = Some(v);
        }
    }
}