subspace_farmer/farmer_cache/
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
//! Metrics for farmer cache

use prometheus_client::metrics::counter::Counter;
use prometheus_client::metrics::gauge::Gauge;
use prometheus_client::registry::{Registry, Unit};
use std::sync::atomic::{AtomicI64, AtomicU64};

/// Metrics for farmer cache
#[derive(Debug)]
pub(super) struct FarmerCacheMetrics {
    pub(super) cache_get_hit: Counter<u64, AtomicU64>,
    pub(super) cache_get_miss: Counter<u64, AtomicU64>,
    pub(super) cache_get_error: Counter<u64, AtomicU64>,
    pub(super) cache_find_hit: Counter<u64, AtomicU64>,
    pub(super) cache_find_miss: Counter<u64, AtomicU64>,
    pub(super) piece_cache_capacity_total: Gauge<i64, AtomicI64>,
    pub(super) piece_cache_capacity_used: Gauge<i64, AtomicI64>,
}

impl FarmerCacheMetrics {
    /// Create new instance
    pub(super) fn new(registry: &mut Registry) -> Self {
        let registry = registry.sub_registry_with_prefix("farmer_cache");

        let cache_get_hit = Counter::default();
        registry.register_with_unit(
            "cache_get_hit",
            "Cache get hit",
            Unit::Other("Requests".to_string()),
            cache_get_hit.clone(),
        );

        let cache_get_miss = Counter::default();
        registry.register_with_unit(
            "cache_get_miss",
            "Cache get miss",
            Unit::Other("Requests".to_string()),
            cache_get_miss.clone(),
        );

        let cache_get_error = Counter::default();
        registry.register_with_unit(
            "cache_error",
            "Cache get error",
            Unit::Other("Requests".to_string()),
            cache_get_error.clone(),
        );

        let cache_find_hit = Counter::default();
        registry.register_with_unit(
            "cache_find_hit",
            "Cache find hit",
            Unit::Other("Requests".to_string()),
            cache_find_hit.clone(),
        );

        let cache_find_miss = Counter::default();
        registry.register_with_unit(
            "cache_find_miss",
            "Cache find miss",
            Unit::Other("Requests".to_string()),
            cache_find_miss.clone(),
        );

        let piece_cache_capacity_total = Gauge::default();
        registry.register_with_unit(
            "piece_cache_capacity_total",
            "Piece cache capacity total",
            Unit::Other("Pieces".to_string()),
            piece_cache_capacity_total.clone(),
        );

        let piece_cache_capacity_used = Gauge::default();
        registry.register_with_unit(
            "piece_cache_capacity_used",
            "Piece cache capacity used",
            Unit::Other("Pieces".to_string()),
            piece_cache_capacity_used.clone(),
        );

        Self {
            cache_get_hit,
            cache_get_miss,
            cache_get_error,
            cache_find_hit,
            cache_find_miss,
            piece_cache_capacity_total,
            piece_cache_capacity_used,
        }
    }
}