Struct prometheus_utils::InstrumentedFuture

pub struct InstrumentedFuture<F: Future> { /* fields omitted */ }

An instrumented Future.

InstrumentedFuture provides a transparent observability layer for futures. An instrumented future is not created directly. Rather, an instrumented future is created from an existing future using IntoInstrumentedFuture::into_instrumented_future.

Most importantly, the increment_until_resolved method allows callers to increment a GuardedGauge, and then decrement the gauge once the future has resolved.

Implementations

impl<F: Future> InstrumentedFuture<F>

pub fn with_guard<GuardFn: FnOnce() -> Option<Box<dyn Drop + Send>> + Send + 'static>(
    self,
    guard_fn: GuardFn
) -> Self

Queue guard_fn to execute when the future is polled, retaining the returned value until the future completes.

pub fn with_count<P: Atomic + 'static>(
    self,
    counter: &'static GenericCounter<P>
) -> Self

Increment a Prometheus counter immediately.

pub fn with_count_labeled<C, L>(self, counter: &'static C, labels: L) -> Self where
    C: Deref<Target = IntCounterWithLabels<L>> + Sync,
    L: Labels + Sync + Send + 'static, 

Increment a labeled Prometheus counter when the future is polled.

pub fn with_count_gauge<G, T, P>(self, gauge: &'static G) -> Self where
    G: Deref<Target = T> + Sync,
    T: GuardedGauge<P> + 'static,
    P: Atomic + 'static, 

Increment a Prometheus gauge until this future has resolved.

When called, this method will immediately increment the given gauge using the GuardedGauge::gaurded_inc trait method. This gauge will then be decremented once this future’s Future::poll implementation returns a Poll::Ready value.

See the GenericGaugeGuard documentation for more information about RAII guards for Prometheus metrics.

Trait Implementations

impl<F: Future> Future for InstrumentedFuture<F>

type Output = <F as Future>::Output

An instrumented future returns the same type as its inner future.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Polls the inner future.

If the inner future’s [Future::poll][fut-poll] implementation returns a [Poll::Ready][poll-ready] value, Prometheus gauges will be decremented accordingly.

impl<'pin, F: Future> Unpin for InstrumentedFuture<F> where
    __InstrumentedFuture<'pin, F>: Unpin,