apollo-router 1.61.13

A configurable, high-performance routing runtime for Apollo Federation 🚀
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

#[cfg(all(
    feature = "global-allocator",
    not(feature = "dhat-heap"),
    target_os = "linux"
))]
pub(crate) mod jemalloc {
    use std::time::Duration;

    use opentelemetry::metrics::MeterProvider;
    use opentelemetry::metrics::ObservableGauge;

    use crate::metrics::meter_provider;

    pub(crate) fn start_epoch_advance_loop() -> tokio::task::JoinHandle<()> {
        tokio::spawn(async move {
            loop {
                if let Err(e) = tikv_jemalloc_ctl::epoch::advance() {
                    tracing::warn!("Failed to advance jemalloc epoch: {}", e);
                }
                tokio::time::sleep(Duration::from_millis(500)).await;
            }
        })
    }

    macro_rules! create_jemalloc_gauge {
        ($name:ident, $description:expr) => {
            meter_provider()
                .meter("apollo/router")
                .u64_observable_gauge(concat!("apollo.router.jemalloc.", stringify!($name)))
                .with_description($description)
                .with_callback(|gauge| {
                    if let Ok(value) = tikv_jemalloc_ctl::stats::$name::read() {
                        gauge.observe(value as u64, &[]);
                    } else {
                        tracing::warn!("Failed to read jemalloc {} stats", stringify!($name));
                    }
                })
                .init()
        };
    }

    pub(crate) fn create_active_gauge() -> ObservableGauge<u64> {
        create_jemalloc_gauge!(active, "Total active bytes in jemalloc")
    }

    pub(crate) fn create_allocated_gauge() -> ObservableGauge<u64> {
        create_jemalloc_gauge!(allocated, "Total bytes allocated by jemalloc")
    }

    pub(crate) fn create_metadata_gauge() -> ObservableGauge<u64> {
        create_jemalloc_gauge!(metadata, "Total metadata bytes in jemalloc")
    }

    pub(crate) fn create_mapped_gauge() -> ObservableGauge<u64> {
        create_jemalloc_gauge!(mapped, "Total mapped bytes in jemalloc")
    }

    pub(crate) fn create_resident_gauge() -> ObservableGauge<u64> {
        create_jemalloc_gauge!(resident, "Total resident bytes in jemalloc")
    }

    pub(crate) fn create_retained_gauge() -> ObservableGauge<u64> {
        create_jemalloc_gauge!(retained, "Total retained bytes in jemalloc")
    }
}