Node.js アプリケーションを本番環境で運用していると、メモリ使用量が徐々に増加し、最終的にアプリケーションがクラッシュしてしまう経験はありませんか。メモリ管理は Node.js 運用における最も重要な課題の一つです。本記事では、Node.js のメモリ構造を深く理解し、ヒープメモリと外部メモリの違いを把握した上で、本番環境でメモリリークを継続的に監視・検知する実践的な手法をご紹介します。初心者の方でも実装できるよう、具体的なコード例と図解を交えて解説していきますね。

背景

Node.js のメモリ構造

Node.js のメモリは大きく分けて「ヒープメモリ」と「外部メモリ」の 2 つに分類されます。この 2 つの違いを理解することが、効果的なメモリ管理の第一歩となるでしょう。

ヒープメモリは V8 JavaScript エンジンが管理するメモリ領域で、JavaScript オブジェクト、文字列、配列などが格納されます。一方、外部メモリは V8 のヒープ外で管理されるメモリで、Buffer オブジェクトや C++ アドオンが使用するネイティブメモリが該当します。

以下の図は、Node.js のメモリ構造全体を示しています。

mermaidCopy codeflowchart TB
  nodejs["Node.js プロセス"]
  heap["ヒープメモリ<br/>(V8 管理)"]
  external["外部メモリ<br/>(ヒープ外)"]

  nodejs --> heap
  nodejs --> external

  heap --> objects["JavaScript<br/>オブジェクト"]
  heap --> strings["文字列"]
  heap --> arrays["配列"]

  external --> buffers["Buffer"]
  external --> native["C++ アドオン<br/>メモリ"]

要点: ヒープメモリは JavaScript の世界、外部メモリはネイティブの世界と覚えておくと理解しやすいですね。

V8 のヒープサイズ制限

V8 エンジンには、デフォルトでヒープメモリのサイズ制限があります。64 ビットシステムでは約 1.4GB、32 ビットシステムでは約 700MB が上限となっています。

この制限を超えるとアプリケーションはクラッシュしてしまうため、本番環境では適切なメモリ監視が不可欠です。--max-old-space-size フラグを使用してヒープサイズを増やすこともできますが、根本的なメモリリークの解決にはなりません。

#	項目	64 ビット	32 ビット
1	デフォルトヒープサイズ	約 1.4GB	約 700MB
2	推奨最大サイズ	2GB 以下	1GB 以下
3	クラッシュリスク	制限超過時	制限超過時

メモリリークが発生する主な原因

メモリリークは、不要になったメモリが解放されずに残り続ける現象です。Node.js では以下のような原因でメモリリークが発生しやすくなります。

• グローバル変数の乱用: グローバルスコープに保存されたデータはガベージコレクションの対象にならない
• イベントリスナーの解除漏れ: EventEmitter にリスナーを追加したまま削除しない
• クロージャによる参照保持: 関数スコープ内の変数が予期せず保持される
• キャッシュの無制限拡大: Map や Object をキャッシュとして使い、削除処理を実装していない
• タイマーのクリア漏れ: setInterval や setTimeout をクリアせずに放置

これらの原因を理解し、適切に対処することで、メモリリークのリスクを大幅に減らせるでしょう。

課題

メモリリークの検知が難しい理由

本番環境でのメモリリークは、開発環境では再現しにくいという特徴があります。本番環境では長時間の稼働、大量のリクエスト、複雑なデータフローなど、開発時には想定しきれない条件が重なるためです。

また、メモリの増加が緩やかな場合、数日から数週間かけてゆっくりと増加していくため、気づいたときには手遅れになっているケースも少なくありません。

以下の図は、メモリリークが発生した際の典型的なメモリ使用量の推移を示しています。

mermaidCopy codeflowchart LR
  start["アプリ起動"] -->|時間経過| slow["緩やかな<br/>メモリ増加"]
  slow -->|数日〜数週間| limit["ヒープ制限<br/>に到達"]
  limit -->|メモリ不足| crash["アプリ<br/>クラッシュ"]

