iii-sdk 0.0.5

SDK for III Engine - a platform for building distributed 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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use opentelemetry::KeyValue;
use opentelemetry::metrics::Meter;
use std::sync::Arc;

use super::worker_metrics::WorkerMetricsCollector;

/// Options for registering worker gauges
pub struct WorkerGaugesOptions {
    pub worker_id: String,
    pub worker_name: Option<String>,
}

/// Register observable gauges for worker metrics with the given meter.
///
/// Returns a handle that keeps the gauges alive. Drop it to stop reporting.
pub fn register_worker_gauges(
    meter: &Meter,
    collector: Arc<WorkerMetricsCollector>,
    options: WorkerGaugesOptions,
) -> WorkerGaugesHandle {
    let mut attrs = vec![KeyValue::new("worker.id", options.worker_id)];
    if let Some(name) = options.worker_name {
        attrs.push(KeyValue::new("worker.name", name));
    }
    let attrs = Arc::new(attrs);

    let c = collector.clone();
    let a = attrs.clone();
    let memory_rss = meter
        .u64_observable_gauge("iii.worker.memory.rss")
        .with_description("Resident set size in bytes")
        .with_unit("By")
        .with_callback(move |observer| {
            let metrics = c.collect_cached();
            observer.observe(metrics.memory_rss, &a);
        })
        .build();

    let c = collector.clone();
    let a = attrs.clone();
    let memory_virtual = meter
        .u64_observable_gauge("iii.worker.memory.virtual")
        .with_description("Virtual memory in bytes")
        .with_unit("By")
        .with_callback(move |observer| {
            let metrics = c.collect_cached();
            observer.observe(metrics.memory_virtual, &a);
        })
        .build();

    let c = collector.clone();
    let a = attrs.clone();
    let cpu_percent = meter
        .f64_observable_gauge("iii.worker.cpu.percent")
        .with_description("CPU usage percentage")
        .with_unit("%")
        .with_callback(move |observer| {
            let metrics = c.collect_cached();
            observer.observe(metrics.cpu_percent as f64, &a);
        })
        .build();

    let c = collector.clone();
    let a = attrs.clone();
    let uptime = meter
        .f64_observable_gauge("iii.worker.uptime_seconds")
        .with_description("Worker uptime in seconds")
        .with_unit("s")
        .with_callback(move |observer| {
            let metrics = c.collect_cached();
            observer.observe(metrics.uptime_seconds, &a);
        })
        .build();

    WorkerGaugesHandle {
        _memory_rss: memory_rss,
        _memory_virtual: memory_virtual,
        _cpu_percent: cpu_percent,
        _uptime: uptime,
    }
}

/// Handle that keeps the OTEL gauges alive. Drop to stop reporting.
pub struct WorkerGaugesHandle {
    _memory_rss: opentelemetry::metrics::ObservableGauge<u64>,
    _memory_virtual: opentelemetry::metrics::ObservableGauge<u64>,
    _cpu_percent: opentelemetry::metrics::ObservableGauge<f64>,
    _uptime: opentelemetry::metrics::ObservableGauge<f64>,
}