Async Instrumenter

This Rust library offers a useful future which allows you to time exactly how long any particular future took to execute.

Please note that this is only as accurate as Rust's Instant type. So while it offers a good benchmark of how long, it is limited to how precise std/os/hardware is measuring the time. (If you know of a more accurate implementation, I am all ears)

Usage couldn't be simpler:

async fn sleep() {
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}

// debug log our `sleep()` future with a custom log message
// will only print debug log if `debug_assertions` are enabled
//
// elapsed arg must be used
dbg_instrument!("sleep() took {elapsed:?}", sleep()).await;

// same as above, except with a predefined macro provided log
// message
dbg_instrument!(sleep()).await;

// will always print a debug log message regardless of
// `debug_assertions` status
//
// elapsed arg must be used
instrument!("{elapsed:?}", sleep()).await;

// same as above, except with a predefined macro provided
// log message
instrument!(sleep()).await;

// we can also manually create an instrumenting future if
//we require custom behavior or access to the elapsed data
let res = InstrumentFuture::new(sleep()).await;
println!("took {:?} with result {:?}", res.elapsed, res.result);