MENU
  1. ホーム
  2. Rust
  3. Rustの非同期テストを効率的にデバッグするツールとテクニック徹底解説

Rustの非同期テストを効率的にデバッグするツールとテクニック徹底解説

Rust

Rustの非同期プログラミングは、効率的な並行処理を可能にしますが、テストやデバッグが難しいという課題があります。非同期タスクの実行順序が予測しづらく、エラーやデッドロックが発生しやすいため、従来のデバッグ手法だけでは不十分です。

本記事では、Rustにおける非同期テストのデバッグを効率化するためのツールやテクニックについて解説します。tokio-consoleやtracingといったツールを活用し、非同期タスクの可視化やログ出力を効果的に行う方法を紹介します。これにより、非同期テストの問題を迅速に特定し、開発をスムーズに進める手助けをします。

目次
  1. Rustにおける非同期テストの概要
    1. 非同期プログラミングの仕組み
    2. 非同期テストの目的
    3. 非同期テストの基本構文
  2. 非同期テストにおける一般的な問題
    1. 1. タスクの非決定的な実行順序
    2. 2. デッドロック
    3. 3. タイムアウトと遅延
    4. 4. エラーハンドリングの難しさ
    5. 5. 非同期テストランタイムの競合
    6. 6. パニックが非同期タスク内で隠れる
  3. 非同期テストのデバッグを支援するツール
    1. 1. tokio-console
    2. 2. tracing
    3. 3. cargo-tarpaulin
    4. 4. loom
    5. 5. miri
    6. 6. RUST_LOG環境変数
  4. tokio-consoleの活用法
    1. tokio-consoleの概要
    2. tokio-consoleの導入方法
    3. tokio-consoleの起動方法
    4. 利用例
    5. tokio-consoleの出力例
    6. 利点
  5. 非同期テストでのロギングテクニック
    1. ロギングクレートの選定
    2. 基本的なロギングの実装
    3. logクレートの利用
    4. tracingクレートの利用
    5. 効果的なロギングのポイント
    6. まとめ
  6. tracingクレートを使ったデバッグ方法
    1. tracingの概要
    2. tracingの導入
    3. 基本的な使い方
    4. イベントの記録
    5. スパンを使ったタスクのトレース
    6. 非同期関数に#[instrument]属性を使う
    7. 利点
    8. まとめ
  7. タイムアウトとエラーハンドリングのテクニック
    1. タイムアウトの設定方法
    2. 使用例
    3. エラーハンドリングのテクニック
    4. Result型を活用したエラーハンドリング
    5. match文を使ったエラー処理
    6. 非同期タスクでのパニック対策
    7. パニック処理の例
    8. タイムアウトとエラーハンドリングの組み合わせ
    9. まとめ
  8. 実践的な非同期テストの例
    1. 1. 非同期HTTPリクエストのテスト
    2. 2. 非同期ファイル読み書きのテスト
    3. 3. 非同期データベース操作のテスト
    4. 4. タイムアウトを伴う非同期処理のテスト
    5. 5. パニック処理を含む非同期タスクのテスト
    6. まとめ
  9. まとめ

Rustにおける非同期テストの概要


Rustでは、非同期処理を行うためにasync/await構文やFutureトレイトが用意されています。非同期プログラムでは、タスクを並行して処理し、ブロッキングせずに効率よくリソースを活用できます。

非同期プログラミングの仕組み


非同期処理は、タスクの一時停止と再開を柔軟に管理することで、I/O操作やネットワークリクエストなどの待ち時間を有効活用します。Rustの主要な非同期ランタイムには、以下のものがあります：

  • Tokio：高性能な非同期ランタイム。広く利用されている。
  • async-std：シンプルで使いやすい非同期ランタイム。

非同期テストの目的


非同期テストの主な目的は、非同期タスクが正しく動作することを検証することです。以下の点を確認する必要があります：

  1. タスクの正しい実行順序：非同期タスクが期待通りの順序で動作するか。
  2. エラーハンドリング：エラーが適切に処理されるか。
  3. パフォーマンス：デッドロックやパフォーマンスボトルネックがないか。

非同期テストの基本構文


Rustの非同期テストは、#[tokio::test]や#[async_std::test]のアトリビュートを使うことで簡単に書けます。

#[tokio::test]
async fn test_async_function() {
    let result = some_async_function().await;
    assert_eq!(result, expected_value);
}

このように、非同期関数をテストする際はawaitを使って結果を待ち、アサーションで期待値を確認します。

