cobble 0.1.1

A flexible embedded key-value storage engine for distributed systems as well as single-node applications.
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

use crate::compaction::CompactionTaskMetrics;
use crate::file::FileManagerMetrics;
use crate::memtable::MemtableManagerMetrics;
use crate::sst::{SSTIteratorMetrics, SSTWriterMetrics, SstCompressionAlgorithm};
use std::sync::Arc;

#[derive(Clone)]
pub struct MetricsManager {
    db_id: String,
    sst_iterator_metrics: Arc<SSTIteratorMetrics>,
    compaction_metrics: Arc<CompactionTaskMetrics>,
    memtable_metrics: MemtableManagerMetrics,
    file_manager_metrics: FileManagerMetrics,
    sst_writer_metrics_none: SSTWriterMetrics,
    sst_writer_metrics_lz4: SSTWriterMetrics,
}

impl MetricsManager {
    pub(crate) fn new(db_id: impl AsRef<str>) -> Self {
        let db_id = db_id.as_ref();
        let sst_iterator_metrics = Arc::new(SSTIteratorMetrics::new(db_id));
        let compaction_metrics = Arc::new(CompactionTaskMetrics::new(db_id));
        let memtable_metrics = MemtableManagerMetrics::new(db_id);
        let file_manager_metrics = FileManagerMetrics::new(db_id);
        let sst_writer_metrics_none = SSTWriterMetrics::new(db_id, SstCompressionAlgorithm::None);
        let sst_writer_metrics_lz4 = SSTWriterMetrics::new(db_id, SstCompressionAlgorithm::Lz4);
        Self {
            db_id: db_id.to_string(),
            sst_iterator_metrics,
            compaction_metrics,
            memtable_metrics,
            file_manager_metrics,
            sst_writer_metrics_none,
            sst_writer_metrics_lz4,
        }
    }

    pub(crate) fn db_id(&self) -> &str {
        &self.db_id
    }

    pub(crate) fn sst_iterator_metrics(&self) -> Arc<SSTIteratorMetrics> {
        Arc::clone(&self.sst_iterator_metrics)
    }

    pub(crate) fn compaction_metrics(&self) -> Arc<CompactionTaskMetrics> {
        Arc::clone(&self.compaction_metrics)
    }

    pub(crate) fn memtable_metrics(&self) -> MemtableManagerMetrics {
        self.memtable_metrics.clone()
    }

    pub(crate) fn file_manager_metrics(&self) -> FileManagerMetrics {
        self.file_manager_metrics.clone()
    }

    pub(crate) fn sst_writer_metrics(
        &self,
        compression: SstCompressionAlgorithm,
    ) -> SSTWriterMetrics {
        match compression {
            SstCompressionAlgorithm::None => self.sst_writer_metrics_none.clone(),
            SstCompressionAlgorithm::Lz4 => self.sst_writer_metrics_lz4.clone(),
        }
    }
}