Skip to main content

kafka_client_engine/metrics/
observer.rs

1//! Single-consumer observation pairing caller- and reactor-owned metrics.
2
3use std::{
4    fmt,
5    future::Future,
6    pin::Pin,
7    task::{Context, Poll},
8};
9
10use crate::Engine;
11use crate::driver::owner::observation::DriverObservation;
12
13use super::{
14    EngineMetricsAdmissionError, EngineMetricsObserverError, EngineMetricsSnapshot,
15    EngineProducerMetrics,
16};
17
18/// Sole observer for one accepted operational snapshot with staged capture points.
19#[must_use = "dropping abandons observation without cancelling accepted metrics work"]
20pub struct EngineMetricsObserver {
21    inner: DriverObservation,
22    producer: EngineProducerMetrics,
23}
24
25impl Engine {
26    /// Requests one bounded operational view at this public admission boundary.
27    pub fn metrics(&self) -> Result<EngineMetricsObserver, EngineMetricsAdmissionError> {
28        let producer = self
29            .inner
30            .admission
31            .try_shard_stats()
32            .map(EngineProducerMetrics::from_shard)
33            .map_err(EngineMetricsAdmissionError::from_producer)?;
34        self.inner
35            .metrics
36            .observe()
37            .map(|inner| EngineMetricsObserver::new(inner, producer))
38            .map_err(EngineMetricsAdmissionError::from_driver)
39    }
40}
41
42impl EngineMetricsObserver {
43    const fn new(inner: DriverObservation, producer: EngineProducerMetrics) -> Self {
44        Self { inner, producer }
45    }
46
47    /// Blocks on the same terminal observation used by [`Future::poll`].
48    pub fn wait(self) -> Result<EngineMetricsSnapshot, EngineMetricsObserverError> {
49        self.inner
50            .wait()
51            .map(|driver| EngineMetricsSnapshot::from_parts(driver, self.producer))
52            .map_err(EngineMetricsObserverError::from_driver)
53    }
54}
55
56impl Future for EngineMetricsObserver {
57    type Output = Result<EngineMetricsSnapshot, EngineMetricsObserverError>;
58
59    fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output> {
60        let this = self.get_mut();
61        Pin::new(&mut this.inner).poll(context).map(|result| {
62            result
63                .map(|driver| EngineMetricsSnapshot::from_parts(driver, this.producer))
64                .map_err(EngineMetricsObserverError::from_driver)
65        })
66    }
67}
68
69impl fmt::Debug for EngineMetricsObserver {
70    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
71        formatter
72            .debug_struct("EngineMetricsObserver")
73            .finish_non_exhaustive()
74    }
75}