MENU
  1. ホーム
  2. TypeScript
  3. TypeScriptのasync/awaitを使ったエラーログ実装の完全ガイド

TypeScriptのasync/awaitを使ったエラーログ実装の完全ガイド

TypeScript

TypeScriptで非同期処理を行う際、エラーハンドリングは非常に重要です。非同期処理はAPI呼び出しやデータベース操作など、外部リソースとのやり取りを含むため、処理が予期せず失敗するリスクが高まります。失敗した処理のエラーログを適切に記録し、後から問題を特定・修正することが重要です。本記事では、TypeScriptで非同期処理を行う際にasync/awaitを使ったエラーログの効果的な実装方法について、基礎から高度な応用まで詳しく解説します。

目次

async/awaitの基礎知識


非同期処理は、JavaScriptやTypeScriptにおいて重要な機能であり、APIのリクエストやファイルの読み込みなど、時間のかかる処理を効率的に実行するために利用されます。async/awaitは、非同期処理をよりシンプルで直感的に書けるようにする構文です。

async/awaitの仕組み


async関数は常にPromiseを返す非同期関数を作成するために使用されます。awaitは、そのPromiseが解決されるまでコードの実行を一時停止し、結果を返す構文です。これにより、従来のPromise.then()チェーンよりも同期的な見た目でコードを書くことができます。

例：基本的なasync/awaitの使用法


以下のコードは、async/awaitを使った基本的な非同期処理の例です：

async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
}

このように、awaitを使うことで、非同期処理が同期的なコードフローで記述でき、可読性が向上します。

try/catchを使ったエラーハンドリング


非同期処理で発生するエラーを適切にキャッチし、処理するためには、try/catch構文を使用します。async/awaitと組み合わせることで、同期処理のようにエラーハンドリングを行うことができ、Promiseのcatch()メソッドを使った場合よりも読みやすいコードを書くことが可能です。

try/catchの基本的な使い方


tryブロック内に非同期処理を記述し、エラーが発生した場合はcatchブロックでそのエラーをキャッチします。catchブロック内では、エラーの内容をログに記録したり、ユーザーに通知したりすることが可能です。

例：try/catchでのエラーハンドリング


以下は、非同期関数でtry/catchを使用した基本的なエラーハンドリングの例です：

async function fetchDataWithErrorHandling() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error('Network response was not ok');
    }
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Error fetching data:', error.message);
  }
}

エラー処理の重要性


try/catchを使用することで、非同期処理のエラーを確実にキャッチし、プログラムの予期しないクラッシュを防止できます。特に、ネットワーク通信やファイル操作といった外部依存がある場合は、エラーが発生する可能性が高く、適切なエラーハンドリングが不可欠です。

非同期エラーハンドリングの注意点


非同期処理では、同期処理とは異なるエラーハンドリングの課題が存在します。非同期処理中に発生したエラーは、通常のエラー処理ではキャッチできないことがあり、適切にハンドリングしないとエラーが見逃される可能性があります。また、非同期処理は複数のスレッドで同時に実行される場合があるため、エラーが発生したタイミングやその影響が予測しにくい点も注意が必要です。

Promiseチェーンとの違い


従来のPromiseチェーンでは、.then()や.catch()を使ってエラーハンドリングを行いますが、async/awaitではtry/catch構文を使うため、コードの流れがよりシンプルになります。しかし、async/awaitを使用しても、すべてのエラーを正確にキャッチできるわけではないため、いくつかの注意点を押さえる必要があります。

非同期処理の中断によるリスク


非同期関数が途中でエラーを投げた場合、awaitの後に記述されたコードは実行されません。そのため、次の処理が重要な場合は、エラー発生後にどう処理を続行するか、または代替手段を用意する必要があります。

async function processData() {
  try {
    const data = await fetchData();
    // この処理が行われる前にエラーが発生する可能性がある
    processFurther(data);
  } catch (error) {
    console.error('Error processing data:', error);
    // 代替処理やリトライの実装が必要
  }
}

複数の非同期処理におけるエラー管理


