MENU
  1. ホーム
  2. Rust
  3. Rustのエラーログ管理：logとtracingクレートの活用ガイド

Rustのエラーログ管理：logとtracingクレートの活用ガイド

Rust

Rustにおいてエラー処理とログ記録は、堅牢なアプリケーションを構築するために欠かせない要素です。特に複雑なシステムでは、エラーが発生した際にその原因を特定するのが難しくなります。そのため、エラーを適切にログに記録することで、トラブルシューティングやデバッグが効率化されます。

Rustには、エラーログの記録に役立つクレートが複数存在します。代表的なものとして、シンプルなインターフェースを提供するlogクレートと、より高度な機能を備えたtracingクレートがあります。本記事では、これらのクレートを活用したエラーのロギング方法について詳しく解説します。

初心者から上級者まで、Rustのエラー管理におけるベストプラクティスを学ぶことで、より安定したアプリケーションを構築する手助けとなるでしょう。

目次
  1. Rustにおけるエラーログの重要性
    1. エラーログ記録の主な利点
    2. エラーログがない場合のリスク
  2. `log`クレートの概要とインストール方法
    1. `log`クレートの特徴
    2. `log`クレートのインストール手順
    3. ポイント
  3. `log`クレートを用いた基本的なログ記録
    1. 基本的なログ記録のコード例
    2. 出力ログのレベル設定
    3. 実行結果
    4. ログレベルの概要
    5. 実践的な活用ポイント
  4. `tracing`クレートの概要とインストール方法
    1. `tracing`クレートの特徴
    2. インストール方法
    3. 出力例
    4. 補足：`tracing`のログレベル
    5. ポイント
  5. `tracing`クレートを使った詳細なログ記録
    1. 基本的なログ記録の例
    2. フィールドを追加した構造化ログ
    3. イベントの階層的な追跡
    4. 非同期コードでの`tracing`活用
    5. まとめ
  6. `log`と`tracing`の違いと使い分け方
    1. `log`クレートの特徴
    2. `tracing`クレートの特徴
    3. 具体的な比較表
    4. 使い分けのポイント
    5. ハイブリッドアプローチ
    6. まとめ
  7. ログ出力フォーマットのカスタマイズ方法
    1. `env_logger`を使ったフォーマットのカスタマイズ
    2. 1. カスタムフォーマットの例
    3. 2. 出力例
    4. 3. カスタマイズのポイント
    5. `tracing_subscriber`を使ったフォーマットのカスタマイズ
    6. 1. デフォルトフォーマットのカスタマイズ例
    7. 2. 出力例
    8. 3. カスタマイズオプション
    9. JSON形式でのログ出力
    10. 出力例
    11. まとめ
  8. 効果的なログ設計のベストプラクティス
    1. 1. 適切なログレベルを使用する
    2. 2. 構造化ログを活用する
    3. 3. コンテキスト情報を追加する
    4. 4. ログフォーマットを統一する
    5. 5. 本番環境と開発環境でログ設定を切り替える
    6. 6. エラー処理時にログを記録する
    7. まとめ
  9. まとめ

Rustにおけるエラーログの重要性

エラー処理にログを記録することは、ソフトウェアの信頼性と保守性を高めるために非常に重要です。Rustでは、システムの安全性やパフォーマンスを保つために厳格なエラー処理が求められるため、エラー発生時の詳細な記録は欠かせません。

エラーログ記録の主な利点

  • 問題の特定と修正
    エラーログにより、どの部分で問題が発生したのかを正確に特定し、迅速に修正できます。
  • 運用環境でのトラブルシューティング
    本番環境ではデバッグが難しいため、エラーログを記録することで後から問題を追跡できます。
  • システムの監視と改善
    ログを分析することで、システムの弱点や改善点を見つけやすくなります。