非同期テストにおける一般的な問題

Rustの非同期テストでは、従来の同期テストとは異なる特有の問題が発生しがちです。これらの問題を理解し、対策を講じることが効率的なテストには不可欠です。

1. タスクの非決定的な実行順序


非同期テストではタスクの実行順序が予測しづらいため、予期しない順序でタスクが実行されることがあります。これにより、テスト結果が不安定になることがあります。
例: 並行タスクが同じリソースにアクセスする場合、タイミングによって結果が変わることがあります。

2. デッドロック


非同期タスク同士が相互に待ち合う状況（デッドロック）が発生すると、テストが終了しなくなる問題があります。デッドロックは特に、複数のタスクが共有リソースをロックしようとする場合に起こりやすいです。

3. タイムアウトと遅延


非同期テストでは、I/O操作やネットワーク通信の遅延により、タスクが予想以上に時間がかかることがあります。適切なタイムアウト設定がされていないと、テストがいつまでも終了しない可能性があります。

4. エラーハンドリングの難しさ


非同期タスク内でエラーが発生した場合、そのエラーが適切に伝播されないと、問題を見逃してしまうことがあります。エラーの原因特定が難しいことが多く、テストの信頼性に影響します。

5. 非同期テストランタイムの競合


複数の非同期ランタイム（例えばTokioとasync-std）を同時に使う場合、テスト内でランタイムが競合することがあります。これにより、テストがクラッシュするリスクがあります。

6. パニックが非同期タスク内で隠れる


非同期タスクがパニックを起こした場合、そのパニックがFutureの中に隠れてしまい、テスト失敗の原因がわかりづらくなります。

これらの問題を理解し、適切なデバッグツールやテクニックを活用することで、非同期テストの効率と信頼性を向上させることができます。

非同期テストのデバッグを支援するツール

Rustの非同期テストでは、特有の問題に対処するために、いくつかのデバッグ支援ツールが活用されています。これらのツールを使うことで、非同期タスクの実行状況やエラーを可視化し、効率的に問題を特定できます。

1. tokio-console


概要: Tokioランタイムで動作する非同期タスクをリアルタイムで監視・可視化するツールです。
特徴:

  • 非同期タスクの実行時間や状態を表示
  • タスクの依存関係やブロッキング状態を特定可能
  • デッドロックやタスクの遅延を検出しやすい

2. tracing


概要: 非同期タスクの詳細なログを取得できるロギングクレートです。
特徴:

  • 非同期タスクごとのログ出力が可能
  • タスクの開始・終了・エラー発生箇所を記録
  • ログの階層化が可能で、複雑なシステムのデバッグに最適

3. cargo-tarpaulin


概要: テストカバレッジを測定するツールです。
特徴:

  • 非同期テストでもカバレッジを計測可能
  • テストがカバーしていないコード部分を特定できる

4. loom


概要: 並行性の問題をシミュレートし、バグを検出するためのツールです。
特徴:

  • 競合状態やデッドロックのシミュレーションが可能
  • 並行処理の正しさを検証するために役立つ

5. miri


概要: Rustプログラムの未定義動作や安全性違反を検出するインタープリタです。
特徴:

  • 非同期タスクにおける安全性違反を検出
  • ヒープバッファオーバーフローや未初期化メモリアクセスの特定

6. RUST_LOG環境変数


概要: 環境変数を設定することでログ出力レベルを制御します。
特徴:

  • 非同期テストのデバッグ出力を簡単に有効化
  • エラーや警告メッセージをフィルタリング可能

これらのツールを適切に組み合わせることで、Rustの非同期テストにおけるデバッグを効率化し、問題の特定と修正を迅速に行うことができます。

tokio-consoleの活用法

Rustの非同期テストで効率的にデバッグするために、tokio-consoleは非常に有用なツールです。非同期タスクの状態や実行時間をリアルタイムで可視化し、デッドロックや遅延の原因を特定するのに役立ちます。

tokio-consoleの概要


tokio-consoleは、Tokioランタイムの非同期タスクを監視するためのツールです。これにより、以下の情報が取得できます：

  • タスクの開始時刻と終了時刻
  • タスクの実行時間
  • タスクの状態（実行中、待機中、完了など）
  • タスク間の依存関係やブロッキング状態

