reth_provider/providers/database/
metrics.rs

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
use metrics::Histogram;
use reth_metrics::Metrics;
use std::time::{Duration, Instant};

#[derive(Debug)]
pub(crate) struct DurationsRecorder {
    start: Instant,
    current_metrics: DatabaseProviderMetrics,
    pub(crate) actions: Vec<(Action, Duration)>,
    latest: Option<Duration>,
}

impl Default for DurationsRecorder {
    fn default() -> Self {
        Self {
            start: Instant::now(),
            actions: Vec::new(),
            latest: None,
            current_metrics: DatabaseProviderMetrics::default(),
        }
    }
}

impl DurationsRecorder {
    /// Saves the provided duration for future logging and instantly reports as a metric with
    /// `action` label.
    pub(crate) fn record_duration(&mut self, action: Action, duration: Duration) {
        self.actions.push((action, duration));
        self.current_metrics.record_duration(action, duration);
        self.latest = Some(self.start.elapsed());
    }

    /// Records the duration since last record, saves it for future logging and instantly reports as
    /// a metric with `action` label.
    pub(crate) fn record_relative(&mut self, action: Action) {
        let elapsed = self.start.elapsed();
        let duration = elapsed - self.latest.unwrap_or_default();

        self.actions.push((action, duration));
        self.current_metrics.record_duration(action, duration);
        self.latest = Some(elapsed);
    }
}

#[derive(Debug, Copy, Clone)]
pub(crate) enum Action {
    InsertStorageHashing,
    InsertAccountHashing,
    InsertMerkleTree,
    InsertBlock,
    InsertState,
    InsertHashes,
    InsertHistoryIndices,
    UpdatePipelineStages,
    InsertCanonicalHeaders,
    InsertHeaders,
    InsertHeaderNumbers,
    InsertHeaderTerminalDifficulties,
    InsertBlockOmmers,
    InsertTransactionSenders,
    InsertTransactions,
    InsertTransactionHashNumbers,
    InsertBlockWithdrawals,
    InsertBlockBodyIndices,
    InsertTransactionBlocks,
    GetNextTxNum,
    GetParentTD,
}

/// Database provider metrics
#[derive(Metrics)]
#[metrics(scope = "storage.providers.database")]
struct DatabaseProviderMetrics {
    /// Duration of insert storage hashing
    insert_storage_hashing: Histogram,
    /// Duration of insert account hashing
    insert_account_hashing: Histogram,
    /// Duration of insert merkle tree
    insert_merkle_tree: Histogram,
    /// Duration of insert block
    insert_block: Histogram,
    /// Duration of insert state
    insert_state: Histogram,
    /// Duration of insert hashes
    insert_hashes: Histogram,
    /// Duration of insert history indices
    insert_history_indices: Histogram,
    /// Duration of update pipeline stages
    update_pipeline_stages: Histogram,
    /// Duration of insert canonical headers
    insert_canonical_headers: Histogram,
    /// Duration of insert headers
    insert_headers: Histogram,
    /// Duration of insert header numbers
    insert_header_numbers: Histogram,
    /// Duration of insert header TD
    insert_header_td: Histogram,
    /// Duration of insert block ommers
    insert_block_ommers: Histogram,
    /// Duration of insert tx senders
    insert_tx_senders: Histogram,
    /// Duration of insert transactions
    insert_transactions: Histogram,
    /// Duration of insert transaction hash numbers
    insert_tx_hash_numbers: Histogram,
    /// Duration of insert block withdrawals
    insert_block_withdrawals: Histogram,
    /// Duration of insert block body indices
    insert_block_body_indices: Histogram,
    /// Duration of insert transaction blocks
    insert_tx_blocks: Histogram,
    /// Duration of get next tx num
    get_next_tx_num: Histogram,
    /// Duration of get parent TD
    get_parent_td: Histogram,
}

impl DatabaseProviderMetrics {
    /// Records the duration for the given action.
    pub(crate) fn record_duration(&self, action: Action, duration: Duration) {
        match action {
            Action::InsertStorageHashing => self.insert_storage_hashing.record(duration),
            Action::InsertAccountHashing => self.insert_account_hashing.record(duration),
            Action::InsertMerkleTree => self.insert_merkle_tree.record(duration),
            Action::InsertBlock => self.insert_block.record(duration),
            Action::InsertState => self.insert_state.record(duration),
            Action::InsertHashes => self.insert_hashes.record(duration),
            Action::InsertHistoryIndices => self.insert_history_indices.record(duration),
            Action::UpdatePipelineStages => self.update_pipeline_stages.record(duration),
            Action::InsertCanonicalHeaders => self.insert_canonical_headers.record(duration),
            Action::InsertHeaders => self.insert_headers.record(duration),
            Action::InsertHeaderNumbers => self.insert_header_numbers.record(duration),
            Action::InsertHeaderTerminalDifficulties => self.insert_header_td.record(duration),
            Action::InsertBlockOmmers => self.insert_block_ommers.record(duration),
            Action::InsertTransactionSenders => self.insert_tx_senders.record(duration),
            Action::InsertTransactions => self.insert_transactions.record(duration),
            Action::InsertTransactionHashNumbers => self.insert_tx_hash_numbers.record(duration),
            Action::InsertBlockWithdrawals => self.insert_block_withdrawals.record(duration),
            Action::InsertBlockBodyIndices => self.insert_block_body_indices.record(duration),
            Action::InsertTransactionBlocks => self.insert_tx_blocks.record(duration),
            Action::GetNextTxNum => self.get_next_tx_num.record(duration),
            Action::GetParentTD => self.get_parent_td.record(duration),
        }
    }
}