エラーログがない場合のリスク

  • 問題の原因が不明確
    エラーの原因がわからないと、修正に多くの時間がかかります。
  • ユーザー体験の低下
    未処理のエラーが続くと、アプリケーションの信頼性が低下し、ユーザーが離れる原因になります。
  • システムクラッシュの増加
    適切にエラーを処理しないと、システム全体がクラッシュする可能性があります。

Rustでは、logやtracingといったクレートを使うことで効率的にエラーログを管理できます。これにより、安定したアプリケーションの運用が可能になります。

`log`クレートの概要とインストール方法

Rustのlogクレートは、シンプルかつ効果的にログ記録を行うためのインターフェースを提供します。log自体はロギングのためのフレームワークではなく、複数のロギングバックエンドと連携できる抽象的な仕組みです。これにより、必要に応じて異なるバックエンドを簡単に切り替えることができます。

`log`クレートの特徴

  • 抽象化されたログインターフェース
    logはログを記録するAPIのみを提供し、出力フォーマットや保存先はバックエンドクレートに委ねます。
  • 複数のバックエンドに対応
    env_logger、fern、slogなど、さまざまなバックエンドと連携可能です。
  • ログレベルの設定
    以下のログレベルに対応しています：
  • error：致命的なエラー
  • warn：警告
  • info：情報
  • debug：デバッグ情報
  • trace：詳細なトレース情報

`log`クレートのインストール手順

  1. Cargo.tomlに依存関係を追加
   [dependencies]
   log = "0.4"
   env_logger = "0.10"

ここでは、env_loggerも追加しています。env_loggerはシンプルなバックエンドで、環境変数でログレベルを制御できます。

  1. コード内でlogクレートを使用する準備
   use log::{info, warn, error};

   fn main() {
       env_logger::init();
       info!("This is an info message");
       warn!("This is a warning message");
       error!("This is an error message");
   }
  1. ビルドして実行
   RUST_LOG=info cargo run

環境変数RUST_LOGを指定することで、出力するログレベルを制御できます。

ポイント

  • logクレートは、インターフェースの役割のみを担うため、必ずバックエンドと一緒に使う必要があります。
  • 本番環境では、より高度なバックエンドを選ぶことで、ファイル出力やフォーマットのカスタマイズが可能です。

これでlogクレートの基本的な使い方とインストールが完了です。

`log`クレートを用いた基本的なログ記録

logクレートを使用すると、Rustプログラムで簡単にログを記録できます。ここでは、logの基本的な使い方をコード例と共に解説します。

基本的なログ記録のコード例

以下の例では、env_loggerをバックエンドとしてlogクレートを使い、異なるログレベルのメッセージを出力しています。

use log::{error, warn, info, debug, trace};

fn main() {
    // env_loggerを初期化
    env_logger::init();

    error!("これはエラーメッセージです");
    warn!("これは警告メッセージです");
    info!("これは情報メッセージです");
    debug!("これはデバッグメッセージです");
    trace!("これはトレースメッセージです");
}

出力ログのレベル設定

ログレベルは、環境変数RUST_LOGで設定できます。例えば、以下のコマンドでログレベルをinfoに設定して実行します。

RUST_LOG=info cargo run

この設定では、infoレベル以上（info、warn、error）のログが出力され、debugやtraceは表示されません。

実行結果

上記コードをRUST_LOG=infoで実行すると、以下のような出力が得られます。

[2024-06-07T12:34:56Z INFO  my_program] これは情報メッセージです
[2024-06-07T12:34:56Z WARN  my_program] これは警告メッセージです
[2024-06-07T12:34:56Z ERROR my_program] これはエラーメッセージです

ログレベルの概要

  • error：致命的なエラーを示します。
  • warn：警告や非致命的な問題を示します。
  • info：通常の動作に関する情報を示します。
  • debug：デバッグに役立つ詳細情報です。
  • trace：最も詳細なトレース情報です。

