Enum InstrumentedFuture

pub enum InstrumentedFuture<F, C>
where
    F: Future,
    C: InstrumentedFutureContext<F::Output>,
{
    Pending {
        future: F,
        context: C,
    },
    Complete,
}

A future wrapper that provides instrumentation hooks for result handling.

This future wrapper allows for instrumentation of async operations by providing a context that is called when the future completes. It ensures that the context callback is invoked exactly once when the future produces its result.

State Management

The future maintains two states:

• Pending: The wrapped future is still executing and contains the future and context
• Complete: The future has completed and the context has been invoked

Generic Parameters

• F: The wrapped future type
• C: The context type that implements InstrumentedFutureContext

Fields

The Pending variant contains the future being instrumented and the context that will be called when it completes. Field documentation is not possible within pin_project macros.

Variants

Pending

Future is currently executing and waiting for completion

Fields

future: F

context: C

Complete

Future has completed and context has been invoked

Implementations

impl<F, C> InstrumentedFuture<F, C>

where F: Future, C: InstrumentedFutureContext<F::Output>,

pub fn new(future: F, context: C) -> Self

Creates a new instrumented future with the given future and context.

Arguments

• future: The future to instrument
• context: The context that will be called when the future completes

Returns

A new InstrumentedFuture in the Pending state

Examples

use telemetry_rust::future::{InstrumentedFuture, InstrumentedFutureContext};

struct MyContext;
impl InstrumentedFutureContext<i32> for MyContext {
    fn on_result(self, result: &i32) {
        println!("Future completed with result: {}", result);
    }
}

let future = async { 42 };
let instrumented = InstrumentedFuture::new(future, MyContext);

Trait Implementations

impl<F, C> Future for InstrumentedFuture<F, C>

where F: Future, C: InstrumentedFutureContext<F::Output>,

type Output = <F as Future>::Output

The type of value produced on completion.

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

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<'__pin, F, C> Unpin for InstrumentedFuture<F, C>

where PinnedFieldsOf<__Origin<'__pin, F, C>>: Unpin, F: Future, C: InstrumentedFutureContext<F::Output>,