tokio-consoleの導入方法

  1. Cargo.tomlに依存クレートを追加します。
   [dependencies]
   tokio = { version = "1", features = ["full", "tracing"] }
   console-subscriber = "0.1"
  1. メイン関数にconsole-subscriberを初期化するコードを追加します。
   use console_subscriber::ConsoleLayer;
   use tracing_subscriber::prelude::*;

   #[tokio::main]
   async fn main() {
       tracing_subscriber::registry()
           .with(ConsoleLayer::new())
           .init();

       my_async_function().await;
   }

tokio-consoleの起動方法

以下のコマンドでtokio-consoleを起動します。

RUSTFLAGS="--cfg tokio_unstable" cargo run

別のターミナルでtokio-consoleを実行します。

tokio-console

利用例

次の非同期タスクをデバッグしてみましょう。

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    tokio::spawn(async {
        sleep(Duration::from_secs(2)).await;
        println!("Task 1 completed");
    });

    tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        println!("Task 2 completed");
    });

    println!("Main task completed");
}

tokio-consoleの出力例

tokio-consoleを実行すると、次のような情報が表示されます。

ID      STATE      DURATION      NAME
1       completed  2.01s         task::spawn (Task 1)
2       completed  1.01s         task::spawn (Task 2)
3       completed  0.01s         main task

利点

  • タスクの遅延やブロッキングの可視化
  • デッドロックや実行時間の長いタスクの特定
  • 非同期タスクの状態遷移の把握

tokio-consoleを活用することで、非同期テストのデバッグが効率的になり、問題を迅速に特定・修正できるようになります。

非同期テストでのロギングテクニック

非同期テストでは、タスクの動作やエラーを把握するためにロギングが重要です。適切にログを出力することで、非同期タスクの実行フローや問題発生箇所を特定しやすくなります。

ロギングクレートの選定


Rustでは、非同期環境で利用できるいくつかのロギングクレートがあります。代表的なものは以下です：

  1. logクレート
  • シンプルなロギングAPIを提供。
  • 他のロギングフレームワークと互換性があります。
  1. tracingクレート
  • 非同期タスク向けの強力なロギングフレームワーク。
  • イベントやスパンを使って非同期処理の流れを可視化します。

基本的なロギングの実装

logクレートの利用

  1. Cargo.tomlに依存関係を追加します。
   [dependencies]
   log = "0.4"
   env_logger = "0.10"
   tokio = { version = "1", features = ["full"] }
  1. ロギングの初期化と使用例です。
   use log::{info, error};
   use tokio::time::{sleep, Duration};

   #[tokio::main]
   async fn main() {
       env_logger::init();

       info!("Starting asynchronous task...");

       let handle = tokio::spawn(async {
           sleep(Duration::from_secs(2)).await;
           info!("Task completed");
       });

       if let Err(e) = handle.await {
           error!("Task failed: {:?}", e);
       }
   }

出力例：

   INFO  Starting asynchronous task...
   INFO  Task completed

tracingクレートの利用

  1. Cargo.tomlに依存関係を追加します。
   [dependencies]
   tracing = "0.1"
   tracing-subscriber = "0.3"
   tokio = { version = "1", features = ["full"] }
  1. スパンとイベントを活用したロギング例です。
   use tracing::{info, error, instrument};
   use tracing_subscriber;

   #[tokio::main]
   async fn main() {
       tracing_subscriber::fmt::init();

       some_async_task().await;
   }

   #[instrument]
   async fn some_async_task() {
       info!("Starting task...");
       if let Err(e) = do_work().await {
           error!("Task failed: {:?}", e);
       }
   }

   async fn do_work() -> Result<(), &'static str> {
       Err("Something went wrong")
   }

出力例：

   INFO  some_async_task: Starting task...
   ERROR some_async_task: Task failed: "Something went wrong"

効果的なロギングのポイント

  • 適切なログレベルを設定する：
  • info!：通常の操作や進捗報告。
  • warn!：注意が必要な事象。
  • error!：エラーや失敗。
  • スパンを活用してタスクの開始・終了を記録する：
    非同期タスクの範囲を明確に示すために、tracingのスパンを利用すると効果的です。
  • 環境変数でログ出力を制御する：
    開発時は詳細なログ、運用時は必要最低限のログといった使い分けが可能です。

まとめ


非同期テストにおけるロギングは、タスクの状態やエラーの原因を特定するために欠かせない手法です。logやtracingクレートを活用し、適切なログレベルやスパンを設定することで、効率的なデバッグが可能になります。

tracingクレートを使ったデバッグ方法