補足: このような緩やかな増加を早期に検知するには、継続的な監視が欠かせません。

外部メモリの可視化が困難

外部メモリは V8 のヒープ外で管理されるため、通常のヒープスナップショットでは捕捉できません。process.memoryUsage() を使用すれば外部メモリの使用量を取得できますが、どこで外部メモリが使われているかを特定するのは容易ではありません。

特に、以下のような状況では外部メモリの監視が重要になります。

#	状況	リスク	対策
1	Buffer の大量生成	外部メモリ枯渇	Buffer プールの利用
2	ファイル I/O の頻発	メモリ断片化	Stream API の活用
3	C++ アドオン使用	メモリリーク	ネイティブメモリ監視

リアルタイムでの継続監視の必要性

メモリリークは一度発生すると、アプリケーションの再起動なしには解決できません。そのため、リーク発生前に検知し、アラートを発することが理想的です。

しかし、多くのチームではメモリ監視を後回しにしがちで、クラッシュが発生してから初めて対応に追われるケースが多いのではないでしょうか。継続的な監視体制を構築することで、問題を未然に防ぐことができますね。

解決策

process.memoryUsage() による基本的な監視

Node.js には process.memoryUsage() という組み込み API があり、これを使用することで現在のメモリ使用状況を取得できます。

この API は以下の情報を返します。

typescriptCopy codeinterface MemoryUsage {
  rss: number; // 常駐セットサイズ（プロセス全体のメモリ）
  heapTotal: number; // V8 が確保したヒープの総量
  heapUsed: number; // 実際に使用されているヒープメモリ
  external: number; // V8 管理外の C++ オブジェクトのメモリ
  arrayBuffers: number; // ArrayBuffer と SharedArrayBuffer のメモリ
}

コードの意図: TypeScript の型定義で、各メモリ指標の意味を明確にしています。

それでは、基本的な監視コードを実装してみましょう。

typescriptCopy code// メモリ使用状況を取得して表示する関数
function logMemoryUsage(): void {
  const usage = process.memoryUsage();

  console.log({
    timestamp: new Date().toISOString(),
    // メガバイト単位に変換して表示
    rss: `${Math.round(usage.rss / 1024 / 1024)} MB`,
    heapTotal: `${Math.round(
      usage.heapTotal / 1024 / 1024
    )} MB`,
    heapUsed: `${Math.round(
      usage.heapUsed / 1024 / 1024
    )} MB`,
    external: `${Math.round(
      usage.external / 1024 / 1024
    )} MB`,
    arrayBuffers: `${Math.round(
      usage.arrayBuffers / 1024 / 1024
    )} MB`,
  });
}

解説: バイト単位の値をメガバイトに変換し、見やすく整形しています。

この関数を定期的に実行することで、メモリ使用状況を継続的に監視できます。

typescriptCopy code// 10秒ごとにメモリ使用状況をログ出力
const MONITORING_INTERVAL = 10 * 1000; // 10秒

setInterval(() => {
  logMemoryUsage();
}, MONITORING_INTERVAL);

補足: 本番環境では、この間隔を調整して監視頻度を最適化するとよいでしょう。

ヒープと外部メモリの分離監視

ヒープメモリと外部メモリは異なる特性を持つため、別々に監視することが重要です。

以下のコードは、ヒープメモリと外部メモリの使用率を計算し、それぞれに対して閾値ベースのアラートを実装しています。

typescriptCopy code// メモリ監視の設定
interface MemoryMonitorConfig {
  heapThreshold: number; // ヒープメモリの閾値（%）
  externalThreshold: number; // 外部メモリの閾値（MB）
  checkInterval: number; // チェック間隔（ミリ秒）
}

const config: MemoryMonitorConfig = {
  heapThreshold: 80, // ヒープ使用率 80% でアラート
  externalThreshold: 200, // 外部メモリ 200MB でアラート
  checkInterval: 30000, // 30秒ごとにチェック
};

