Rust异步编程的可观察调试工具:Await-Tree

开发 开发工具
在本文中,我们介绍了await- tree作为Async Rust中可观察性的强大工具。await- tree是为Async Rust原生设计的回溯工具,它允许开发者实时观察每个异步任务的执行状态,并分析不同future或任务之间的依赖阻塞关系。​

Async Rust中的future可以任意组合或嵌套,以实现各种控制流。假设每个Future的执行都表示为一个节点,那么可以将异步任务的异步执行组织到一个逻辑树中,该逻辑树在Future的轮询、完成和取消过程中不断转换。

在本文中,我们将介绍Await-Tree,一个Async Rust的调试工具。它可以分析任务中的异步调用链和任务之间的依赖阻塞关系,以最小的运行时开销显著提高系统的可观察性和可调试性。await-tree允许开发人员在运行时转储这个执行树,每个Future的跨度由instrument_await注释。

下面我们看一个基本示例:

在Cargo.toml文件中,加入以下依赖项:

[dependencies]
await-tree = "0.1.2"
futures = "0.3.30"
tokio = {version = "1.35.1", features = ["full"]}

代码如下:

use std::time::Duration;

use await_tree::{Config, InstrumentAwait, Registry};
use futures::future::{join, pending};
use tokio::time::sleep;

async fn bar(i: i32) {
    // `&'static str` span
    baz(i).instrument_await("baz in bar").await
}

async fn baz(i: i32) {
    // runtime `String` span is also supported
    pending()
        .instrument_await(format!("pending in baz {i}"))
        .await
}

async fn foo() {
    // spans of joined futures will be siblings in the tree
    join(
        bar(3).instrument_await("bar"),
        baz(2).instrument_await("baz"),
    )
    .await;
}

#[tokio::main]
async fn main() {
    let mut registry = Registry::new(Config::default());
    let root = registry.register((), "foo");
    tokio::spawn(root.instrument(foo()));

    sleep(Duration::from_secs(1)).await;
    let tree = registry.get(&()).unwrap().to_string();
    println!("{tree}");
}

执行cargo run,结果如下:

foo [1.002s]
  baz [1.002s]
    pending in baz 2 [1.002s]
  bar [1.002s]
    baz in bar [1.002s]
      pending in baz 3 [1.002s]

在代码中,我们有一些简单的async函数嵌套调用和使用join并发执行。与通常的代码不同,我们在希望跟踪的每个关键future后面添加.instrument_await,并为其指定名称。此名称可以是静态字符串常量,也可以包含其他运行时信息。

我们再看另外一个例子:

use std::time::Duration;

use await_tree::{Config, InstrumentAwait, Registry};
use futures::channel::oneshot::{self, Receiver};
use futures::future::{pending, select};
use futures::FutureExt;
use tokio::time::sleep;

async fn work(rx: Receiver<()>) {
    let mut fut = pending().instrument_await("fut");

    let _ = select(
        sleep(Duration::from_millis(500))
            .instrument_await("sleep")
            .boxed(),
        &mut fut,
    )
    .instrument_await("select")
    .await;

    // 等待信号继续
    rx.instrument_await("rx").await.unwrap();

    fut.await
}

#[tokio::main]
async fn main() {
    let mut registry = Registry::new(Config::default());
    let root = registry.register((), "work");
    let (tx, rx) = oneshot::channel();
    tokio::spawn(root.instrument(work(rx)));

    sleep(Duration::from_millis(100)).await;
    let tree = registry.get(&()).unwrap().to_string();
    println!("{tree}");

    sleep(Duration::from_secs(1)).await;
    let tree = registry.get(&()).unwrap().to_string();
    println!("{tree}");

    tx.send(()).unwrap();
    sleep(Duration::from_secs(1)).await;
    let tree = registry.get(&()).unwrap().to_string();
    println!("{tree}");
}

结果如下:

work [101.181ms]
  select [101.066ms]
    fut [101.044ms]
    sleep [101.044ms]

work [1.103s]
  rx [601.779ms]
[Detached 4]
  fut [1.103s]

work [2.105s]
  fut [2.105s]

这个例子展示了如何从树中分离并重新挂载一个span。

总结

在本文中,我们介绍了await- tree作为Async Rust中可观察性的强大工具。await- tree是为Async Rust原生设计的回溯工具,它允许开发者实时观察每个异步任务的执行状态,并分析不同future或任务之间的依赖阻塞关系。

责任编辑:武晓燕 来源: coding到灯火阑珊
相关推荐

2022-08-28 10:36:53

调试工具通用

2014-07-15 10:08:42

异步编程In .NET

2021-09-26 09:50:21

开发技能程序

2024-01-24 13:22:40

Python调试工具技巧

2023-03-23 13:48:00

工具应用场景选型

2021-06-28 08:10:59

JavaScript异步编程

2016-12-02 20:23:51

AndroidADB

2012-02-24 09:25:20

JavaScript

2011-08-15 17:38:48

iPhone开发调试工具

2023-03-29 08:18:16

Go调试工具

2022-08-21 14:05:54

调试工具CDP

2023-02-21 08:00:00

2023-11-17 08:00:54

Tetragon执行工具

2018-11-27 11:35:32

systemtapMySQL调试工具

2020-05-21 15:53:59

远程调试工具

2022-12-30 11:05:40

Rust代码

2022-07-25 07:57:19

工具代码调试

2017-08-23 09:26:16

Chromelive 状态代码

2015-04-22 12:10:28

在线编译调试工具

2021-07-28 11:46:51

工具gRPC客户端
点赞
收藏

51CTO技术栈公众号