Rustの非同期テストでは、tracingクレートを使うことで、非同期タスクの詳細なデバッグ情報を取得できます。tracingは、イベントやスパンを使って非同期タスクの挙動を可視化し、エラーや遅延の原因を特定するのに役立ちます。

tracingの概要


tracingは、非同期環境に特化したロギングクレートで、以下の特徴があります：

  • イベントとスパンを用いたロギング
  • 非同期タスクの開始・終了や状態遷移を記録
  • 並行タスクの依存関係やタイミングの可視化
  • ログのフィルタリングやフォーマットの柔軟性

tracingの導入

  1. Cargo.tomlに依存クレートを追加します。
   [dependencies]
   tracing = "0.1"
   tracing-subscriber = "0.3"
   tokio = { version = "1", features = ["full"] }
  1. ロギングの初期化を行います。
   use tracing_subscriber;

   fn init_tracing() {
       tracing_subscriber::fmt::init();
   }

基本的な使い方

イベントの記録

info!, warn!, error! マクロを使ってログを記録します。

use tracing::{info, warn, error};
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    init_tracing();

    info!("Starting asynchronous task...");

    let handle = tokio::spawn(async {
        sleep(Duration::from_secs(2)).await;
        warn!("Task is taking longer than expected");
        error!("Task encountered an error");
    });

    handle.await.unwrap();
}

出力例：

INFO  Starting asynchronous task...
WARN  Task is taking longer than expected
ERROR Task encountered an error

スパンを使ったタスクのトレース

スパン（span!）を使うことで、タスクの範囲や処理時間を記録できます。

use tracing::{info, span, Level};
use tracing_futures::Instrument;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    init_tracing();

    let span = span!(Level::INFO, "main_task");
    let _enter = span.enter();

    let handle = tokio::spawn(do_work().instrument(span!(Level::INFO, "do_work")));
    handle.await.unwrap();
}

async fn do_work() {
    info!("Work started");
    sleep(Duration::from_secs(1)).await;
    info!("Work completed");
}

出力例：

INFO  main_task: Work started
INFO  main_task: Work completed

非同期関数に#[instrument]属性を使う

非同期関数に#[instrument]属性を付けることで、関数の呼び出しと引数を自動的に記録できます。

use tracing::{info, instrument};
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
    init_tracing();
    my_async_function(42).await;
}

#[instrument]
async fn my_async_function(value: i32) {
    info!("Processing value...");
    sleep(Duration::from_secs(2)).await;
    info!("Done processing");
}

出力例：

INFO  my_async_function{value=42}: Processing value...
INFO  my_async_function{value=42}: Done processing

利点

  • タスクごとの詳細なログが取得できる
  • 関数の呼び出しと引数の自動記録でデバッグが容易
  • タスクの範囲や実行時間の可視化により、遅延やデッドロックの特定が可能

まとめ


tracingクレートは、Rustの非同期テストやデバッグにおいて強力なツールです。イベントやスパンを活用し、非同期タスクの挙動を詳細に記録することで、問題の特定と解決が効率的に行えます。

タイムアウトとエラーハンドリングのテクニック

Rustの非同期テストでは、タスクが予期しない時間待機したり、エラーが発生する可能性があります。これらの問題に対処するために、タイムアウト設定とエラーハンドリングのテクニックが重要です。

タイムアウトの設定方法

非同期タスクが長時間実行されないように、タイムアウトを設定することで、テストがハングするのを防ぎます。tokio::time::timeoutを使用してタイムアウトを設定できます。

使用例

use tokio::time::{timeout, Duration, sleep};

#[tokio::test]
async fn test_with_timeout() {
    let result = timeout(Duration::from_secs(2), async_task()).await;

    match result {
        Ok(_) => println!("Task completed within time limit"),
        Err(_) => println!("Task timed out"),
    }
}

async fn async_task() {
    sleep(Duration::from_secs(3)).await; // タイムアウトを超えるタスク
}

出力例：

Task timed out

この例では、async_taskが3秒かかるため、2秒のタイムアウトでエラーになります。

エラーハンドリングのテクニック

非同期テストでは、エラーを適切に処理し、原因を把握することが重要です。以下の方法でエラーハンドリングを行います。

Result型を活用したエラーハンドリング

非同期関数でResult型を返すことで、エラーを明示的に処理できます。

use tokio::fs::File;
use tokio::io::AsyncReadExt;

#[tokio::test]
async fn test_with_error_handling() -> Result<(), Box<dyn std::error::Error>> {
    let mut file = File::open("non_existent_file.txt").await?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).await?;

    Ok(())
}

