Struct Dial9TokioHandle 

pub struct Dial9TokioHandle { /* private fields */ }

Available on crate feature dial9 only.

Tokio handle for spawning instrumented tasks.

Spawned futures are wrapped with wake-event tracking and, when configured, task dump capture while telemetry is live on this handle. Otherwise they spawn plainly. Obtain one for the current runtime with current. To spawn onto a specific runtime from any thread, use spawn_in.

This handle only spawns. For recording and control, use Dial9Handle.

Implementations

impl Dial9TokioHandle

pub fn current() -> Dial9TokioHandle

Handle that spawns on the current tokio runtime (like tokio::spawn).

Wraps spawned futures with Dial9 instrumentation when the current thread is owned by a live dial9 runtime, otherwise spawns plainly.

pub fn disabled() -> Dial9TokioHandle

Inert handle: spawn falls back to [tokio::spawn] without Dial9 instrumentation.

pub fn spawn<F>(&self, future: F) -> JoinHandle<<F as Future>::Output>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Spawn an instrumented future.

On an enabled handle the future is wrapped with wake-event tracking and, when configured, task dump capture. The task runs on this handle’s runtime, the current one for current, or the specific runtime the handle was built for.

Panics

For a current-runtime handle, panics if called outside a tokio runtime context (same as [tokio::spawn]).

pub fn spawn_with<F, S>( &self, future: F, spawn_fn: impl FnOnce(TracedFuture<F>) -> S, ) -> S

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Spawn an instrumented future through a user-supplied spawn function.

spawn_fn must synchronously perform a real Tokio spawn (or an equivalent operation) before returning; do not defer the future or run it with block_on. To record the resulting task as instrumented, spawn on a dial9-traced runtime with task tracking enabled. The closure’s return value is forwarded back to the caller, so you can keep the [tokio::task::JoinHandle], [tokio::task::AbortHandle], or whatever the spawn function returns.

For [tokio::task::JoinSet], prefer JoinSetExt::spawn_traced.

Examples

Spawn while retaining the task’s [tokio::task::AbortHandle]:

let handle = Dial9TokioHandle::current();
let abort_handle = handle.spawn_with(work(), |f| tokio::spawn(f).abort_handle());

The recorded spawn location is the spawn_fn call site under --cfg tokio_unstable, and this method’s call site without it. An inline closure like the one above puts both at the same line.

Trait Implementations

impl Clone for Dial9TokioHandle

fn clone(&self) -> Dial9TokioHandle

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Dial9TokioHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.