非同期処理が連鎖している場合、例えば複数のawaitが含まれる処理では、それぞれに対して個別にエラーハンドリングが必要です。これを怠ると、特定の処理で発生したエラーが上位でキャッチされないまま、次の非同期処理が続行されてしまうリスクがあります。

async function processMultiple() {
  try {
    const data1 = await fetchFirstData();
    const data2 = await fetchSecondData();
    processBoth(data1, data2);
  } catch (error) {
    console.error('Error in one of the processes:', error);
  }
}

非同期処理におけるエラーハンドリングでは、エラーが発生するタイミングや影響をしっかり把握し、どのようにリカバリーするかを計画しておくことが重要です。

エラーログを保存する手法


非同期処理で発生したエラーは、単にコンソールに出力するだけでなく、後から追跡・分析するためにログとして保存することが重要です。エラーログを適切に保存することで、システム障害の原因分析や改善に役立ちます。エラーログを保存するには、ファイルやデータベースなどに記録する方法があります。

ログをファイルに保存する方法


ローカル環境やサーバー上で動作するアプリケーションでは、エラーログをファイルに保存するのが一般的です。Node.js環境であれば、標準のfsモジュールを使って、簡単にエラーログをファイルに書き出すことができます。

import * as fs from 'fs';

async function logErrorToFile(error: Error) {
  const logEntry = `${new Date().toISOString()} - Error: ${error.message}\n`;
  fs.appendFile('error.log', logEntry, (err) => {
    if (err) {
      console.error('Failed to write to log file:', err);
    }
  });
}

この例では、エラーが発生した時に、error.logファイルにエラーメッセージが追記されるようになっています。エラーログの内容には、タイムスタンプも含めることで、発生した時間も把握できるようにしています。

データベースにエラーログを保存する方法


大規模なアプリケーションや、複数のサーバーで動作するシステムでは、データベースにエラーログを保存する方が便利です。データベースに保存することで、集中管理ができ、後から簡単にログを検索したり分析できるメリットがあります。

以下は、MongoDBを使ってエラーログを保存する例です：

import { MongoClient } from 'mongodb';

async function logErrorToDatabase(error: Error) {
  const client = new MongoClient('mongodb://localhost:27017');
  try {
    await client.connect();
    const db = client.db('errorLogs');
    const logsCollection = db.collection('logs');
    await logsCollection.insertOne({
      message: error.message,
      stack: error.stack,
      timestamp: new Date(),
    });
  } catch (dbError) {
    console.error('Failed to log error to database:', dbError);
  } finally {
    await client.close();
  }
}

このコードでは、エラーのメッセージとスタックトレース、発生時間をMongoDBに記録しています。データベースを利用することで、エラーログの管理や参照が非常に容易になります。

クラウドサービスを利用したログ保存


さらに、クラウドサービス（例えば、Amazon CloudWatchやLogglyなど）を利用してエラーログを保存・分析する方法もあります。これらのサービスを利用することで、リアルタイムのモニタリングや通知、分析機能を組み込むことができ、より高度なログ管理が可能です。

エラーログを適切な形式で保存し、定期的にモニタリングすることで、システムの健全性を維持し、迅速なトラブルシューティングが可能になります。

実践：エラーログを活用した非同期関数の実装例


ここでは、実際に非同期関数でエラーログを記録する実装例を紹介します。非同期処理の中で発生したエラーをキャッチし、それをファイルやデータベースにログとして保存することで、後から問題を特定しやすくする方法です。このセクションでは、try/catchとasync/awaitを組み合わせ、非同期処理で発生したエラーを効率的にログに残す方法を学びます。

非同期処理でのエラーログ記録の例


以下のコードは、API呼び出しを行い、その結果に応じてエラーログを記録する非同期関数の例です。エラーログはファイルに保存する形式で、fsモジュールを利用しています。

import * as fs from 'fs';

async function fetchDataAndLogError() {
  try {
    const response = await fetch('https://api.example.com/data');

    if (!response.ok) {
      throw new Error('Failed to fetch data: ' + response.statusText);
    }

    const data = await response.json();
    console.log('Data fetched successfully:', data);

  } catch (error) {
    console.error('Error occurred:', error.message);
    logErrorToFile(error);
  }
}

