zksync_consensus_network 0.13.0

ZKsync consensus network component
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

//! Metrics for RPCs.

use std::{any::Any, time::Duration};

use vise::{
    Buckets, EncodeLabelSet, EncodeLabelValue, Family, Gauge, Histogram, LabeledFamily, Metrics,
    Unit,
};

use super::Rpc;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EncodeLabelValue)]
#[metrics(rename_all = "snake_case")]
pub(super) enum CallLatencyType {
    ClientSendRecv,
    ServerRecvSend,
    ServerProcess,
}

impl CallLatencyType {
    pub(super) fn to_labels<R: Rpc>(
        self,
        req: &R::Req,
        result: &anyhow::Result<impl Any>,
    ) -> CallLatencyLabels {
        CallLatencyLabels {
            r#type: self,
            method: R::METHOD,
            submethod: R::submethod(req),
            result: match result {
                Ok(_) => ResultLabel::Ok,
                Err(_) => ResultLabel::Err,
            },
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EncodeLabelValue)]
#[metrics(rename_all = "snake_case")]
enum ResultLabel {
    Ok,
    Err,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EncodeLabelSet)]
pub(super) struct CallLatencyLabels {
    r#type: CallLatencyType,
    method: &'static str,
    submethod: &'static str,
    result: ResultLabel,
}

impl CallLatencyLabels {
    pub(super) fn set_result(&mut self, result: &anyhow::Result<impl Any>) {
        self.result = match result {
            Ok(_) => ResultLabel::Ok,
            Err(_) => ResultLabel::Err,
        };
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EncodeLabelValue)]
#[metrics(rename_all = "snake_case")]
pub(super) enum CallType {
    Client,
    Server,
    ReqSent,
    ReqRecv,
    RespSent,
    RespRecv,
}

impl CallType {
    pub(super) fn to_labels<R: Rpc>(self, req: &R::Req) -> CallLabels {
        CallLabels {
            r#type: self,
            method: R::METHOD,
            submethod: R::submethod(req),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EncodeLabelSet)]
pub(super) struct CallLabels {
    r#type: CallType,
    method: &'static str,
    submethod: &'static str,
}

const MESSAGE_SIZE_BUCKETS: Buckets =
    Buckets::exponential(zksync_protobuf::kB as f64..=zksync_protobuf::MB as f64, 2.0);

#[derive(Debug, Metrics)]
#[metrics(prefix = "network_rpc")]
pub(super) struct RpcMetrics {
    /// Latency of RPCs in seconds.
    #[metrics(unit = Unit::Seconds, buckets = Buckets::LATENCIES)]
    pub(super) latency: Family<CallLatencyLabels, Histogram<Duration>>,
    /// Current number of executing RPCs.
    pub(super) inflight: Family<CallLabels, Gauge>,
    /// RPC message sizes in bytes.
    #[metrics(unit = Unit::Bytes, buckets = MESSAGE_SIZE_BUCKETS)]
    pub(super) message_size: Family<CallLabels, Histogram<usize>>,
    /// Time that client waits for the server to prepare a stream for an RPC call.
    #[metrics(unit = Unit::Seconds, buckets = Buckets::LATENCIES, labels = ["method"])]
    pub(super) call_reserve_latency: LabeledFamily<&'static str, Histogram<Duration>>,
}

#[vise::register]
pub(super) static RPC_METRICS: vise::Global<RpcMetrics> = vise::Global::new();