コードの意図: 監視設定を一元管理し、閾値を柔軟に調整できるようにしています。

次に、閾値を超えた場合にアラートを発する監視ロジックを実装します。

typescriptCopy code// メモリ監視とアラート機能
function monitorMemory(config: MemoryMonitorConfig): void {
  const usage = process.memoryUsage();

  // ヒープ使用率を計算（%）
  const heapUsagePercent =
    (usage.heapUsed / usage.heapTotal) * 100;

  // 外部メモリをMB単位で計算
  const externalMB = usage.external / 1024 / 1024;

  // ヒープメモリの閾値チェック
  if (heapUsagePercent > config.heapThreshold) {
    console.error(
      `[ALERT] ヒープメモリ使用率が高い: ${heapUsagePercent.toFixed(
        2
      )}%`
    );
    // ここでアラート通知を送信（Slack, Email など）
  }

  // 外部メモリの閾値チェック
  if (externalMB > config.externalThreshold) {
    console.error(
      `[ALERT] 外部メモリ使用量が高い: ${externalMB.toFixed(
        2
      )} MB`
    );
    // ここでアラート通知を送信
  }
}

解説: ヒープは使用率（%）、外部メモリは絶対値（MB）で監視することで、それぞれの特性に合わせた検知が可能です。

メモリリーク検知のための差分監視

メモリリークを早期に検知するには、単純な閾値監視だけでなく、時系列での変化を追跡することが効果的です。

以下は、過去の値と現在の値を比較し、増加傾向を検知するコードです。

typescriptCopy code// メモリ履歴を保持するクラス
class MemoryTracker {
  private history: number[] = [];
  private readonly maxHistorySize: number = 10;

  constructor(maxHistorySize: number = 10) {
    this.maxHistorySize = maxHistorySize;
  }

  // 新しいメモリ値を追加
  addSample(heapUsed: number): void {
    this.history.push(heapUsed);

    // 履歴サイズを制限
    if (this.history.length > this.maxHistorySize) {
      this.history.shift();
    }
  }

  // メモリが増加傾向にあるかチェック
  isIncreasing(): boolean {
    if (this.history.length < 3) {
      return false; // データ不足
    }

    // 直近3つの値が連続して増加しているかチェック
    for (
      let i = this.history.length - 3;
      i < this.history.length - 1;
      i++
    ) {
      if (this.history[i] >= this.history[i + 1]) {
        return false;
      }
    }

    return true;
  }

  // 平均増加率を計算（%）
  getGrowthRate(): number {
    if (this.history.length < 2) {
      return 0;
    }

    const oldest = this.history[0];
    const newest = this.history[this.history.length - 1];

    return ((newest - oldest) / oldest) * 100;
  }
}

コードの意図: メモリ値の履歴を保持し、増加傾向と成長率を計算する専用クラスです。

このクラスを使用した監視ループを実装しましょう。

typescriptCopy code// メモリトラッカーのインスタンス作成
const heapTracker = new MemoryTracker(10);
const externalTracker = new MemoryTracker(10);

// 定期的にメモリをチェック
setInterval(() => {
  const usage = process.memoryUsage();

  // サンプルを追加
  heapTracker.addSample(usage.heapUsed);
  externalTracker.addSample(usage.external);

  // ヒープメモリの増加傾向をチェック
  if (heapTracker.isIncreasing()) {
    const growthRate = heapTracker.getGrowthRate();
    console.warn(
      `[WARNING] ヒープメモリが継続的に増加中: +${growthRate.toFixed(
        2
      )}%`
    );
  }

  // 外部メモリの増加傾向をチェック
  if (externalTracker.isIncreasing()) {
    const growthRate = externalTracker.getGrowthRate();
    console.warn(
      `[WARNING] 外部メモリが継続的に増加中: +${growthRate.toFixed(
        2
      )}%`
    );
  }
}, 60000); // 1分ごと

解説: 直近の複数サンプルを比較することで、一時的なスパイクと継続的なリークを区別できます。