async function logErrorToFile(error: Error) {
  const logEntry = `${new Date().toISOString()} - Error: ${error.message}\n`;
  fs.appendFile('error.log', logEntry, (err) => {
    if (err) {
      console.error('Failed to write to log file:', err);
    }
  });
}

この例では、fetchDataAndLogError関数がAPIからデータを取得し、エラーが発生した場合にはエラーメッセージをファイルにログとして保存します。try/catchブロック内でエラーがキャッチされ、logErrorToFile関数が呼ばれてログを書き込む処理が行われます。

データベースにエラーログを記録する例


データベースにログを保存する場合は、例えばMongoDBを使用して次のように実装できます：

import { MongoClient } from 'mongodb';

async function fetchDataAndLogToDB() {
  try {
    const response = await fetch('https://api.example.com/data');

    if (!response.ok) {
      throw new Error('Failed to fetch data: ' + response.statusText);
    }

    const data = await response.json();
    console.log('Data fetched successfully:', data);

  } catch (error) {
    console.error('Error occurred:', error.message);
    await logErrorToDatabase(error);
  }
}

async function logErrorToDatabase(error: Error) {
  const client = new MongoClient('mongodb://localhost:27017');

  try {
    await client.connect();
    const db = client.db('errorLogs');
    const logsCollection = db.collection('logs');

    await logsCollection.insertOne({
      message: error.message,
      stack: error.stack,
      timestamp: new Date(),
    });

    console.log('Error logged to database');
  } catch (dbError) {
    console.error('Failed to log error to database:', dbError);
  } finally {
    await client.close();
  }
}

このコードでは、fetchDataAndLogToDB関数内で発生したエラーがMongoDBに記録されます。データベースを使用することで、ログの保存や後からの検索が簡単に行えるようになります。

複数の非同期処理を扱う場合の工夫


複数の非同期処理を行う際には、個々の処理でエラーが発生しても他の処理に影響を与えないように、try/catchを個別に適用することが重要です。以下は、その一例です：

async function performMultipleAsyncTasks() {
  try {
    await fetchDataAndLogError();  // APIからデータを取得
    await fetchDataAndLogToDB();    // データベースにログを記録
  } catch (error) {
    console.error('A critical error occurred:', error);
  }
}

このように、非同期関数のエラーハンドリングは、try/catchとログ記録の組み合わせで堅牢なシステムを構築する重要なステップです。実際のシステムでは、エラー発生時に処理を中断するかどうか、再試行するかなど、ケースに応じた実装が求められます。

複数の非同期処理でのエラーログの統合


複数の非同期処理を同時に実行する場面では、各処理のエラーハンドリングをどのように行うかが重要です。特に、複数の非同期処理にまたがるエラーログの一元化を行うことで、システム全体の監視が容易になり、エラーが発生した際のトラブルシューティングが効果的になります。

Promise.allを使った非同期処理の統合


複数の非同期処理を同時に実行する場合、Promise.allを使って処理を一括管理することができます。Promise.allは、すべてのPromiseが解決されるまで待機し、一つでもエラーが発生すると、その時点で処理全体が失敗します。この場合、エラーはひとつに集約され、統合的に管理できます。

async function performMultipleTasks() {
  try {
    await Promise.all([
      fetchDataAndLogError(),
      fetchDataAndLogToDB(),
      anotherAsyncTask(),
    ]);
    console.log('All tasks completed successfully');
  } catch (error) {
    console.error('Error occurred during one of the tasks:', error);
    logErrorToFile(error);
  }
}

この例では、Promise.allを使用して3つの非同期処理を同時に実行し、いずれかの処理でエラーが発生した場合には、統一的にエラーハンドリングを行います。エラーはひとつのcatchブロックでキャッチされ、ログに記録されます。

個別エラーハンドリングと一元化


ただし、Promise.allでは、どの処理がエラーを発生させたのかの詳細な情報を得にくいため、個別の非同期処理ごとにエラーハンドリングを行い、エラーログを一元化する方法も検討する必要があります。この場合、各非同期処理のエラーを収集し、統一されたフォーマットでログに記録することが有効です。

