rust_observer 0.2.2

Express telemetry rust SDK
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

use super::{exporters::MetricsExporter, Metrics, MetricsExporterManager, SystemMetricsCollector};
use crate::metrics::exporters::METRICS_EXPORTER_MANAGER;

pub struct MetricsBuilder {
    interval_secs: u64,
    exporter: Option<Box<dyn MetricsExporter>>,
    http_metrics_enabled: bool,
    grpc_metrics_enabled: bool,
    websocket_metrics_enabled: bool,
    system_metrics_enabled: bool,
    process_metrics_enabled: bool,
}

impl MetricsBuilder {
    pub fn new() -> Self {
        Self {
            interval_secs: 10,
            exporter: None,
            http_metrics_enabled: false,
            grpc_metrics_enabled: false,
            websocket_metrics_enabled: false,
            system_metrics_enabled: false,
            process_metrics_enabled: false,
        }
    }

    pub fn with_interval_secs(mut self, interval_secs: u64) -> Self {
        self.interval_secs = interval_secs;
        self
    }

    pub fn with_exporter(mut self, exporter: Box<dyn MetricsExporter>) -> Self {
        self.exporter = Some(exporter);
        self
    }

    pub fn with_http_metrics(mut self) -> Self {
        self.http_metrics_enabled = true;
        self
    }

    pub fn with_grpc_metrics(mut self) -> Self {
        self.grpc_metrics_enabled = true;
        self
    }

    pub fn with_websocket_metrics(mut self) -> Self {
        self.websocket_metrics_enabled = true;
        self
    }

    pub fn with_system_metrics(mut self) -> Self {
        self.system_metrics_enabled = true;
        self
    }

    pub fn with_process_metrics(mut self) -> Self {
        self.process_metrics_enabled = true;
        self
    }

    pub fn initialize(self) {
        if let Some(exporter) = self.exporter {
            let exporter_manager = MetricsExporterManager::new(10000, vec![exporter]);
            *METRICS_EXPORTER_MANAGER.write() = Some(exporter_manager.clone());

            let interval_secs = self.interval_secs;
            let http_enabled = self.http_metrics_enabled;
            let grpc_enabled = self.grpc_metrics_enabled;
            let websocket_enabled = self.websocket_metrics_enabled;
            let system_enabled = self.system_metrics_enabled;
            let process_enabled = self.process_metrics_enabled;

            tokio::spawn(async move {
                let mut interval = tokio::time::interval(std::time::Duration::from_secs(interval_secs));
                let mut metrics = Metrics::new(interval_secs);
                let system_metrics_collector = SystemMetricsCollector::new();

                loop {
                    interval.tick().await;
                    metrics.collect_all_metrics(
                        &system_metrics_collector,
                        http_enabled,
                        grpc_enabled,
                        websocket_enabled,
                        system_enabled,
                        process_enabled,
                    ).await;
                    exporter_manager.send_metrics(metrics.clone());
                }
            });
        }
    }
}