Struct CpuTimedFuture 

pub struct CpuTimedFuture<F> { /* private fields */ }

A Future adapter that accumulates thread CPU time across every poll.

Each call to Future::poll is bracketed by a ThreadTime sample; the delta is added to counter. Tokio’s executor cannot migrate a task to another worker thread or run another task on the current thread between the entry and exit of a single poll, so each delta is a clean per-thread CPU-time measurement of the wrapped future’s work for that poll. Multiple polls (across Pending returns and wake-ups) accumulate into the same counter, with each poll independently sampling the thread it ran on.

This is the per-task analogue of tokio’s unstable on_before_task_poll / on_after_task_poll runtime hooks: it hooks the same boundary, but on a single future rather than the whole runtime, and it works on stable Rust without --cfg tokio_unstable.

Measurement scope and upstream isolation

Vector components communicate only through BufferReceiver/BufferSender channels — never through stream combinators chained across component boundaries. Each component runs in its own tokio task. When a transform polls its input channel, it dequeues items that the upstream component computed earlier, in its own task; it does not execute any upstream code. The upstream’s CPU was already charged to the upstream’s counter at the time those items were produced. This holds even when the channel is always full: the items were produced by upstream CPU that was already counted upstream; we are only dequeuing them.

As a consequence, this counter for a transform task includes:

• Input-channel dequeue (our task’s poll of the channel, not upstream work)
• on_events_received bookkeeping and metric emit
• transform_all (the core CPU cost)
• send_outputs / fanout dispatch to downstream channels
• Per-event schema validation and latency recording
• For transforms that spawn helper tasks (e.g. aws_ec2_metadata IMDS refresh, throttle‘s flush loop): those tasks’ polls, via spawn_timed, feed the same counter rather than being silently excluded.

And does not include:

• Other components’ CPU — channel isolation guarantees this.
• Time the task is parked (Poll::Pending): no polls → no measurement. Back-pressure and input starvation show up as flat counter growth.
• Drop of the inner future after the final Poll::Ready. The drop runs after CpuTimedFuture::poll returns, so it is outside the timed window. This is a one-time cost at task shutdown, not steady-state.
• Tokio scheduler and waker overhead — executor work, not component work.

Concurrent sync transforms

For transforms that run concurrently (enable_concurrency() == true), both the driver future and each per-batch spawned task are wrapped with this adapter. Because the spawned tasks are separate tokio tasks, the driver’s CpuTimedFuture never observes their polls — there is no double-counting. The driver is measured for: input dequeue, on_events_received, and send_outputs. Each spawned task is measured for: transform_all.

Construct it via CpuTimedExt::cpu_timed.

Trait Implementations

impl<F: Future> Future for CpuTimedFuture<F>

type Output = <F as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<F::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> Unpin for CpuTimedFuture<F>

where PinnedFieldsOf<__CpuTimedFuture<'pin, F>>: Unpin,