async function performMultipleTasksIndividually() {
  const errors: Error[] = [];

  const task1 = fetchDataAndLogError().catch((error) => {
    errors.push(error);
    logErrorToFile(error);
  });

  const task2 = fetchDataAndLogToDB().catch((error) => {
    errors.push(error);
    logErrorToFile(error);
  });

  const task3 = anotherAsyncTask().catch((error) => {
    errors.push(error);
    logErrorToFile(error);
  });

  await Promise.all([task1, task2, task3]);

  if (errors.length > 0) {
    console.error('One or more tasks failed:', errors);
  }
}

このコードでは、各非同期処理が失敗した場合に個別にエラーをキャッチし、そのエラーをerrors配列に追加して一元管理しています。エラーが複数発生した場合でも、すべてのエラーを収集し、後から統合的にログに記録できます。

非同期処理のリトライ戦略


複数の非同期処理の中でエラーが発生した場合、単にエラーログを記録するだけでなく、エラーに応じて処理を再試行（リトライ）することも重要です。特にネットワークエラーなど、一時的な問題が原因の場合、リトライによって処理が成功することが多いため、エラーハンドリングにリトライ機能を組み込むことが推奨されます。

async function retryAsyncTask(task: () => Promise<any>, retries: number) {
  for (let i = 0; i < retries; i++) {
    try {
      return await task();
    } catch (error) {
      if (i === retries - 1) {
        logErrorToFile(error);
        throw error;  // 最後の試行で失敗した場合、エラーを投げる
      }
      console.warn(`Retrying task, attempt ${i + 1}`);
    }
  }
}

このリトライ機能を活用することで、非同期処理のエラーハンドリングをより堅牢にし、単一のエラーによるシステム全体の障害を回避することができます。

エラーログ統合のベストプラクティス


複数の非同期処理を行う際には、以下の点に注意してエラーログを統合することがベストプラクティスです：

  • すべての非同期処理に個別のエラーハンドリングを実装し、失敗した処理を特定しやすくする。
  • 統一されたエラーログフォーマットを使用して、エラーログを一元管理しやすくする。
  • リトライ戦略を組み込み、ネットワークエラーなど一時的な障害に対応できるようにする。

エラーハンドリングとログの統合を適切に行うことで、複雑な非同期処理の問題を効率的に解決でき、システム全体の安定性を向上させることができます。

ログ収集ツールとの連携


大規模なアプリケーションやマイクロサービス環境では、エラーログをローカルファイルやデータベースに保存するだけでは十分でない場合があります。こうしたシステムでは、リアルタイムでエラーログを収集・分析し、必要に応じてアラートを発するログ収集ツールとの連携が不可欠です。クラウドベースのログ管理ツールや専用のログ収集システムを使うことで、エラーログの一元管理やリアルタイムの監視が可能になります。

一般的なログ収集ツール


以下は、ログ収集において広く使用されているツールです：

  • Loggly：クラウドベースのログ管理プラットフォームで、リアルタイムのエラーログ監視とアラート機能を提供します。
  • Amazon CloudWatch：AWSのサービスで、アプリケーションのログを集約し、メトリクスを可視化できる。
  • ELKスタック（Elasticsearch, Logstash, Kibana）：強力なログ収集・検索・可視化機能を持つオープンソースのツールセット。
  • Sentry：エラーログの監視と通知に特化したプラットフォームで、特に開発者に人気です。

これらのツールを使うことで、ログの収集だけでなく、問題が発生した際の迅速な対応が可能となります。

Logglyを使用したエラーログの送信例


以下の例では、Logglyを使ってTypeScriptアプリケーションからエラーログを送信する方法を示します。LogglyはAPIを通じてログを送信できるため、エラーログをHTTPリクエストで送信するだけで簡単に利用可能です。

import fetch from 'node-fetch';

