rustfoundry 4.2.0

A Rust service rustfoundry library.
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::telemetry::tokio_runtime_metrics::metrics::{tokio_runtime_core, tokio_runtime_worker};
use std::sync::atomic::Ordering;
use std::sync::Arc;
use tokio::runtime::{Handle, RuntimeMetrics};

pub(super) struct RuntimeHandle {
    pub(super) runtime_name: Option<Arc<str>>,
    pub(super) runtime_id: Option<usize>,
    pub(super) handle: Handle,
}

impl RuntimeHandle {
    pub(super) fn record_sample(&mut self) {
        let metrics = self.handle.metrics();

        self.record_global_metrics(&metrics);

        for worker_idx in 0..metrics.num_workers() {
            self.record_worker_metrics(&metrics, worker_idx);
        }
    }

    fn record_global_metrics(&mut self, metrics: &RuntimeMetrics) {
        tokio_runtime_core::workers(&self.runtime_name, self.runtime_id)
            .set(metrics.num_workers() as u64);

        tokio_runtime_core::blocking_threads(&self.runtime_name, self.runtime_id)
            .set(metrics.num_blocking_threads() as u64);

        tokio_runtime_core::num_alive_tasks(&self.runtime_name, self.runtime_id)
            .set(metrics.num_alive_tasks() as u64);

        tokio_runtime_core::idle_blocking_threads(&self.runtime_name, self.runtime_id)
            .set(metrics.num_idle_blocking_threads() as u64);

        tokio_runtime_core::remote_schedules_total(&self.runtime_name, self.runtime_id)
            .inner()
            .store(metrics.remote_schedule_count(), Ordering::SeqCst);

        tokio_runtime_core::budget_forced_yields_total(&self.runtime_name, self.runtime_id)
            .inner()
            .store(metrics.budget_forced_yield_count(), Ordering::SeqCst);

        tokio_runtime_core::io_driver_fd_registrations_total(&self.runtime_name, self.runtime_id)
            .inner()
            .store(metrics.io_driver_fd_registered_count(), Ordering::SeqCst);

        tokio_runtime_core::io_driver_fd_deregistrations_total(&self.runtime_name, self.runtime_id)
            .inner()
            .store(metrics.io_driver_fd_deregistered_count(), Ordering::SeqCst);

        tokio_runtime_core::io_driver_fd_readies_total(&self.runtime_name, self.runtime_id)
            .inner()
            .store(metrics.io_driver_ready_count(), Ordering::SeqCst);

        tokio_runtime_core::global_queue_depth(&self.runtime_name, self.runtime_id)
            .set(metrics.global_queue_depth() as u64);

        tokio_runtime_core::blocking_queue_depth(&self.runtime_name, self.runtime_id)
            .set(metrics.blocking_queue_depth() as u64);
    }

    fn record_worker_metrics(&mut self, metrics: &RuntimeMetrics, worker_idx: usize) {
        tokio_runtime_worker::parks_total(&self.runtime_name, self.runtime_id, worker_idx)
            .inner()
            .store(metrics.worker_park_count(worker_idx), Ordering::SeqCst);

        tokio_runtime_worker::noops_total(&self.runtime_name, self.runtime_id, worker_idx)
            .inner()
            .store(metrics.worker_noop_count(worker_idx), Ordering::SeqCst);

        tokio_runtime_worker::task_steals_total(&self.runtime_name, self.runtime_id, worker_idx)
            .inner()
            .store(metrics.worker_steal_count(worker_idx), Ordering::SeqCst);

        tokio_runtime_worker::steal_operations_total(
            &self.runtime_name,
            self.runtime_id,
            worker_idx,
        )
        .inner()
        .store(
            metrics.worker_steal_operations(worker_idx),
            Ordering::SeqCst,
        );

        tokio_runtime_worker::polls_total(&self.runtime_name, self.runtime_id, worker_idx)
            .inner()
            .store(metrics.worker_poll_count(worker_idx), Ordering::SeqCst);

        tokio_runtime_worker::busy_duration_micros_total(
            &self.runtime_name,
            self.runtime_id,
            worker_idx,
        )
        .inner()
        .store(
            metrics.worker_total_busy_duration(worker_idx).as_micros() as u64,
            Ordering::SeqCst,
        );

        tokio_runtime_worker::local_schedules_total(
            &self.runtime_name,
            self.runtime_id,
            worker_idx,
        )
        .inner()
        .store(
            metrics.worker_local_schedule_count(worker_idx),
            Ordering::SeqCst,
        );

        tokio_runtime_worker::overflows_total(&self.runtime_name, self.runtime_id, worker_idx)
            .inner()
            .store(metrics.worker_overflow_count(worker_idx), Ordering::SeqCst);

        tokio_runtime_worker::local_queue_depth(&self.runtime_name, self.runtime_id, worker_idx)
            .set(metrics.worker_local_queue_depth(worker_idx) as u64);

        tokio_runtime_worker::mean_poll_time_micros(
            &self.runtime_name,
            self.runtime_id,
            worker_idx,
        )
        .set(metrics.worker_mean_poll_time(worker_idx).as_micros() as u64);
    }
}