以下の図は、メモリリーク検知のフローを示しています。

mermaidCopy codeflowchart TD
  sample["メモリ<br/>サンプル取得"]
  store["履歴に<br/>保存"]
  check["増加傾向<br/>チェック"]
  alert["アラート<br/>発報"]
  normal["正常"]

  sample --> store
  store --> check
  check -->|連続増加| alert
  check -->|正常範囲| normal

図で理解できる要点:

• サンプル取得から判定までの一連の流れが把握できます
• 増加傾向の検知がメモリリーク早期発見の鍵となります

ヒープスナップショットの活用

より詳細なメモリ分析が必要な場合は、V8 のヒープスナップショット機能を活用します。ヒープスナップショットは、特定時点でのヒープメモリの完全なスナップショットを取得する機能です。

typescriptCopy codeimport { writeHeapSnapshot } from 'v8';
import { join } from 'path';

// ヒープスナップショットを保存する関数
function captureHeapSnapshot(): string {
  const timestamp = new Date()
    .toISOString()
    .replace(/[:.]/g, '-');
  const filename = `heap-${timestamp}.heapsnapshot`;
  const filepath = join(__dirname, 'snapshots', filename);

  // スナップショットを保存
  writeHeapSnapshot(filepath);

  console.log(`ヒープスナップショットを保存: ${filepath}`);
  return filepath;
}

解説: タイムスタンプ付きのファイル名でスナップショットを保存し、後で比較分析できるようにしています。

メモリ使用量が閾値を超えた場合に自動的にスナップショットを取得する実装例です。

typescriptCopy code// 閾値超過時に自動でスナップショット取得
function monitorWithSnapshot(
  config: MemoryMonitorConfig
): void {
  const usage = process.memoryUsage();
  const heapUsagePercent =
    (usage.heapUsed / usage.heapTotal) * 100;

  if (heapUsagePercent > config.heapThreshold) {
    console.error(
      `[ALERT] ヒープメモリ使用率: ${heapUsagePercent.toFixed(
        2
      )}%`
    );

    // スナップショットを自動取得
    captureHeapSnapshot();
  }
}

補足: スナップショットファイルは Chrome DevTools で開いて分析できます。

具体例

Express サーバーでの実装例

実際の Web アプリケーションでメモリ監視を実装する例として、Express サーバーでの完全な実装を見ていきましょう。

まず、必要なパッケージをインストールします。

bashCopy codeyarn add express
yarn add -D @types/express @types/node typescript

コマンドの説明: Express と TypeScript の型定義をインストールしています。

次に、メモリ監視機能を持つ Express サーバーを実装します。

typescriptCopy codeimport express, { Request, Response } from 'express';

// Express アプリケーションの初期化
const app = express();
const PORT = 3000;

// JSON パースのミドルウェア
app.use(express.json());

コードの意図: 基本的な Express サーバーのセットアップです。

メモリ監視のミドルウェアを作成しましょう。

typescriptCopy code// メモリ監視ミドルウェア
app.use((req: Request, res: Response, next) => {
  const usage = process.memoryUsage();

  // レスポンスヘッダーにメモリ情報を追加
  res.setHeader(
    'X-Memory-Heap-Used',
    `${Math.round(usage.heapUsed / 1024 / 1024)}MB`
  );
  res.setHeader(
    'X-Memory-External',
    `${Math.round(usage.external / 1024 / 1024)}MB`
  );

  next();
});

解説: 各リクエストのレスポンスヘッダーにメモリ情報を含めることで、リクエストごとのメモリ変化を追跡できます。

メモリ情報を返す API エンドポイントを作成します。