async function logErrorToLoggly(error: Error) {
  const logglyEndpoint = 'https://logs-01.loggly.com/inputs/YOUR-LOGGLY-TOKEN/tag/http/';
  const logEntry = {
    timestamp: new Date(),
    message: error.message,
    stack: error.stack,
  };

  try {
    await fetch(logglyEndpoint, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(logEntry),
    });
    console.log('Error logged to Loggly');
  } catch (err) {
    console.error('Failed to log error to Loggly:', err);
  }
}

このコードは、エラーが発生した場合にLogglyのAPIエンドポイントへエラーログをPOSTリクエストで送信します。ログはリアルタイムで収集され、ダッシュボードで確認したり、アラートを設定したりすることが可能です。

Amazon CloudWatchと非同期エラーログの連携


AWS環境でアプリケーションを運用している場合、Amazon CloudWatchを利用してエラーログを監視することが有効です。CloudWatchはログを集約するだけでなく、特定のエラーが発生した際に通知を送るアラート機能も提供します。

以下は、AWS SDKを使ってCloudWatch Logsにエラーログを送信する例です：

import AWS from 'aws-sdk';

const cloudWatchLogs = new AWS.CloudWatchLogs({ region: 'us-east-1' });

async function logErrorToCloudWatch(error: Error) {
  const logGroupName = '/my-app/error-logs';
  const logStreamName = 'application-errors';

  try {
    const params = {
      logGroupName,
      logStreamName,
      logEvents: [
        {
          message: JSON.stringify({
            timestamp: new Date(),
            message: error.message,
            stack: error.stack,
          }),
          timestamp: Date.now(),
        },
      ],
    };
    await cloudWatchLogs.putLogEvents(params).promise();
    console.log('Error logged to CloudWatch');
  } catch (err) {
    console.error('Failed to log error to CloudWatch:', err);
  }
}

この例では、CloudWatch Logsにエラーログを送信する非同期処理を実装しています。logGroupNameやlogStreamNameを指定することで、ログを適切に分類・管理できます。

ログ収集ツールの利点


ログ収集ツールを利用する主な利点は以下の通りです：

  • リアルタイム監視：ログがリアルタイムで収集され、即座に問題を検知できます。
  • アラート機能：特定のエラーや条件を満たした場合に、メールやチャット通知などでアラートを発することができます。
  • 分析と可視化：ログを可視化し、時間経過によるパターン分析や、システム全体のパフォーマンス監視が可能です。
  • スケーラビリティ：大規模なシステムでも簡単にスケールアウトでき、ログの量が増えても管理しやすい。

これらのツールと連携することで、アプリケーションのエラーを効率的に管理でき、障害対応の迅速化とシステムの信頼性向上が期待できます。

例外処理を拡張した高度なエラーハンドリング


単純なtry/catchを使ったエラーハンドリングだけでは、複雑な非同期処理や大規模なアプリケーションで発生するすべてのエラーを効率的に管理できません。そこで、より柔軟で高度なエラーハンドリングを実現するために、カスタムエラーや例外処理の拡張が有効です。これにより、エラーの種類に応じた適切な対応ができ、エラーログの精度や対応速度を向上させることができます。

カスタムエラーの作成


JavaScriptおよびTypeScriptでは、標準のErrorクラスを拡張してカスタムエラーを作成することができます。これにより、エラーの内容をより詳細に伝えたり、特定の状況に応じたエラーメッセージを提供したりすることができます。

以下の例では、APIリクエストに失敗した場合のカスタムエラーを作成しています：

class ApiError extends Error {
  constructor(message: string, public statusCode: number) {
    super(message);
    this.name = 'ApiError';
  }
}

async function fetchDataWithCustomError() {
  try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new ApiError('API request failed', response.status);
    }
    const data = await response.json();
    console.log('Data:', data);
  } catch (error) {
    if (error instanceof ApiError) {
      console.error(`API Error: ${error.message}, Status Code: ${error.statusCode}`);
    } else {
      console.error('General Error:', error.message);
    }
    logErrorToFile(error);
  }
}

このコードでは、ApiErrorクラスを作成し、APIリクエストのエラーハンドリングに活用しています。APIエラーと一般的なエラーを区別して処理することで、より正確なログを残すことができ、エラーの原因特定が容易になります。