実践的な活用ポイント

  1. エラー処理の際にerror!を使用する
    重大なエラーが発生したときにはerror!マクロでログを記録します。
  2. デバッグ時にdebug!やtrace!を活用する
    開発中やデバッグ作業時には、詳細な情報をdebug!やtrace!で記録し、問題箇所を特定します。
  3. 環境変数で柔軟にログレベルを変更する
    本番環境ではinfoやwarnレベルで記録し、デバッグ時にはdebugやtraceに切り替えることで効率的なログ管理が可能です。

これで、logクレートを使った基本的なログ記録の方法が理解できました。

`tracing`クレートの概要とインストール方法

tracingクレートは、Rustで高性能かつ詳細なログやイベント情報を記録するためのクレートです。logクレートと似ていますが、tracingは構造化ロギングやイベントの階層的な追跡に優れており、特に非同期アプリケーションや大規模なシステムに適しています。

`tracing`クレートの特徴

  • 構造化ロギング
    ログに付加情報（フィールド）を追加し、詳細なコンテキストを記録できます。
  • イベントの階層的な追跡
    イベントの開始と終了を追跡し、システム内の処理の流れを把握できます。
  • 非同期処理のサポート
    非同期タスクのログを効率的に管理できるため、async/await環境で有用です。
  • 豊富なバックエンドサポート
    tracing-subscriberクレートを使えば、さまざまな出力形式やバックエンドに対応できます。

インストール方法

  1. Cargo.tomlに依存関係を追加
   [dependencies]
   tracing = "0.1"
   tracing-subscriber = "0.3"
  • tracing：メインのトレース記録クレート
  • tracing-subscriber：ログ出力用のバックエンドクレート
  1. プロジェクト内でtracingを使用する準備
   use tracing::{info, warn, error};
   use tracing_subscriber;

   fn main() {
       // デフォルトのログフォーマッターで初期化
       tracing_subscriber::fmt::init();

       info!("アプリケーションが開始されました");
       warn!("警告: データが見つかりません");
       error!("エラー: 処理中に問題が発生しました");
   }
  1. ビルドして実行
   cargo run

出力例

実行すると、次のような出力が得られます。

2024-06-07T12:34:56.789 INFO  my_program: アプリケーションが開始されました
2024-06-07T12:34:56.791 WARN  my_program: 警告: データが見つかりません
2024-06-07T12:34:56.793 ERROR my_program: エラー: 処理中に問題が発生しました

補足：`tracing`のログレベル

  • trace!：最も詳細なイベント記録
  • debug!：デバッグ用情報
  • info!：一般的な操作の情報
  • warn!：警告メッセージ
  • error!：エラーメッセージ

ポイント

  • 非同期プログラムの監視に優れているため、複数のタスクが同時に動作する場合に最適です。
  • 構造化ロギングを活用することで、ログにコンテキスト情報を加え、後で解析しやすくなります。

これでtracingクレートの基本的なインストール方法と概要が理解できました。次は実際に詳細なログ記録の方法を見ていきましょう。

`tracing`クレートを使った詳細なログ記録

tracingクレートは、Rustアプリケーションにおいて構造化された詳細なログやイベントのトレースを記録するために非常に有用です。ここでは、tracingを使ってより詳細なログを記録する方法を解説します。

基本的なログ記録の例

まず、tracingクレートを使ったシンプルなログ記録の例です。tracing_subscriberを使ってログを出力します。

use tracing::{info, warn, error, debug, trace};
use tracing_subscriber;

fn main() {
    // `tracing_subscriber`でフォーマッターを初期化
    tracing_subscriber::fmt::init();

    trace!("これはトレースログです");
    debug!("これはデバッグログです");
    info!("これは情報ログです");
    warn!("これは警告ログです");
    error!("これはエラーログです");
}

フィールドを追加した構造化ログ

tracingでは、ログにフィールド（追加情報）を含めることで、より詳細なコンテキストを記録できます。

use tracing::{info, error};
use tracing_subscriber;

fn main() {
    tracing_subscriber::fmt::init();

    let user_id = 42;
    let action = "login";

    info!(user_id, action, "ユーザーがログインしました");

    let error_code = 500;
    error!(error_code, "サーバーエラーが発生しました");
}

