re_perf_telemetry 0.27.2

In and out of process performance profiling utilities for Rerun & Redap
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

use opentelemetry_sdk::error::OTelSdkResult;
use opentelemetry_sdk::metrics::{
    ManualReader, Pipeline, Temporality, data::ResourceMetrics, reader::MetricReader,
};
use std::sync::{Arc, Weak};
use std::time::Duration;

/// A wrapper that allows sharing a `ManualReader`.
///
/// 1. `MeterProvider::with_reader()` takes ownership of the reader
/// 2. We need the same reader instance in our metrics server to call `collect()`
/// 3. `ManualReader` doesn't implement Clone
///
/// The wrapper holds `ManualReader` in Arc and implements `MetricReader` by delegating all calls.
#[derive(Clone, Debug)]
pub struct SharedManualReader {
    inner: Arc<ManualReader>,
}

impl SharedManualReader {
    pub fn new(temporality: Temporality) -> Self {
        let reader = ManualReader::builder()
            .with_temporality(temporality)
            .build();
        Self {
            inner: Arc::new(reader),
        }
    }

    pub fn inner(&self) -> Arc<ManualReader> {
        Arc::clone(&self.inner)
    }
}

impl MetricReader for SharedManualReader {
    fn register_pipeline(&self, pipeline: Weak<Pipeline>) {
        self.inner.register_pipeline(pipeline);
    }

    fn collect(&self, rm: &mut ResourceMetrics) -> OTelSdkResult {
        self.inner.collect(rm)
    }

    fn force_flush(&self) -> OTelSdkResult {
        self.inner.force_flush()
    }

    fn shutdown(&self) -> OTelSdkResult {
        self.inner.shutdown()
    }

    fn shutdown_with_timeout(&self, timeout: Duration) -> OTelSdkResult {
        self.inner.shutdown_with_timeout(timeout)
    }

    fn temporality(&self, kind: opentelemetry_sdk::metrics::InstrumentKind) -> Temporality {
        self.inner.temporality(kind)
    }
}