非同期処理の階層的なエラーハンドリング


複雑なシステムでは、非同期処理が階層化され、複数の処理が連携して実行されます。そのため、個々の処理で発生するエラーを適切に処理しつつ、全体としても一貫したエラーハンドリングを行うことが必要です。

以下の例は、複数の非同期処理を階層的に管理し、それぞれの処理でエラーが発生した場合に個別の対応を行いながら、最終的なエラーハンドリングを一元管理しています：

async function processData() {
  try {
    await performStep1();
    await performStep2();
    await performStep3();
  } catch (error) {
    console.error('Error in processing steps:', error);
    logErrorToFile(error);
  }
}

async function performStep1() {
  try {
    // ステップ1の処理
  } catch (error) {
    throw new Error('Error in Step 1: ' + error.message);
  }
}

async function performStep2() {
  try {
    // ステップ2の処理
  } catch (error) {
    throw new Error('Error in Step 2: ' + error.message);
  }
}

async function performStep3() {
  try {
    // ステップ3の処理
  } catch (error) {
    throw new Error('Error in Step 3: ' + error.message);
  }
}

この例では、各ステップの処理でエラーが発生した場合、それぞれのステップで適切なエラーメッセージが生成され、最終的に一つのcatchブロックで処理されます。これにより、エラー発生箇所の特定が容易になり、エラー内容に応じたログを残すことができます。

エラーの再スローと再試行


エラーハンドリングの一環として、特定の条件下でエラーを再スローしたり、再試行を行うことで、エラーによるシステム全体の失敗を防ぐことができます。特に一時的な問題（ネットワークエラーなど）に対しては、再試行戦略を取り入れることが有効です。

以下は、非同期処理でエラーが発生した場合に、一定回数まで再試行を行う例です：

async function retryOperation(task: () => Promise<any>, retries: number) {
  for (let i = 0; i < retries; i++) {
    try {
      return await task();
    } catch (error) {
      if (i === retries - 1) {
        console.error('Task failed after maximum retries:', error.message);
        logErrorToFile(error);
        throw error;  // 最後の試行で失敗した場合にエラーを再スロー
      }
      console.log(`Retrying task (${i + 1}/${retries})...`);
    }
  }
}

async function fetchDataWithRetry() {
  await retryOperation(() => fetchDataWithCustomError(), 3);
}

このコードは、非同期タスクが失敗した際に再試行を行い、最終的にエラーが解決されなければエラーログに記録して再スローします。このようにすることで、エラーハンドリングが柔軟かつ効率的になります。

エラーハンドリングのベストプラクティス


高度なエラーハンドリングでは、以下のポイントを意識することが重要です：

  • カスタムエラーの活用：エラーを細かく分類し、エラー内容に応じた適切な処理を行う。
  • 階層的なエラーハンドリング：非同期処理の流れに応じた階層的なエラーハンドリングを実装し、処理の粒度ごとにエラーを管理する。
  • 再試行戦略の導入：一時的なエラーに対しては再試行を行い、システムの信頼性を高める。

これらの技術を組み合わせることで、より柔軟で堅牢な非同期エラーハンドリングが可能になります。

エラーログの自動通知システム


エラーが発生した際、エラーログを記録するだけでなく、リアルタイムで開発者や運用担当者に通知することができれば、迅速な問題解決が可能になります。エラー通知システムを構築することで、重大なエラーが発生したときにアラートを発し、即座に対応できる環境を整えることができます。ここでは、メールやチャットアプリを使った自動通知システムの実装方法を紹介します。

メールによるエラーログ通知


SMTPを使用してエラーログをメールで通知する方法が一般的です。Node.js環境では、nodemailerというパッケージを利用して、メールを送信できます。

以下のコードは、エラーが発生した際にメール通知を行う例です：

import nodemailer from 'nodemailer';

