sui_indexer_alt_jsonrpc/metrics/
mod.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
// Copyright (c) Mysten Labs, Inc.
// SPDX-License-Identifier: Apache-2.0

use std::sync::Arc;

use prometheus::{
    register_histogram_vec_with_registry, register_histogram_with_registry,
    register_int_counter_vec_with_registry, register_int_counter_with_registry, Histogram,
    HistogramVec, IntCounter, IntCounterVec, Registry,
};

pub(crate) mod middleware;

/// Histogram buckets for the distribution of latency (time between receiving a request and sending
/// a response).
const LATENCY_SEC_BUCKETS: &[f64] = &[
    0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 20.0, 50.0, 100.0,
    200.0, 500.0, 1000.0,
];

/// Histogram buckets for the distribution of the number of pages of data fetched/scanned from the
/// database.
const PAGE_SCAN_BUCKETS: &[f64] = &[1.0, 2.0, 5.0, 10.0, 20.0, 50.0, 100.0];

#[derive(Clone)]
pub struct RpcMetrics {
    pub db_latency: Histogram,
    pub db_requests_received: IntCounter,
    pub db_requests_succeeded: IntCounter,
    pub db_requests_failed: IntCounter,

    pub request_latency: HistogramVec,
    pub requests_received: IntCounterVec,
    pub requests_succeeded: IntCounterVec,
    pub requests_failed: IntCounterVec,

    pub owned_objects_filter_scans: Histogram,
}

impl RpcMetrics {
    pub(crate) fn new(registry: &Registry) -> Arc<Self> {
        Arc::new(Self {
            db_latency: register_histogram_with_registry!(
                "db_latency",
                "Time taken by the database to respond to queries",
                LATENCY_SEC_BUCKETS.to_vec(),
                registry,
            ).unwrap(),

            db_requests_received: register_int_counter_with_registry!(
                "db_requests_received",
                "Number of database requests sent by the service",
                registry,
            ).unwrap(),

            db_requests_succeeded: register_int_counter_with_registry!(
                "db_requests_succeeded",
                "Number of database requests that completed successfully",
                registry,
            ).unwrap(),

            db_requests_failed: register_int_counter_with_registry!(
                "db_requests_failed",
                "Number of database requests that completed with an error",
                registry,
            ).unwrap(),

            request_latency: register_histogram_vec_with_registry!(
                "rpc_request_latency",
                "Time taken to respond to JSON-RPC requests, by method",
                &["method"],
                LATENCY_SEC_BUCKETS.to_vec(),
                registry
            )
            .unwrap(),

            requests_received: register_int_counter_vec_with_registry!(
                "rpc_requests_received",
                "Number of requests initiated for each JSON-RPC method",
                &["method"],
                registry
            )
            .unwrap(),

            requests_succeeded: register_int_counter_vec_with_registry!(
                "rpc_requests_succeeded",
                "Number of requests that completed successfully for each JSON-RPC method",
                &["method"],
                registry
            )
            .unwrap(),

            requests_failed: register_int_counter_vec_with_registry!(
                "rpc_requests_failed",
                "Number of requests that completed with an error for each JSON-RPC method, by error code",
                &["method", "code"],
                registry
            )
            .unwrap(),

            owned_objects_filter_scans: register_histogram_with_registry!(
                "owned_objects_filter_scans",
                "Number of pages of owned objects scanned in response to compound owned object filters",
                PAGE_SCAN_BUCKETS.to_vec(),
                registry,
            )
            .unwrap(),
        })
    }
}