slatedb 0.10.0

A cloud native embedded storage engine built on object storage.
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

use crate::stats::{Counter, Gauge, StatRegistry};
use std::sync::Arc;

macro_rules! db_stat_name {
    ($suffix:expr) => {
        crate::stat_name!("db", $suffix)
    };
}

pub const IMMUTABLE_MEMTABLE_FLUSHES: &str = db_stat_name!("immutable_memtable_flushes");
pub const SST_FILTER_FALSE_POSITIVES: &str = db_stat_name!("sst_filter_false_positives");
pub const SST_FILTER_POSITIVES: &str = db_stat_name!("sst_filter_positives");
pub const SST_FILTER_NEGATIVES: &str = db_stat_name!("sst_filter_negatives");
pub const BACKPRESSURE_COUNT: &str = db_stat_name!("backpressure_count");
pub const WAL_BUFFER_ESTIMATED_BYTES: &str = db_stat_name!("wal_buffer_estimated_bytes");
pub const WAL_BUFFER_FLUSHES: &str = db_stat_name!("wal_buffer_flushes");
pub const GET_REQUESTS: &str = db_stat_name!("get_requests");
pub const SCAN_REQUESTS: &str = db_stat_name!("scan_requests");
pub const WRITE_BATCH_COUNT: &str = db_stat_name!("write_batch_count");
pub const WRITE_OPS: &str = db_stat_name!("write_ops");
pub const TOTAL_MEM_SIZE_BYTES: &str = db_stat_name!("total_mem_size_bytes");
pub const L0_SST_COUNT: &str = db_stat_name!("l0_sst_count");

#[non_exhaustive]
#[derive(Clone, Debug)]
pub(crate) struct DbStats {
    pub(crate) immutable_memtable_flushes: Arc<Counter>,
    pub(crate) wal_buffer_estimated_bytes: Arc<Gauge<i64>>,
    pub(crate) wal_buffer_flushes: Arc<Counter>,
    pub(crate) sst_filter_false_positives: Arc<Counter>,
    pub(crate) sst_filter_positives: Arc<Counter>,
    pub(crate) sst_filter_negatives: Arc<Counter>,
    pub(crate) backpressure_count: Arc<Counter>,
    pub(crate) get_requests: Arc<Counter>,
    pub(crate) scan_requests: Arc<Counter>,
    pub(crate) write_batch_count: Arc<Counter>,
    pub(crate) write_ops: Arc<Counter>,
    pub(crate) total_mem_size_bytes: Arc<Gauge<i64>>,
    pub(crate) l0_sst_count: Arc<Gauge<i64>>,
}

impl DbStats {
    pub(crate) fn new(registry: &StatRegistry) -> DbStats {
        let stats = Self {
            immutable_memtable_flushes: Arc::new(Counter::default()),
            wal_buffer_estimated_bytes: Arc::new(Gauge::default()),
            wal_buffer_flushes: Arc::new(Counter::default()),
            sst_filter_false_positives: Arc::new(Counter::default()),
            sst_filter_positives: Arc::new(Counter::default()),
            sst_filter_negatives: Arc::new(Counter::default()),
            backpressure_count: Arc::new(Counter::default()),
            get_requests: Arc::new(Counter::default()),
            scan_requests: Arc::new(Counter::default()),
            write_batch_count: Arc::new(Counter::default()),
            write_ops: Arc::new(Counter::default()),
            total_mem_size_bytes: Arc::new(Gauge::default()),
            l0_sst_count: Arc::new(Gauge::default()),
        };
        registry.register(
            IMMUTABLE_MEMTABLE_FLUSHES,
            stats.immutable_memtable_flushes.clone(),
        );
        registry.register(
            WAL_BUFFER_ESTIMATED_BYTES,
            stats.wal_buffer_estimated_bytes.clone(),
        );
        registry.register(WAL_BUFFER_FLUSHES, stats.wal_buffer_flushes.clone());
        registry.register(
            SST_FILTER_FALSE_POSITIVES,
            stats.sst_filter_false_positives.clone(),
        );
        registry.register(SST_FILTER_POSITIVES, stats.sst_filter_positives.clone());
        registry.register(SST_FILTER_NEGATIVES, stats.sst_filter_negatives.clone());
        registry.register(BACKPRESSURE_COUNT, stats.backpressure_count.clone());
        registry.register(GET_REQUESTS, stats.get_requests.clone());
        registry.register(SCAN_REQUESTS, stats.scan_requests.clone());
        registry.register(WRITE_BATCH_COUNT, stats.write_batch_count.clone());
        registry.register(WRITE_OPS, stats.write_ops.clone());
        registry.register(TOTAL_MEM_SIZE_BYTES, stats.total_mem_size_bytes.clone());
        registry.register(L0_SST_COUNT, stats.l0_sst_count.clone());
        stats
    }
}