async function sendErrorNotification(error: Error) {
  const transporter = nodemailer.createTransport({
    service: 'Gmail',
    auth: {
      user: 'your-email@gmail.com',
      pass: 'your-email-password',
    },
  });

  const mailOptions = {
    from: 'your-email@gmail.com',
    to: 'developer-team@example.com',
    subject: 'Critical Error Occurred',
    text: `An error occurred:\n\nMessage: ${error.message}\nStack: ${error.stack}`,
  };

  try {
    await transporter.sendMail(mailOptions);
    console.log('Error notification sent via email');
  } catch (mailError) {
    console.error('Failed to send email notification:', mailError);
  }
}

async function logErrorAndNotify(error: Error) {
  console.error('Error occurred:', error.message);
  await logErrorToFile(error);  // ログをファイルに保存
  await sendErrorNotification(error);  // メールで通知
}

このコードでは、nodemailerを使ってエラー発生時に指定されたメールアドレスに通知を送信します。メールにはエラーメッセージとスタックトレースを含め、エラーの詳細をすぐに把握できるようにしています。特にクリティカルなエラーに対して即座に対応が必要な場合、メール通知は有効な手段です。

チャットアプリを使ったリアルタイム通知


SlackやMicrosoft Teamsなどのチャットアプリと連携することで、エラー発生時にリアルタイムで通知を受け取ることができます。Slackの場合、Webhookを設定して簡単にエラーログを送信できます。

以下は、SlackのWebhookを使ってエラーログをチャットで通知する例です：

import fetch from 'node-fetch';

async function sendSlackNotification(error: Error) {
  const webhookUrl = 'https://hooks.slack.com/services/YOUR/WEBHOOK/URL';
  const payload = {
    text: `*Error Occurred*\nMessage: ${error.message}\nStack: ${error.stack}`,
  };

  try {
    const response = await fetch(webhookUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload),
    });

    if (!response.ok) {
      throw new Error('Failed to send Slack notification');
    }

    console.log('Error notification sent to Slack');
  } catch (slackError) {
    console.error('Failed to send Slack notification:', slackError);
  }
}

async function logErrorAndNotifySlack(error: Error) {
  console.error('Error occurred:', error.message);
  await logErrorToFile(error);  // ログをファイルに保存
  await sendSlackNotification(error);  // Slackで通知
}

この例では、SlackのWebhookを使用してエラーの詳細をチャットに送信します。Slackでリアルタイム通知を受け取ることで、エラー発生時にすぐに対処できる体制を整えることができます。

通知システムのベストプラクティス


自動通知システムを構築する際には、以下の点を考慮することで、効果的なエラーログ通知が可能です：

  • 重要度に応じた通知：すべてのエラーを通知するのではなく、クリティカルなエラーや再試行が効かないエラーだけを通知対象にすることで、通知の精度を上げ、運用負荷を減らすことができます。
  • 適切なチャンネルの選定：通知をメール、チャット、もしくは専用のアラート管理システム（PagerDutyなど）に送信する際には、チームのワークフローに合わせたチャンネルを選定し、対応しやすい体制を整えます。
  • 通知の内容を充実させる：通知には、エラーメッセージやスタックトレースだけでなく、発生した状況（APIのレスポンス、リクエストパラメータなど）も含めることで、迅速な対応が可能になります。

自動通知とアラートの利点


自動通知システムを導入することで、以下の利点が得られます：

  • 迅速な対応：リアルタイムで通知を受け取ることで、重大なエラーが発生した際に迅速に対応でき、システムのダウンタイムを短縮できます。
  • 監視の効率化：エラーログの監視を手動で行う必要がなくなり、効率的にエラー管理が行えます。
  • チーム間での共有：エラーログがチーム全体に共有され、全員がエラー状況を把握できるため、担当者の不在時でも他のメンバーがすぐに対応できるようになります。

これらの機能を活用することで、非同期処理のエラーハンドリングがさらに強化され、システムの安定性を向上させることができます。

実践応用：エラーハンドリングのベストプラクティス


非同期処理におけるエラーハンドリングは、アプリケーションの安定性を維持するために欠かせない要素です。エラーを適切に処理し、ログに記録し、必要に応じて通知するためには、いくつかのベストプラクティスを導入することが重要です。このセクションでは、非同期処理に関するエラーハンドリングの効果的な手法を総括し、実践的な応用例を紹介します。