この場合、ファイルが存在しないとエラーが返り、テストは失敗します。

match文を使ったエラー処理

match文を使ってエラー内容に応じた処理を行うことができます。

use tokio::fs::File;

#[tokio::test]
async fn test_with_match_error_handling() {
    match File::open("non_existent_file.txt").await {
        Ok(_) => println!("File opened successfully"),
        Err(e) => eprintln!("Failed to open file: {:?}", e),
    }
}

非同期タスクでのパニック対策

非同期タスクがパニックを起こした場合、そのエラーを回復するためにtokio::spawnの戻り値を確認します。

パニック処理の例

use tokio::task;

#[tokio::test]
async fn test_with_panic_handling() {
    let handle = task::spawn(async {
        panic!("Something went wrong!");
    });

    match handle.await {
        Ok(_) => println!("Task completed successfully"),
        Err(e) => eprintln!("Task panicked: {:?}", e),
    }
}

出力例：

Task panicked: task panicked at 'Something went wrong!'

タイムアウトとエラーハンドリングの組み合わせ

タイムアウトとエラーハンドリングを組み合わせることで、堅牢な非同期テストを実現します。

use tokio::time::{timeout, Duration};

#[tokio::test]
async fn test_with_timeout_and_error_handling() {
    let result = timeout(Duration::from_secs(2), async_task()).await;

    match result {
        Ok(Ok(_)) => println!("Task completed successfully"),
        Ok(Err(e)) => eprintln!("Task encountered an error: {:?}", e),
        Err(_) => eprintln!("Task timed out"),
    }
}

async fn async_task() -> Result<(), &'static str> {
    Err("An error occurred")
}

出力例：

Task encountered an error: "An error occurred"

まとめ

  • タイムアウトを設定することで、タスクのハングを防止。
  • Result型やmatch文を活用してエラー処理を明確に。
  • パニック処理で非同期タスクのクラッシュを回避。

これらのテクニックを組み合わせることで、Rustの非同期テストをより堅牢で効率的にデバッグできます。

実践的な非同期テストの例

Rustの非同期テストを実践的に行うための例を紹介します。これらの例を通じて、非同期タスクのテスト方法やデバッグ手法の理解を深めましょう。

1. 非同期HTTPリクエストのテスト

非同期のHTTPリクエストを処理し、そのレスポンスを検証するテストです。reqwestクレートを使用します。

Cargo.tomlに依存クレートを追加

[dependencies]
tokio = { version = "1", features = ["full"] }
reqwest = { version = "0.11", features = ["json"] }

テストコード

use reqwest::Error;

#[tokio::test]
async fn test_async_http_request() -> Result<(), Error> {
    let url = "https://jsonplaceholder.typicode.com/posts/1";
    let response = reqwest::get(url).await?.json::<serde_json::Value>().await?;

    assert_eq!(response["id"], 1);
    println!("Response received: {:?}", response);

    Ok(())
}

2. 非同期ファイル読み書きのテスト

非同期でファイルに書き込み、読み取るテストです。tokio::fsを使用します。

テストコード

use tokio::fs::{File, read_to_string};
use tokio::io::{AsyncWriteExt, Result};

#[tokio::test]
async fn test_async_file_io() -> Result<()> {
    let file_path = "test.txt";

    // ファイルに書き込み
    let mut file = File::create(file_path).await?;
    file.write_all(b"Hello, world!").await?;

    // ファイルから読み込み
    let contents = read_to_string(file_path).await?;
    assert_eq!(contents, "Hello, world!");

    println!("File content: {}", contents);
    Ok(())
}

3. 非同期データベース操作のテスト

非同期データベースクエリをテストします。sqlxクレートを使用します。

Cargo.tomlに依存クレートを追加

[dependencies]
tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.6", features = ["sqlite", "runtime-tokio-native-tls"] }

テストコード

use sqlx::{sqlite::SqlitePool, Result};

#[tokio::test]
async fn test_async_db_query() -> Result<()> {
    let pool = SqlitePool::connect(":memory:").await?;
    sqlx::query("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)")
        .execute(&pool)
        .await?;

    sqlx::query("INSERT INTO users (name) VALUES ('Alice')")
        .execute(&pool)
        .await?;

    let row: (i64, String) = sqlx::query_as("SELECT id, name FROM users WHERE name = 'Alice'")
        .fetch_one(&pool)
        .await?;

    assert_eq!(row.1, "Alice");
    println!("Retrieved user: {:?}", row);
    Ok(())
}