出力例:

2024-06-07T12:34:56.789 INFO  my_program: ユーザーがログインしました user_id=42 action="login"
2024-06-07T12:34:56.793 ERROR my_program: サーバーエラーが発生しました error_code=500

イベントの階層的な追跡

tracingでは、spanを使って処理の範囲を定義し、その中で発生したイベントをグループ化できます。

use tracing::{info, span, Level};
use tracing_subscriber;

fn main() {
    tracing_subscriber::fmt::init();

    let span = span!(Level::INFO, "request", method = "GET", path = "/home");
    let _enter = span.enter();

    info!("リクエストを処理しています");
    // ここでの処理は、この`span`内で記録されます

    info!("リクエスト処理が完了しました");
}

出力例:

2024-06-07T12:34:56.789 INFO  my_program: request{method="GET" path="/home"}: リクエストを処理しています
2024-06-07T12:34:56.793 INFO  my_program: request{method="GET" path="/home"}: リクエスト処理が完了しました

非同期コードでの`tracing`活用

非同期関数でもtracingを使うことで、タスクごとの詳細なログを記録できます。

use tracing::{info, instrument};
use tracing_subscriber;

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();
    process_request("user123").await;
}

#[instrument]
async fn process_request(user_id: &str) {
    info!("リクエストを処理中");
    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
    info!("リクエスト処理が完了しました");
}

出力例:

2024-06-07T12:34:56.789 INFO  my_program: process_request{user_id="user123"}: リクエストを処理中
2024-06-07T12:34:58.791 INFO  my_program: process_request{user_id="user123"}: リクエスト処理が完了しました

まとめ

  • フィールド付きの構造化ログでコンテキストを追加
  • spanを活用した階層的なイベント追跡
  • 非同期タスクのトレースで処理フローを詳細に記録

これにより、tracingクレートを使ってアプリケーションの動作を詳細に追跡し、デバッグやモニタリングが効率的になります。

`log`と`tracing`の違いと使い分け方

Rustでエラーログを記録する際、logクレートとtracingクレートはどちらも強力な選択肢です。しかし、それぞれの特徴や適したユースケースが異なります。ここでは、logとtracingの違いと使い分けのポイントについて解説します。

`log`クレートの特徴

  • シンプルなAPI
    logはシンプルなログ記録インターフェースを提供し、バックエンドを柔軟に切り替えられます。
  • バックエンドの選択肢が豊富
    env_logger、fern、slogなど、多くのバックエンドと連携可能です。
  • 基本的なログレベル
    error、warn、info、debug、traceの5つのログレベルに対応しています。
  • 同期処理向け
    非同期処理のサポートは限定的で、主に同期プログラムでの利用が適しています。

適したユースケース

  • 小規模なプロジェクトやシンプルなロギングが必要な場合。
  • バックエンドを自由に切り替えたい場合。
  • 構造化ログや非同期処理が不要な場合。

`tracing`クレートの特徴

  • 構造化ロギング
    ログにフィールド（追加情報）を加え、コンテキスト付きの詳細な情報を記録できます。
  • イベントの階層的な追跡
    spanを使って処理の範囲を明確にし、イベントの開始と終了を追跡できます。
  • 非同期処理のサポート
    非同期タスクをまたぐ処理のトレースが可能で、並行処理のデバッグが容易です。
  • 高性能なログ記録
    大規模なアプリケーションやパフォーマンスが重要なシステムに適しています。

適したユースケース

  • 非同期プログラムや複雑な並行処理がある場合。
  • 大規模なシステムや複数のコンポーネントが連携するアプリケーション。
  • 詳細なコンテキスト付きのロギングやイベント追跡が必要な場合。

具体的な比較表