1. エラーをキャッチし、必ず処理する


非同期処理において、エラーが発生した場合に見逃さないためには、必ずtry/catchでエラーをキャッチし、適切に処理することが重要です。エラーをキャッチしなかった場合、予期しないクラッシュやパフォーマンスの低下につながる可能性があります。

async function performTask() {
  try {
    await someAsyncOperation();
  } catch (error) {
    console.error('Error during operation:', error);
    await logErrorToFile(error);  // エラーログを記録する
  }
}

このように、エラーをキャッチしてログに残すことで、後から問題を特定しやすくなります。

2. カスタムエラーを使用してエラーを区別する


標準のエラー処理では、エラーの発生箇所や原因を特定するのが難しい場合があります。そこで、カスタムエラーを定義し、エラーの種類を区別することで、特定のエラーに応じた処理を行うことができます。

class ValidationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'ValidationError';
  }
}

カスタムエラーを使うことで、エラーの原因をより明確にし、適切な処理を行うことが可能です。

3. エラーログの一元管理


エラーが発生した場合、分散したログよりも一元管理されたログの方が、問題の把握と解決が迅速に行えます。ログ収集ツール（例：LogglyやAmazon CloudWatch）を使うことで、リアルタイムにエラーログを監視し、チーム全体でエラーログにアクセスできる体制を整えることが可能です。

await logErrorToLoggly(error);  // Logglyにエラーを送信

このように、クラウドベースのログ管理ツールを活用すると、エラー発生時の対応が迅速になります。

4. リトライ戦略を実装する


特定のエラー（ネットワークの一時的な障害など）は、リトライによって解決できることが多いです。エラー発生時にリトライを行う戦略を導入することで、非同期処理の信頼性を高めることができます。

async function retryTask(task: () => Promise<any>, retries: number) {
  for (let i = 0; i < retries; i++) {
    try {
      return await task();
    } catch (error) {
      if (i === retries - 1) throw error;
    }
  }
}

リトライを行うことで、特定の障害に対して自動的に回復する仕組みを導入できます。

5. 非同期処理全体の監視と通知


エラーが発生した際に、リアルタイムで通知を受け取る仕組みを導入することで、早期に問題を発見し対応できます。Slackやメールなど、通知のチャネルを選定し、エラーログを適切に通知する体制を整えることが重要です。

await sendErrorNotification(error);  // メールやSlackで通知

通知機能を使って、チーム全体でエラーに対処できる環境を整えましょう。

6. プロダクション環境と開発環境でのエラーハンドリングの差異


開発環境とプロダクション環境では、エラーハンドリングの方法を変えることが重要です。開発環境では詳細なエラーメッセージを表示し、デバッグしやすくする一方、プロダクション環境ではユーザーに影響を与えない形でエラーを処理し、ログに記録します。

if (process.env.NODE_ENV === 'production') {
  logErrorToFile(error);
} else {
  console.error('Development error:', error);
}

環境に応じた適切なエラーハンドリングを行い、システム全体の信頼性を向上させます。

エラーハンドリングのまとめ


非同期処理におけるエラーハンドリングは、システムの安定性を支える重要な要素です。エラーをキャッチしてログに残し、カスタムエラーやリトライ戦略を活用することで、より信頼性の高いアプリケーションを構築することができます。また、エラー発生時には通知機能を使ってリアルタイムで対応できる体制を整え、プロダクション環境と開発環境で異なるアプローチを取ることで、システムの健全性を維持しましょう。

まとめ


本記事では、TypeScriptのasync/awaitを使った非同期処理におけるエラーハンドリングの基本から高度な手法までを解説しました。try/catchによるエラーのキャッチ、カスタムエラーの活用、ログ収集ツールとの連携、リトライ戦略、そしてエラー通知システムの導入など、実践的な方法を紹介しました。これらのベストプラクティスを導入することで、非同期処理におけるエラー管理を効率化し、システムの信頼性を大幅に向上させることができます。

TypeScript
エラーログ 非同期処理 TypeScript

コメント

コメントする

目次