4. タイムアウトを伴う非同期処理のテスト

タスクがタイムアウトすることを確認するテストです。

テストコード

use tokio::time::{timeout, Duration, sleep};

#[tokio::test]
async fn test_async_task_with_timeout() {
    let result = timeout(Duration::from_secs(1), async_task()).await;
    assert!(result.is_err(), "Task should have timed out");
}

async fn async_task() {
    sleep(Duration::from_secs(2)).await;
}

5. パニック処理を含む非同期タスクのテスト

非同期タスクでパニックが発生した場合の処理をテストします。

テストコード

use tokio::task;

#[tokio::test]
async fn test_async_task_panic_handling() {
    let handle = task::spawn(async {
        panic!("Unexpected error occurred!");
    });

    let result = handle.await;
    assert!(result.is_err(), "Task should have panicked");
    println!("Task panicked as expected");
}

まとめ

これらの実践例を通じて、Rustの非同期テストのさまざまなシナリオに対応する方法を学びました。

  • HTTPリクエストやファイルI/Oのテスト
  • データベースクエリのテスト
  • タイムアウト設定やパニック処理のテスト

これらのテクニックを活用し、堅牢で効率的な非同期テストを実現しましょう。

まとめ

本記事では、Rustの非同期テストにおけるデバッグを効率化するためのツールとテクニックについて解説しました。非同期テストの基本概念から、よくある問題、そして具体的な解決方法までを網羅しました。

  • tokio-console を使った非同期タスクの可視化
  • ロギングテクニック と tracingクレート による詳細なデバッグ
  • タイムアウト設定 や エラーハンドリング の効果的な方法
  • 実践的な非同期テストの例 を通じた具体的なアプローチ

これらのツールとテクニックを活用することで、非同期テストの問題を迅速に特定し、信頼性の高い非同期プログラムを開発できます。Rustの非同期プログラミングは複雑ですが、適切な手法を学び、効率的なデバッグを行うことで、スムーズに開発を進めることが可能になります。

Rust
デバッグ 開発ツール Rust 非同期テスト

コメント

コメントする

目次
  1. Rustにおける非同期テストの概要
    1. 非同期プログラミングの仕組み
    2. 非同期テストの目的
    3. 非同期テストの基本構文
  2. 非同期テストにおける一般的な問題
    1. 1. タスクの非決定的な実行順序
    2. 2. デッドロック
    3. 3. タイムアウトと遅延
    4. 4. エラーハンドリングの難しさ
    5. 5. 非同期テストランタイムの競合
    6. 6. パニックが非同期タスク内で隠れる
  3. 非同期テストのデバッグを支援するツール
    1. 1. tokio-console
    2. 2. tracing
    3. 3. cargo-tarpaulin
    4. 4. loom
    5. 5. miri
    6. 6. RUST_LOG環境変数
  4. tokio-consoleの活用法
    1. tokio-consoleの概要
    2. tokio-consoleの導入方法
    3. tokio-consoleの起動方法
    4. 利用例
    5. tokio-consoleの出力例
    6. 利点
  5. 非同期テストでのロギングテクニック
    1. ロギングクレートの選定
    2. 基本的なロギングの実装
    3. logクレートの利用
    4. tracingクレートの利用
    5. 効果的なロギングのポイント
    6. まとめ
  6. tracingクレートを使ったデバッグ方法
    1. tracingの概要
    2. tracingの導入
    3. 基本的な使い方
    4. イベントの記録
    5. スパンを使ったタスクのトレース
    6. 非同期関数に#[instrument]属性を使う
    7. 利点
    8. まとめ
  7. タイムアウトとエラーハンドリングのテクニック
    1. タイムアウトの設定方法
    2. 使用例
    3. エラーハンドリングのテクニック
    4. Result型を活用したエラーハンドリング
    5. match文を使ったエラー処理
    6. 非同期タスクでのパニック対策
    7. パニック処理の例
    8. タイムアウトとエラーハンドリングの組み合わせ
    9. まとめ
  8. 実践的な非同期テストの例
    1. 1. 非同期HTTPリクエストのテスト
    2. 2. 非同期ファイル読み書きのテスト
    3. 3. 非同期データベース操作のテスト
    4. 4. タイムアウトを伴う非同期処理のテスト
    5. 5. パニック処理を含む非同期タスクのテスト
    6. まとめ
  9. まとめ