特徴logtracing
ロギングタイプシンプルなロギング構造化ロギング、イベント追跡
非同期サポート限定的強力なサポート
構造化データの追加不可可能
ユースケース小規模・シンプルなアプリ大規模・非同期アプリ
バックエンド切り替え柔軟に切り替え可能tracing_subscriberが主流

使い分けのポイント

  • シンプルなログが必要なら：logを選択
    例：小規模なCLIツールやシンプルなWebアプリケーション。
  • 非同期処理や詳細なトレースが必要なら：tracingを選択
    例：複雑なバックエンドシステムや非同期タスクが多いアプリケーション。

ハイブリッドアプローチ

logとtracingを組み合わせることも可能です。tracingにはtracing-logクレートがあり、logベースのライブラリもtracingのシステム内で利用できます。

[dependencies]
tracing = "0.1"
tracing-log = "0.1"

これにより、既存のlogベースのライブラリを使いつつ、tracingの高度な機能を活用できます。

まとめ

  • シンプルなロギングにはlog。
  • 構造化や非同期トレースにはtracing。
  • 既存のlogクレートをtracingで活用するハイブリッドも選択肢の一つです。

用途やプロジェクトの規模に合わせて、適切なクレートを選びましょう。

ログ出力フォーマットのカスタマイズ方法

Rustにおけるログ出力は、デフォルトのフォーマットでは十分でない場合があります。logやtracingクレートでは、バックエンドを利用してログ出力フォーマットを柔軟にカスタマイズできます。ここでは、env_loggerとtracing_subscriberを使ったカスタマイズ方法を解説します。

`env_logger`を使ったフォーマットのカスタマイズ

logクレートとenv_loggerバックエンドを使って、ログのフォーマットをカスタマイズする方法です。

1. カスタムフォーマットの例

use log::{info, warn};
use env_logger::{Builder, fmt::Formatter};
use std::io::Write;

fn main() {
    // カスタムフォーマッターを定義
    Builder::new()
        .format(|buf, record| {
            writeln!(
                buf,
                "[{}] {}: {}",
                record.level(),
                record.target(),
                record.args()
            )
        })
        .init();

    info!("これはカスタムフォーマットの情報ログです");
    warn!("これはカスタムフォーマットの警告ログです");
}

2. 出力例

[INFO] my_program: これはカスタムフォーマットの情報ログです
[WARN] my_program: これはカスタムフォーマットの警告ログです

3. カスタマイズのポイント

  • record.level()：ログのレベル（例：INFO, WARN）
  • record.target()：ログが呼び出されたモジュール名
  • record.args()：ログのメッセージ

`tracing_subscriber`を使ったフォーマットのカスタマイズ

tracingクレートとtracing_subscriberバックエンドでは、より高度なフォーマットのカスタマイズが可能です。

1. デフォルトフォーマットのカスタマイズ例

use tracing::{info, warn};
use tracing_subscriber::fmt::format::FmtSpan;
use tracing_subscriber;

fn main() {
    // カスタムフォーマットで初期化
    tracing_subscriber::fmt()
        .with_target(true)       // ログ出力にターゲット（モジュール名）を含める
        .with_level(true)        // ログレベルを表示
        .with_thread_ids(true)   // スレッドIDを表示
        .with_span_events(FmtSpan::FULL)  // spanの開始・終了イベントを表示
        .init();

    info!("カスタムフォーマットの情報ログです");
    warn!("カスタムフォーマットの警告ログです");
}

2. 出力例

2024-06-07T12:34:56.789 INFO [my_program] [thread=1]: カスタムフォーマットの情報ログです
2024-06-07T12:34:56.793 WARN [my_program] [thread=1]: カスタムフォーマットの警告ログです

3. カスタマイズオプション

  • with_target(true)：モジュール名を表示
  • with_level(true)：ログレベルを表示
  • with_thread_ids(true)：スレッドIDを表示
  • with_span_events(FmtSpan::FULL)：spanの開始、終了、エラー時のイベントを出力

JSON形式でのログ出力

tracing_subscriberではJSON形式のログ出力も可能です。

