agave-votor 4.2.0

Blockchain, Rebuilt for Scale
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

use {
    solana_metrics::datapoint_info,
    std::{
        num::Saturating,
        time::{Duration, Instant},
    },
};

const STATS_REPORT_INTERVAL: Duration = Duration::from_secs(10);

#[derive(Debug)]
pub(super) struct ConsensusPoolServiceStats {
    pub(super) add_message_failed: Saturating<usize>,
    pub(super) certificates_sent: Saturating<usize>,
    pub(super) certificates_dropped: Saturating<usize>,
    pub(super) certificates_skipped_unstaked: Saturating<usize>,
    pub(super) new_finalized_slot: Saturating<usize>,
    pub(super) parent_ready_missed_window: Saturating<usize>,
    pub(super) parent_ready_produce_window: Saturating<usize>,
    pub(super) received_votes: Saturating<usize>,
    pub(super) received_certificates: Saturating<usize>,
    pub(super) standstill: bool,
    pub(super) prune_old_state_called: Saturating<usize>,
    pub(crate) pending_safe_to_notar_repair_sent: Saturating<usize>,
    pub(crate) pending_safe_to_notar_resolved: Saturating<usize>,
    last_request_time: Instant,
}

impl ConsensusPoolServiceStats {
    pub fn new() -> Self {
        Self {
            add_message_failed: Saturating(0),
            certificates_sent: Saturating(0),
            certificates_dropped: Saturating(0),
            certificates_skipped_unstaked: Saturating(0),
            new_finalized_slot: Saturating(0),
            parent_ready_missed_window: Saturating(0),
            parent_ready_produce_window: Saturating(0),
            received_votes: Saturating(0),
            received_certificates: Saturating(0),
            standstill: false,
            prune_old_state_called: Saturating(0),
            pending_safe_to_notar_repair_sent: Saturating(0),
            pending_safe_to_notar_resolved: Saturating(0),
            last_request_time: Instant::now(),
        }
    }

    fn report(&self) {
        let &Self {
            add_message_failed: Saturating(add_message_failed),
            certificates_sent: Saturating(certificates_sent),
            certificates_dropped: Saturating(certificates_dropped),
            certificates_skipped_unstaked: Saturating(certificates_skipped_unstaked),
            new_finalized_slot: Saturating(new_finalized_slot),
            parent_ready_missed_window: Saturating(parent_ready_missed_window),
            parent_ready_produce_window: Saturating(parent_ready_produce_window),
            received_votes: Saturating(received_votes),
            received_certificates: Saturating(received_certificates),
            standstill,
            prune_old_state_called: Saturating(prune_old_state_called),
            pending_safe_to_notar_repair_sent: Saturating(pending_safe_to_notar_repair_sent),
            pending_safe_to_notar_resolved: Saturating(pending_safe_to_notar_resolved),
            last_request_time: _,
        } = self;
        datapoint_info!(
            "consensus_pool_service",
            ("add_message_failed", add_message_failed, i64),
            ("certificates_sent", certificates_sent, i64),
            ("certificates_dropped", certificates_dropped, i64),
            (
                "certificates_skipped_unstaked",
                certificates_skipped_unstaked,
                i64
            ),
            ("new_finalized_slot", new_finalized_slot, i64),
            (
                "parent_ready_missed_window",
                parent_ready_missed_window,
                i64
            ),
            (
                "parent_ready_produce_window",
                parent_ready_produce_window,
                i64
            ),
            ("received_votes", received_votes, i64),
            ("received_certificates", received_certificates, i64),
            ("in_standstill_bool", standstill, bool),
            ("prune_old_state_called", prune_old_state_called, i64),
            (
                "pending_safe_to_notar_repair_sent",
                pending_safe_to_notar_repair_sent,
                i64
            ),
            (
                "pending_safe_to_notar_resolved",
                pending_safe_to_notar_resolved,
                i64
            ),
        );
    }

    pub(super) fn maybe_report(&mut self) {
        if self.last_request_time.elapsed() >= STATS_REPORT_INTERVAL {
            self.report();
            *self = Self::new();
        }
    }
}