typescriptCopy code// メモリ情報を取得する API エンドポイント
app.get('/api/memory', (req: Request, res: Response) => {
  const usage = process.memoryUsage();

  // メガバイト単位に変換
  const memoryInfo = {
    timestamp: new Date().toISOString(),
    rss: Math.round(usage.rss / 1024 / 1024),
    heapTotal: Math.round(usage.heapTotal / 1024 / 1024),
    heapUsed: Math.round(usage.heapUsed / 1024 / 1024),
    external: Math.round(usage.external / 1024 / 1024),
    arrayBuffers: Math.round(
      usage.arrayBuffers / 1024 / 1024
    ),
    unit: 'MB',
  };

  res.json(memoryInfo);
});

コードの意図: 現在のメモリ使用状況を JSON 形式で返す REST API です。

ヒープスナップショットを取得する API も追加しましょう。

typescriptCopy codeimport { writeHeapSnapshot } from 'v8';

// ヒープスナップショットを取得する API
app.post(
  '/api/memory/snapshot',
  (req: Request, res: Response) => {
    try {
      const filepath = writeHeapSnapshot();

      res.json({
        success: true,
        message: 'ヒープスナップショットを取得しました',
        filepath: filepath,
      });
    } catch (error) {
      console.error('スナップショット取得エラー:', error);

      res.status(500).json({
        success: false,
        message: 'スナップショット取得に失敗しました',
        error:
          error instanceof Error
            ? error.message
            : 'Unknown error',
      });
    }
  }
);

解説: POST リクエストでスナップショットを手動取得できるようにしています。エラーハンドリングも実装済みです。

サーバーの起動処理と継続的な監視を実装します。

typescriptCopy code// サーバー起動
app.listen(PORT, () => {
  console.log(
    `サーバーが起動しました: http://localhost:${PORT}`
  );
  console.log(
    `メモリ API: http://localhost:${PORT}/api/memory`
  );

  // 継続的なメモリ監視を開始
  startMemoryMonitoring();
});

// メモリ監視の開始
function startMemoryMonitoring(): void {
  const heapTracker = new MemoryTracker(10);

  setInterval(() => {
    const usage = process.memoryUsage();
    heapTracker.addSample(usage.heapUsed);

    // ヒープ使用率をチェック
    const heapUsagePercent =
      (usage.heapUsed / usage.heapTotal) * 100;

    if (heapUsagePercent > 80) {
      console.error(
        `[ALERT] ヒープメモリ使用率: ${heapUsagePercent.toFixed(
          2
        )}%`
      );
    }

    // 継続的な増加をチェック
    if (heapTracker.isIncreasing()) {
      const growthRate = heapTracker.getGrowthRate();
      console.warn(
        `[WARNING] メモリリークの可能性: +${growthRate.toFixed(
          2
        )}%`
      );
    }
  }, 30000); // 30秒ごと
}

補足: サーバー起動時に監視を開始し、定期的にメモリ状態をチェックします。

Prometheus との連携

本番環境での監視には、Prometheus のようなモニタリングツールとの連携が効果的です。prom-client ライブラリを使用して、メモリメトリクスを Prometheus 形式で公開する実装を見ていきましょう。

まず、必要なパッケージをインストールします。

bashCopy codeyarn add prom-client

コマンドの説明: Prometheus クライアントライブラリをインストールしています。

Prometheus メトリクスを設定します。

typescriptCopy codeimport client from 'prom-client';

// デフォルトメトリクスを有効化（CPU、メモリなど）
client.collectDefaultMetrics({ timeout: 5000 });

// カスタムメトリクスの定義
const heapUsedGauge = new client.Gauge({
  name: 'nodejs_heap_used_bytes',
  help: 'Node.js ヒープメモリ使用量（バイト）',
});

const externalMemoryGauge = new client.Gauge({
  name: 'nodejs_external_memory_bytes',
  help: 'Node.js 外部メモリ使用量（バイト）',
});

const heapUsagePercentGauge = new client.Gauge({
  name: 'nodejs_heap_usage_percent',
  help: 'Node.js ヒープメモリ使用率（%）',
});

コードの意図: Prometheus のゲージメトリクスを定義し、メモリ情報を記録できるようにしています。

定期的にメトリクスを更新する処理を実装します。