use tracing::{info, warn};
use tracing_subscriber::fmt::format::JsonFields;
use tracing_subscriber;

fn main() {
    tracing_subscriber::fmt()
        .json() // JSON形式でログ出力
        .flatten_event(true) // イベントをフラットなJSON形式で出力
        .init();

    info!(user_id = 42, "ユーザーがログインしました");
    warn!(error_code = 404, "データが見つかりません");
}

出力例

{"timestamp":"2024-06-07T12:34:56.789","level":"INFO","fields":{"user_id":42,"message":"ユーザーがログインしました"}}
{"timestamp":"2024-06-07T12:34:56.793","level":"WARN","fields":{"error_code":404,"message":"データが見つかりません"}}

まとめ

  • env_loggerを使えば、シンプルなフォーマットカスタマイズが可能です。
  • tracing_subscriberでは、構造化ロギングやJSON出力など高度なカスタマイズが可能です。
  • アプリケーションの要件に合わせてフォーマットをカスタマイズし、効率的なログ管理を実現しましょう。

効果的なログ設計のベストプラクティス

エラーログやデバッグ情報を効果的に記録するためには、適切なログ設計が不可欠です。ここでは、Rustのアプリケーションでlogやtracingクレートを活用する際に役立つログ設計のベストプラクティスを紹介します。

1. 適切なログレベルを使用する

ログは適切なレベルで記録することで、重要な情報を見逃さずに済みます。

  • error：致命的な問題。アプリケーションの動作に支障が出る場合。
  • warn：非致命的な問題。将来的に問題が起こり得る状態。
  • info：通常の動作。システムの状態や処理の進捗を示す。
  • debug：デバッグ用の詳細情報。開発・テスト時に使用。
  • trace：最も詳細な情報。関数の呼び出しや内部状態を追跡するため。

例：

use log::{error, warn, info, debug, trace};

fn main() {
    error!("重大なエラーが発生しました");
    warn!("注意：不正な入力です");
    info!("処理が正常に完了しました");
    debug!("デバッグ情報：変数xの値は42です");
    trace!("トレース情報：関数process()が呼び出されました");
}

2. 構造化ログを活用する

tracingクレートを使って構造化ログを記録し、ログに付加情報を加えることで、後での解析が容易になります。

例：

use tracing::{info, error};

fn main() {
    let user_id = 42;
    let action = "update_profile";

    info!(user_id, action, "ユーザーがプロフィールを更新しました");
    error!(user_id, action, "プロフィール更新中にエラーが発生しました");
}

出力例：

2024-06-07T12:34:56 INFO  my_program: ユーザーがプロフィールを更新しました user_id=42 action="update_profile"
2024-06-07T12:34:56 ERROR my_program: プロフィール更新中にエラーが発生しました user_id=42 action="update_profile"

3. コンテキスト情報を追加する

ログにコンテキスト情報を含めることで、問題が発生した際の状況を正確に把握できます。

tracingを使用した例：

use tracing::{span, Level, info};

fn main() {
    let span = span!(Level::INFO, "request", method = "POST", path = "/api/data");
    let _enter = span.enter();

    info!("リクエストの処理を開始しました");
    // ここでの処理はspan内に記録されます
    info!("リクエスト処理が完了しました");
}

4. ログフォーマットを統一する

一貫したフォーマットを使用することで、ログの解析や検索が容易になります。例えば、タイムスタンプ、ログレベル、モジュール名、メッセージを含めたフォーマットを採用します。

env_loggerのカスタムフォーマット例：

use env_logger::{Builder, fmt::Formatter};
use log::info;
use std::io::Write;

fn main() {
    Builder::new()
        .format(|buf, record| {
            writeln!(
                buf,
                "{} [{}] - {}",
                chrono::Local::now().format("%Y-%m-%d %H:%M:%S"),
                record.level(),
                record.args()
            )
        })
        .init();

    info!("ログフォーマットの統一例です");
}

