Possible to instrument async such that the span only exits after future is completed?

[bonsairobo]

Based on this documentation, it seems like the only correct way to instrument async code is using the Instrument trait or the #[instrument] attribute macro.

When I do this and view my traces in the Tracy profiler, a single async fn will be split across many "zones", making it hard to use any of the aggregation features. I understand this happens because in reality the async fn is a future that is being polled many times before completing, and each of those corresponds to an enter/exit of the span.

I am wondering if it would be possible for tracing to have an alternative way of instrumenting a future such that it only exits once the future has completed (and will not be polled again).

[mladedav]

I don't think this is really possible because the span must be exited on the same thread as it was entered. When you await on a work-stealing runtime like tokio's multithreaded runtime, you're not guaranteed that you'll be on the same thread as before.

If you know you'll be on the same thread and you don't need you Futures to be Send, then you can probably do something like this, but note that the documentation you linked still applies and your children-parent relationships might be wrong and because of that some spans may not be closed when they should be because tracing still sees some of their children as not closed.

    let span = tracing::info_span!("span").entered();
    tokio::task::yield_now().await;
    drop(span);

I think the best way to achieve what you want is for the subscriber exporting your data to only report first enter (or creation of the span) and last exit (or when the span is closed).