typescriptCopy code// メトリクスを定期的に更新
setInterval(() => {
  const usage = process.memoryUsage();

  // ヒープメモリのメトリクスを更新
  heapUsedGauge.set(usage.heapUsed);

  // 外部メモリのメトリクスを更新
  externalMemoryGauge.set(usage.external);

  // ヒープ使用率を計算して更新
  const heapUsagePercent =
    (usage.heapUsed / usage.heapTotal) * 100;
  heapUsagePercentGauge.set(heapUsagePercent);
}, 10000); // 10秒ごと

解説: 定期的にメモリ使用状況を取得し、Prometheus メトリクスとして記録しています。

Prometheus がスクレイピングするエンドポイントを公開します。

typescriptCopy code// Prometheus メトリクスのエンドポイント
app.get('/metrics', async (req: Request, res: Response) => {
  try {
    res.set('Content-Type', client.register.contentType);
    const metrics = await client.register.metrics();
    res.end(metrics);
  } catch (error) {
    res.status(500).end(error);
  }
});

補足: ​/​metrics エンドポイントから Prometheus 形式のメトリクスを取得できます。

以下の図は、Node.js アプリケーションと Prometheus の連携フローを示しています。

mermaidCopy codeflowchart LR
  nodejs["Node.js<br/>アプリケーション"]
  metrics["メトリクス<br/>収集"]
  endpoint["/metrics<br/>エンドポイント"]
  prometheus["Prometheus<br/>サーバー"]
  grafana["Grafana<br/>ダッシュボード"]

  nodejs -->|10秒ごと| metrics
  metrics --> endpoint
  prometheus -->|スクレイピング| endpoint
  prometheus -->|データ提供| grafana

図で理解できる要点:

• メトリクス収集からダッシュボード表示までの全体フローが把握できます
• Prometheus がデータを定期的に取得する仕組みが理解できます

Docker コンテナでの監視

Docker コンテナ内で動作する Node.js アプリケーションのメモリ監視も重要です。コンテナにはメモリ制限があるため、ホスト OS とは異なる監視が必要になります。

以下は、Docker のメモリ制限を考慮した監視実装です。

typescriptCopy codeimport { readFile } from 'fs/promises';

// Docker コンテナのメモリ制限を取得
async function getContainerMemoryLimit(): Promise<
  number | null
> {
  try {
    // cgroup v1 の場合
    const cgroupPath =
      '/sys/fs/cgroup/memory/memory.limit_in_bytes';
    const content = await readFile(cgroupPath, 'utf-8');
    const limit = parseInt(content.trim(), 10);

    // 制限なしの場合は非常に大きな値が返される
    if (limit > 9007199254740991) {
      return null;
    }

    return limit;
  } catch (error) {
    // Docker コンテナ外、または cgroup v2 の場合
    return null;
  }
}

コードの意図: Docker コンテナのメモリ制限を cgroup ファイルから読み取っています。

コンテナメモリ制限に基づいた監視ロジックを実装します。

typescriptCopy code// コンテナメモリ制限を考慮した監視
async function monitorContainerMemory(): Promise<void> {
  const containerLimit = await getContainerMemoryLimit();
  const usage = process.memoryUsage();

  if (containerLimit) {
    // コンテナメモリ制限が設定されている場合
    const containerUsagePercent =
      (usage.rss / containerLimit) * 100;

    console.log({
      containerLimit: `${Math.round(
        containerLimit / 1024 / 1024
      )} MB`,
      rss: `${Math.round(usage.rss / 1024 / 1024)} MB`,
      containerUsagePercent: `${containerUsagePercent.toFixed(
        2
      )}%`,
    });

    // コンテナメモリ使用率が 80% を超えたらアラート
    if (containerUsagePercent > 80) {
      console.error(
        `[ALERT] コンテナメモリ使用率が高い: ${containerUsagePercent.toFixed(
          2
        )}%`
      );
    }
  } else {
    // コンテナ外での実行、または制限なし
    console.log('コンテナメモリ制限が検出されませんでした');
  }
}