5. 本番環境と開発環境でログ設定を切り替える

  • 開発環境：詳細なデバッグログを記録する。
  • 本番環境：infoやwarnレベルのログのみを記録し、パフォーマンスを維持する。

Cargo.tomlでの設定例：

[profile.dev]
debug = true

[profile.release]

debug = false

6. エラー処理時にログを記録する

エラーが発生した際は、必ずエラーログを記録しましょう。エラー内容やスタックトレースを含めると、原因究明が容易になります。

例：

use log::error;

fn process_data() -> Result<(), &'static str> {
    Err("データ処理中にエラーが発生しました")
}

fn main() {
    if let Err(e) = process_data() {
        error!("エラー: {}", e);
    }
}

まとめ

効果的なログ設計のベストプラクティスを活用することで、以下のメリットが得られます：

  • 問題の早期発見と修正
  • システムの状態把握と監視の効率化
  • メンテナンス性の向上

適切なログ設計で、Rustアプリケーションの品質と信頼性を高めましょう。

まとめ

本記事では、Rustにおけるエラーをログに記録するためのクレートとして、logとtracingの活用法について解説しました。

  • logクレートはシンプルなインターフェースを提供し、小規模なプロジェクトや基本的なロギングに適しています。
  • tracingクレートは構造化ロギングや非同期処理のトレースが可能で、大規模システムや複雑な並行処理に適しています。
  • フォーマットのカスタマイズや効果的なログ設計のベストプラクティスを導入することで、効率的なデバッグとトラブルシューティングが実現できます。

適切なロギング手法を選択することで、Rustアプリケーションの信頼性と保守性が向上します。用途やシステムの要件に応じて、logとtracingを使い分け、安定したソフトウェア開発を行いましょう。

Rust
エラーログ Rust クレート log tracing

コメント

コメントする

目次
  1. Rustにおけるエラーログの重要性
    1. エラーログ記録の主な利点
    2. エラーログがない場合のリスク
  2. `log`クレートの概要とインストール方法
    1. `log`クレートの特徴
    2. `log`クレートのインストール手順
    3. ポイント
  3. `log`クレートを用いた基本的なログ記録
    1. 基本的なログ記録のコード例
    2. 出力ログのレベル設定
    3. 実行結果
    4. ログレベルの概要
    5. 実践的な活用ポイント
  4. `tracing`クレートの概要とインストール方法
    1. `tracing`クレートの特徴
    2. インストール方法
    3. 出力例
    4. 補足：`tracing`のログレベル
    5. ポイント
  5. `tracing`クレートを使った詳細なログ記録
    1. 基本的なログ記録の例
    2. フィールドを追加した構造化ログ
    3. イベントの階層的な追跡
    4. 非同期コードでの`tracing`活用
    5. まとめ
  6. `log`と`tracing`の違いと使い分け方
    1. `log`クレートの特徴
    2. `tracing`クレートの特徴
    3. 具体的な比較表
    4. 使い分けのポイント
    5. ハイブリッドアプローチ
    6. まとめ
  7. ログ出力フォーマットのカスタマイズ方法
    1. `env_logger`を使ったフォーマットのカスタマイズ
    2. 1. カスタムフォーマットの例
    3. 2. 出力例
    4. 3. カスタマイズのポイント
    5. `tracing_subscriber`を使ったフォーマットのカスタマイズ
    6. 1. デフォルトフォーマットのカスタマイズ例
    7. 2. 出力例
    8. 3. カスタマイズオプション
    9. JSON形式でのログ出力
    10. 出力例
    11. まとめ
  8. 効果的なログ設計のベストプラクティス
    1. 1. 適切なログレベルを使用する
    2. 2. 構造化ログを活用する
    3. 3. コンテキスト情報を追加する
    4. 4. ログフォーマットを統一する
    5. 5. 本番環境と開発環境でログ設定を切り替える
    6. 6. エラー処理時にログを記録する
    7. まとめ
  9. まとめ