解説: RSS（常駐セットサイズ）をコンテナの制限値と比較し、使用率を監視しています。

メモリリークを意図的に発生させる検証コード

メモリ監視が正しく機能するか検証するため、意図的にメモリリークを発生させるコードを実装してみましょう。

typescriptCopy code// メモリリークの検証用コード（本番環境では使用しないこと）
class MemoryLeakSimulator {
  private leakyArray: any[] = [];

  // グローバル変数への参照蓄積
  simulateGlobalLeak(): void {
    setInterval(() => {
      // 大きなオブジェクトを配列に追加し続ける
      this.leakyArray.push(new Array(10000).fill('leak'));

      console.log(`配列サイズ: ${this.leakyArray.length}`);
    }, 1000);
  }

  // イベントリスナーの解除漏れ
  simulateEventListenerLeak(): void {
    const EventEmitter = require('events');
    const emitter = new EventEmitter();

    setInterval(() => {
      // リスナーを追加し続ける（削除しない）
      emitter.on('leak', () => {
        console.log('Leaky listener');
      });
    }, 100);
  }
}

注意: このコードは検証専用です。本番環境では絶対に使用しないでください。

検証用エンドポイントを作成します。

typescriptCopy code// メモリリーク検証用エンドポイント（開発環境のみ）
if (process.env.NODE_ENV === 'development') {
  const simulator = new MemoryLeakSimulator();

  app.post(
    '/api/test/memory-leak/start',
    (req: Request, res: Response) => {
      simulator.simulateGlobalLeak();

      res.json({
        message:
          'メモリリークシミュレーションを開始しました',
        warning:
          '検証用のため、アプリケーションは数分でクラッシュする可能性があります',
      });
    }
  );
}

解説: 開発環境でのみメモリリーク検証ができるようにしています。

以下の表は、各種メモリリークパターンと検知方法をまとめたものです。

#	リークパターン	原因	検知方法	対策
1	グローバル変数蓄積	配列への追加のみ	ヒープ増加監視	WeakMap の利用
2	イベントリスナー	removeListener 未実装	ヒープスナップショット比較	once() の利用
3	クロージャ参照	スコープチェーン保持	差分監視	変数の明示的な null 化
4	タイマー未クリア	clearInterval 漏れ	プロセス監視	try-finally でのクリア
5	Buffer 蓄積	Stream の適切な終了処理漏れ	外部メモリ監視	Stream の destroy 呼び出し

まとめ

Node.js 本番環境でのメモリ運用は、ヒープメモリと外部メモリの両方を適切に監視することが重要です。process.memoryUsage() を活用した基本的な監視から、差分監視による継続的なリーク検知、Prometheus との連携による本格的なモニタリングまで、段階的に監視体制を強化していくことをお勧めします。

メモリリークは発生してからの対処では遅く、継続的な監視によって早期に検知することが不可欠です。本記事で紹介した手法を組み合わせることで、安定した Node.js アプリケーションの運用が実現できるでしょう。

特に以下のポイントを押さえておくとよいですね。

• ヒープメモリは使用率（%）で監視し、80% を超えたらアラートを発する
• 外部メモリは絶対値（MB）で監視し、Buffer の大量生成に注意する
• 差分監視により継続的な増加傾向を検知し、メモリリークを早期発見する
• ヒープスナップショットを活用して、詳細な原因分析を行う
• Prometheus や Grafana と連携して、視覚的なダッシュボードで監視する

これらの実践により、本番環境での突然のクラッシュを防ぎ、安定したサービス提供が可能になります。メモリ監視は一度構築すれば継続的に動作するため、早い段階での導入が効果的です。ぜひ本記事の内容を参考に、堅牢なメモリ監視体制を構築してください。

関連リンク

• Node.js 公式ドキュメント - process.memoryUsage()
• V8 ヒープスナップショット
• Prometheus Node.js クライアント
• Chrome DevTools - メモリプロファイリング
• Docker メモリ制限の設定