Pythonのメモリデバッグツール: tracemalloc 詳細解説

Pythonは自動メモリ管理機能（ガベージコレクション）を備えていますが、それでもメモリリークや非効率なメモリ使用といった問題が発生することがあります。特に長時間動作するサーバーアプリケーションや、大量のデータを処理するバッチプログラムでは、メモリの問題がパフォーマンスのボトルネックになったり、最悪の場合はプロセスがクラッシュする原因になったりします。

このようなメモリの問題を特定し、解決するためにPythonが標準で提供している強力なツールが tracemalloc モジュールです。このモジュールはPython 3.4で導入され、以降のバージョンで機能改善が続けられています。

このブログ記事では、tracemalloc の基本的な使い方から、メモリリークの特定、詳細なメモリ分析方法まで、具体的なコード例を交えながら詳しく解説していきます。

tracemalloc は、Pythonプログラムがメモリをどこで、どれだけ確保したかを追跡（トレース）するためのモジュールです。具体的には、以下の情報を提供してくれます。

• オブジェクトが割り当てられたコード上の場所（ファイル名と行番号）を示すトレースバック
• ファイル名や行番号ごとに集計されたメモリ割り当て統計（合計サイズ、ブロック数、平均サイズなど）
• メモリ使用量のスナップショット（特定の時点でのメモリ割り当て状況）を取得し、比較する機能

メモリプロファイリングが重要な理由はいくつかあります。

• メモリリークの検出と修正: プログラムが不要になったメモリを解放し損ねている箇所を特定し、修正することで、アプリケーションの安定性を向上させます。メモリリークは、参照が意図せず残り続ける循環参照や、解放されるべきリソース（ファイルハンドル、ネットワーク接続など）が閉じられていない場合に発生しやすいです。
• パフォーマンス最適化: メモリを過剰に消費している箇所を見つけ出し、よりメモリ効率の良いデータ構造やアルゴリズムに改善することで、プログラム全体のパフォーマンスを向上させることができます。
• リソース使用量の把握: アプリケーションがどの程度のメモリを必要とするかを正確に把握することは、適切なインフラストラクチャの選定や、リソース制限のある環境（コンテナなど）での運用において重要です。

tracemalloc を使うことで、これらの課題に対して具体的なデータに基づいたアプローチが可能になります。

tracemalloc を使い始めるのは非常に簡単です。基本的な流れは以下の通りです。

1. tracemalloc.start() を呼び出してメモリ割り当てのトレースを開始します。
2. メモリ使用量を調査したい処理を実行します。
3. tracemalloc.get_traced_memory() で現在のメモリ使用量とピーク時のメモリ使用量を取得します。
4. tracemalloc.stop() を呼び出してトレースを停止します。

簡単な例を見てみましょう。

import tracemalloc
import time

# メモリ割り当てのトレースを開始
tracemalloc.start()

# メモリを消費する可能性のある処理
my_list = [i for i in range(100000)]
my_dict = {str(i): i for i in range(10000)}

time.sleep(1) # 何らかの処理時間をシミュレート

# 現在のメモリ使用量とピーク時のメモリ使用量を取得
current, peak = tracemalloc.get_traced_memory()
print(f"現在のメモリ使用量: {current / 1024:.2f} KiB")
print(f"ピーク時のメモリ使用量: {peak / 1024:.2f} KiB")

# ピーク値をリセットして、特定の区間のピークを計測することも可能
tracemalloc.reset_peak()

another_list = ['x'] * 50000
current_after_reset, peak_after_reset = tracemalloc.get_traced_memory()
print(f"リセット後の現在のメモリ使用量: {current_after_reset / 1024:.2f} KiB")
print(f"リセット後のピーク時のメモリ使用量: {peak_after_reset / 1024:.2f} KiB")

# トレースを停止
tracemalloc.stop()

# 停止後に呼び出すとエラーになる
try:
    tracemalloc.get_traced_memory()
except RuntimeError as e:
    print(f"\nトレース停止後の呼び出しエラー: {e}")
        

start() 関数には引数 nframe を指定できます。これは、各メモリアロケーションに対して保存するスタックフレームの数を指定します。デフォルトは 1 で、割り当てが行われた直近のフレームのみを記録します。より詳細なトレースバックが必要な場合は、この値を増やします（例: tracemalloc.start(25)）。ただし、フレーム数を増やすと、メモリ使用量とCPUオーバーヘッドが増加します。

tracemalloc の最も強力な機能の一つが、メモリ割り当てのスナップショットを取得し、比較する機能です。これにより、特定の処理区間でどのようなメモリ割り当てが増加したか、つまり潜在的なメモリリークを特定するのに役立ちます。

基本的な手順は以下の通りです。

1. tracemalloc.start() でトレースを開始します。
2. 調査したい処理の前に tracemalloc.take_snapshot() を呼び出して、最初のスナップショットを取得します。
3. メモリリークが疑われる処理を実行します。
4. 処理の後に再度 tracemalloc.take_snapshot() を呼び出して、2番目のスナップショットを取得します。
5. 2番目のスナップショットの compare_to() メソッドを使って、最初のスナップショットとの差分を計算します。
6. 差分情報を分析して、メモリが増加している箇所を特定します。

メモリリークをシミュレートする簡単な例を見てみましょう。

import tracemalloc
import os

# グローバルリスト（メモリリークの原因）
leaky_list = []

def memory_leaking_function():
    """意図的にメモリリークを発生させる関数"""
    leaky_list.extend([os.urandom(1024) for _ in range(100)]) # 100KBずつ追加

tracemalloc.start(10) # トレースバック用にフレーム数を増やす

print("最初のスナップショットを取得...")
snapshot1 = tracemalloc.take_snapshot()

# メモリリークが疑われる処理を実行
for _ in range(5):
    memory_leaking_function()

print("2番目のスナップショットを取得...")
snapshot2 = tracemalloc.take_snapshot()

print("スナップショット間の差分を計算・表示...")
top_stats = snapshot2.compare_to(snapshot1, 'lineno')

print("\n[メモリ使用量が増加した上位10箇所]")
for stat in top_stats[:10]:
    print(stat)

print("\n[差分の詳細なトレースバック]")
for stat in top_stats[:3]: # 上位3つの詳細を表示
    print(f"--- {stat} ---")
    for line in stat.traceback.format():
        print(line)
    print("-" * 40)

tracemalloc.stop()
        

このコードを実行すると、compare_to() の結果として StatisticDiff オブジェクトのリストが得られます。これには、各コード行におけるメモリブロックの数とサイズの差分が含まれています。出力結果から、memory_leaking_function 内のリストへの要素追加（leaky_list.extend(...) の行）でメモリ使用量が大幅に増加していることが確認できるはずです。

compare_to() や statistics() メソッドの第一引数 (key_type) には、集計・ソートのキーを指定します。よく使われるキーは以下の通りです。

• 'lineno': ファイル名と行番号で集計。メモリを消費している具体的なコード行を特定しやすい。
• 'filename': ファイル名で集計。どのモジュールがメモリを多く使っているかを把握するのに役立つ。
• 'traceback': 完全なトレースバックで集計。同じコールスタックからの割り当てをグループ化できるが、出力が多くなりがち。

メモリリーク調査では、まず 'lineno' であたりをつけ、必要に応じて 'traceback' で詳細な呼び出し経路を確認するのが効果的です。

取得したスナップショットは、単に比較するだけでなく、より詳細な分析を行うことができます。Snapshot オブジェクトには statistics() メソッドがあり、これを使うとそのスナップショット時点でのメモリ割り当て統計を取得できます。

import tracemalloc
import numpy as np # 例としてNumPyを使用

tracemalloc.start(5) # 少し多めにフレームを保存

# 何らかの処理
data = np.random.rand(1000, 1000)
intermediate_list = [str(i) * 10 for i in range(5000)]
result = {"data": data, "info": intermediate_list[:100]}

snapshot = tracemalloc.take_snapshot()

# ファイル名と行番号で統計情報を取得し、上位5件を表示
print("[ファイル名と行番号別トップ5]")
top_lineno = snapshot.statistics('lineno')
for stat in top_lineno[:5]:
    print(stat)

# ファイル名で統計情報を取得し、上位5件を表示
print("\n[ファイル名別トップ5]")
top_filename = snapshot.statistics('filename')
for stat in top_filename[:5]:
    print(stat)

# トレースバックで統計情報を取得し、上位3件の詳細を表示
print("\n[トレースバック別トップ3 (詳細)]")
top_traceback = snapshot.statistics('traceback')
for stat in top_traceback[:3]:
    print(f"--- {stat} ---")
    for line in stat.traceback.format():
        print(line)
    print("-" * 40)


tracemalloc.stop()
        

statistics() メソッドは Statistic オブジェクトのリストを返します。各 Statistic オブジェクトは以下の属性を持っています。

• traceback: メモリ割り当て元のトレースバック (Traceback インスタンス)。
• size: そのトレースバックから割り当てられたメモリの合計サイズ（バイト単位）。
• count: そのトレースバックから割り当てられたメモリブロックの数。

フィルタリングによるノイズ除去

tracemalloc 自体の内部動作や、デバッグツール、特定のライブラリによるメモリ割り当てもトレース結果に含まれることがあります。これらはメモリリーク調査の際にはノイズとなる場合があるため、フィルタリングして除外したい場合があります。

スナップショットの filter_traces() メソッドと Filter クラス（またはPython 3.6以降では DomainFilter も）を使うことで、トレース情報をフィルタリングできます。

Filter クラスの主な引数は以下の通りです。

• inclusive: True なら指定したパターンに一致するものを含める（インクルーシブ）、False なら一致するものを除外する（エクスクルーシブ）。
• filename_pattern: ファイル名のパターン（fnmatch 形式のワイルドカード使用可能）。
• lineno: 特定の行番号（オプション）。
• all_frames: True ならトレースバック内の全フレームを対象に、False (デフォルト) なら最も新しいフレームのみを対象にフィルタリング。
• domain: (Python 3.6+) メモリアドレス空間ドメイン。通常はPython内部メモリを示す 0 を使用。

import tracemalloc
import os
import fnmatch # ワイルドカードマッチング用

tracemalloc.start(10)

# わざとtracemalloc自身に関する操作も入れてみる
current, peak = tracemalloc.get_traced_memory()
print(f"現在の tracemalloc 内部メモリ: {tracemalloc.get_tracemalloc_memory()} bytes")

# 何らかの処理
my_data = [os.urandom(512) for _ in range(200)]
import collections # collections モジュールも使ってみる
my_deque = collections.deque(range(1000))


snapshot = tracemalloc.take_snapshot()
print(f"\nフィルタ前のトレース数: {len(snapshot.traces)}")

# --- フィルタリングの例 ---

# 1. tracemalloc自身のコードを除外するフィルタ
filter1 = tracemalloc.Filter(inclusive=False, filename_pattern=tracemalloc.__file__)

# 2. 特定のディレクトリ配下のファイルのみを含めるフィルタ (例: site-packagesを除外)
# 注意: パス区切り文字は環境依存の可能性があるため os.sep を使うのが堅牢
import sys
site_packages_path = None
for p in sys.path:
    if 'site-packages' in p:
        site_packages_path = p
        break

filters = [filter1]
if site_packages_path:
    # site-packages 内のファイルを除外するフィルタを追加
    # fnmatch でディレクトリを扱う場合は末尾に * をつけることが多い
    filter_exclude_site_packages = tracemalloc.Filter(inclusive=False, filename_pattern=os.path.join(site_packages_path, "*"))
    filters.append(filter_exclude_site_packages)
    print(f"除外フィルタ (site-packages): {filter_exclude_site_packages.filename_pattern}")

# 3. 特定のファイルパターンのみ含める (例: 自分のプロジェクトコード 'my_project/' 配下など)
# ここでは例として現在のスクリプトファイルのみを含めるフィルタを作成
current_script_file = __file__
filter_only_this_script = tracemalloc.Filter(inclusive=True, filename_pattern=current_script_file)
# filters.append(filter_only_this_script) # 必要に応じて有効化

# フィルタを適用
filtered_snapshot = snapshot.filter_traces(filters)
print(f"フィルタ後のトレース数: {len(filtered_snapshot.traces)}")


# フィルタ後の統計情報を表示
print("\n[フィルタ後のメモリ使用量トップ5 (lineno)]")
top_stats_filtered = filtered_snapshot.statistics('lineno')
for stat in top_stats_filtered[:5]:
    print(stat)


tracemalloc.stop()
        

複数のフィルタをリストで渡すと、まず全ての inclusive=True のフィルタが適用され、いずれかにマッチしないトレースは除外されます。その後、inclusive=False のフィルタが適用され、いずれかにマッチしたトレースが除外されます。これにより、特定のライブラリを除外しつつ、自分のコードのみを対象にする、といった柔軟なフィルタリングが可能です。

大規模なアプリケーションでは、多くのライブラリが内部的にメモリを確保します。メモリリークの原因を特定する際には、まず自分のアプリケーションコードに焦点を当てるために、外部ライブラリを除外するフィルタが非常に役立ちます。

特定のオブジェクトがどこで割り当てられたのかをピンポイントで知りたい場合があります。tracemalloc.get_object_traceback(obj) 関数を使うと、指定したオブジェクト obj が割り当てられた際のトレースバックを取得できます。

これは、予期せずメモリ上に残り続けているオブジェクトを発見し、その生成元を突き止めるのに役立ちます。

import tracemalloc
import gc

class MyObject:
    def __init__(self, name):
        self.name = name
        self.data = list(range(100)) # いくらかメモリを消費

tracemalloc.start(5)

# オブジェクトを作成
obj1 = MyObject("Object One")
obj2 = MyObject("Object Two")

# obj1への参照をいくつか作成
ref1 = obj1
ref_list = [obj1, obj2]

# obj1 のトレースバックを取得してみる
tb1 = tracemalloc.get_object_traceback(obj1)
if tb1:
    print(f"--- Traceback for obj1 ({obj1.name}) ---")
    for line in tb1.format():
        print(line)
else:
    print("obj1 のトレースバックは見つかりませんでした (まだトレースされていないか、モジュールが非アクティブ)。")

# obj2 のトレースバックを取得
tb2 = tracemalloc.get_object_traceback(obj2)
if tb2:
    print(f"\n--- Traceback for obj2 ({obj2.name}) ---")
    for line in tb2.format():
        print(line)

# 不要になった参照を削除してみる
del obj1
del ref1
ref_list.pop(0)

# ガベージコレクションを強制実行（通常は不要だがデモのため）
gc.collect()

# 再度 obj1 のトレースバックを試みる（通常はNoneになるはず）
# 注意: CPythonの実装詳細により、すぐにメモリが再利用されるとは限らない
obj1_addr = id(ref_list[0]) # obj2のアドレス
print(f"\nobj2のアドレス: {obj1_addr}")

# 存在しないオブジェクトやトレースされていないオブジェクトを渡すとNoneが返る
tb_nonexistent = tracemalloc.get_object_traceback(12345) # intオブジェクト
print(f"\n存在しないオブジェクトのトレースバック: {tb_nonexistent}")

tracemalloc.stop()
        

get_object_traceback() は、tracemalloc がアクティブで、かつ対象オブジェクトの割り当てがトレースされている場合にのみ Traceback オブジェクトを返します。そうでない場合は None を返します。

この機能は、gc.get_referrers() （オブジェクトを参照している他のオブジェクトを取得）や objgraph のような外部ライブラリと組み合わせると、メモリリークの原因となっている参照関係と、そのオブジェクトが生成された場所の両方を特定するのに非常に強力です。

プログラムの非常に早い段階、あるいは起動直後からメモリアロケーションをトレースしたい場合があります。例えば、インポート時のメモリ使用量やグローバル変数の初期化などを調査したいケースです。

このような場合、Pythonのコード内で tracemalloc.start() を呼び出すよりも前にトレースを開始する必要があります。これを実現するのが環境変数 PYTHONTRACEMALLOC です。

この環境変数を設定してPythonプロセスを起動すると、tracemalloc モジュールが自動的にトレースを開始します。

• PYTHONTRACEMALLOC=1: デフォルトのフレーム数（1フレーム）でトレースを開始します。
• PYTHONTRACEMALLOC=N (N は1以上の整数): 指定したフレーム数 N でトレースを開始します。例えば PYTHONTRACEMALLOC=25 とすると、25フレームまで保存します。

また、Python 3.7以降ではコマンドラインオプション -X tracemalloc や -X tracemalloc=N も利用できます。

使い方（ターミナル）:

# 環境変数を設定してPythonスクリプトを実行 (例: 10フレームでトレース)
export PYTHONTRACEMALLOC=10
python your_script.py

# またはコマンドラインオプションで実行 (Python 3.7+)
python -X tracemalloc=10 your_script.py
        

スクリプト内では、tracemalloc.is_tracing() でトレースが有効になっているか確認できます。

# your_script.py
import tracemalloc
import time
import sys

if tracemalloc.is_tracing():
    print(f"tracemalloc は起動時から有効です。フレーム数: {tracemalloc.get_traceback_limit()}")
else:
    print("tracemalloc はまだ有効になっていません。start()を呼び出します。")
    tracemalloc.start()

# グローバル変数など、起動直後の割り当て例
startup_list = [i for i in range(1000)]

def main():
    print("\nメイン処理開始...")
    local_list = [str(x) for x in range(5000)]
    time.sleep(0.5)
    print("メイン処理終了...")

if __name__ == "__main__":
    main()

    if tracemalloc.is_tracing():
        snapshot = tracemalloc.take_snapshot()
        print("\n終了時のメモリ統計 (上位5件):")
        top_stats = snapshot.statistics('lineno')
        for stat in top_stats[:5]:
            print(stat)
        tracemalloc.stop()
    else:
        print("\nトレースが有効でないため、統計は取得できません。")

この方法を使うと、import 文によるモジュールのロードや、クラス定義、グローバルスコープでの変数初期化など、if __name__ == "__main__": ブロックよりも前に発生するメモリアロケーションも捕捉できます。これは、起動時のメモリフットプリントを分析する際に特に有用です。

tracemalloc は非常に強力なデバッグツールですが、有効にするとパフォーマンス（CPU時間とメモリ使用量）に影響を与えます。トレース中は、Pythonのメモリアロケータに関数がフックされ、アロケーションごとにトレースバック情報が記録・保存されるためです。

• CPUオーバーヘッド: メモリ割り当ての頻度が高いアプリケーションでは、tracemalloc を有効にすると実行速度が遅くなる可能性があります。公式ドキュメントには具体的な数値は明記されていませんが、アプリケーションによっては数%から数十%の速度低下が見られる場合があります。特に、保存するフレーム数（nframe）を増やすと、オーバーヘッドは増加します。
• メモリオーバーヘッド: tracemalloc 自体がトレース情報を保存するためにメモリを消費します。保存するフレーム数や、プログラム全体のメモリアロケーション数に比例して、このオーバーヘッドは増加します。tracemalloc.get_tracemalloc_memory() 関数を使うと、tracemalloc モジュール自身が使用しているメモリ量を確認できます。

import tracemalloc
import time

tracemalloc.start(25) # フレーム数を25に設定

# 大量の小さなオブジェクトを生成してみる
start_time = time.perf_counter()
for _ in range(100000):
    a = object()
end_time = time.perf_counter()

print(f"処理時間 (tracemalloc有効): {end_time - start_time:.4f} 秒")

# tracemallocが使用しているメモリ量を確認
mem_usage = tracemalloc.get_tracemalloc_memory()
print(f"tracemalloc のメモリ使用量: {mem_usage / 1024:.2f} KiB")

tracemalloc.stop()

# 比較のために tracemalloc 無効で同じ処理を実行
start_time_no_trace = time.perf_counter()
for _ in range(100000):
    a = object()
end_time_no_trace = time.perf_counter()

print(f"\n処理時間 (tracemalloc無効): {end_time_no_trace - start_time_no_trace:.4f} 秒")
        

このコードを実行すると、tracemalloc が有効な場合の方が処理時間が長くなることが確認できるでしょう（差は環境やPythonバージョンによります）。

注意点まとめ:

• tracemalloc はデバッグやプロファイリングのためのツールであり、本番環境で常に有効にしておくべきではありません。パフォーマンスへの影響が大きいためです。
• メモリリーク調査やメモリ使用量の最適化を行う開発・テスト環境でのみ使用することを推奨します。
• 保存するフレーム数 (nframe) は、必要な情報が得られる最小限の数に設定することで、オーバーヘッドを抑えることができます。多くの場合、デフォルトの1や、数フレーム程度で十分な場合が多いです。
• tracemalloc.get_tracemalloc_memory() でツール自体のメモリ消費量を監視し、過剰になっていないか確認しましょう。
• C拡張によって確保されたメモリは追跡できない点を理解しておく必要があります。

tracemalloc は様々なシナリオで役立ちます。

• Webアプリケーション (Flask, Djangoなど):
  • リクエスト処理中にメモリ使用量が異常に増加していないか調査。
  • 特定のエンドポイントやビュー関数がメモリリークの原因になっていないか特定。
  • リクエスト前後でスナップショットを比較し、リーク箇所を特定。
  • 長期間稼働させるWebサーバープロセス全体のメモリ増加傾向を分析。
• 長時間実行されるバッチ処理・データ処理:
  • 処理が進むにつれてメモリ使用量が増え続け、最終的にクラッシュする問題を調査。
  • ループ処理の各イテレーション前後でスナップショットを比較し、メモリが適切に解放されているか確認。
  • 大規模なデータセットを処理する際に、どのデータ構造や処理ステップがメモリを大量に消費しているか特定し、最適化（例: ジェネレータの使用、チャンク処理）。
• ライブラリやフレームワークの開発:
  • 開発中のライブラリが意図せずメモリリークを引き起こしていないかテスト。
  • 内部データ構造のメモリ効率を評価・改善。
• テストコードでの利用:
  • 特定のテストケース実行前後でメモリ使用量を比較し、テスト対象のコードがメモリリークを起こさないことを確認するアサーションを追加。

例えば、Flaskアプリケーションで特定のリクエストハンドラにおけるメモリ使用量を調査する場合、以下のようなデコレータを作成して適用することが考えられます（簡略化した例）。

from functools import wraps
import tracemalloc
from flask import Flask, request

app = Flask(__name__)

# 注意: 本番環境での使用は非推奨。デバッグ目的のみ。
# また、複数リクエストを同時に処理する場合、スナップショットが混ざる可能性があるため、
# 実際の利用ではより注意深い実装が必要です（例：リクエストごとに一意なIDで管理）。
def trace_request_memory(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if not tracemalloc.is_tracing():
            tracemalloc.start() # トレースが開始されていなければ開始

        snapshot1 = tracemalloc.take_snapshot()
        try:
            result = f(*args, **kwargs)
        finally:
            snapshot2 = tracemalloc.take_snapshot()
            top_stats = snapshot2.compare_to(snapshot1, 'lineno')
            print(f"\n--- Request to {request.path} Memory Diff ---")
            if top_stats:
                print("[Top 5 Memory Differences]")
                for stat in top_stats[:5]:
                    print(stat)
            else:
                print("No significant memory difference detected.")
            print("-" * 40)
        return result
    return decorated_function

@app.route('/process_large_data')
@trace_request_memory
def process_large_data():
    # わざとメモリを多く使う処理
    data_size = request.args.get('size', default=10000, type=int)
    large_list = ['item ' * 100] * data_size
    # ここで何らかの処理を行う
    processed_count = len(large_list)
    # large_list を解放せずに返す（リークのシミュレーション）
    # 本来は適切に解放すべき
    return f"Processed {processed_count} items."

@app.route('/')
def index():
    return "Hello! Try /process_large_data?size=50000"

if __name__ == '__main__':
    # 開発サーバーで実行。PYTHONTRACEMALLOCは設定しない想定。
    app.run(debug=True, use_reloader=False) # reloaderはデバッグに影響することがある

この例では、/process_large_data エンドポイントへのリクエスト前後でスナップショットを取得し、コンソールに差分を出力します。これにより、リクエスト処理によるメモリ増加を簡単に確認できます。ただし、上記コードは簡略化されており、スレッドセーフティなどの考慮はされていません。実際のアプリケーションに組み込む場合は注意が必要です。

tracemalloc は、Pythonアプリケーションにおけるメモリ関連の問題を診断するための非常に強力で便利な標準ライブラリです。

• 簡単な開始: start() / stop() で簡単にトレースを開始・停止できます。
• スナップショット比較: take_snapshot() と compare_to() でメモリリークの原因箇所を特定できます。
• 詳細な統計情報: statistics() で、どのファイルや行がメモリを多く消費しているか詳細に分析できます。
• フィルタリング: Filter クラスでノイズを除去し、調査対象を絞り込めます。
• オブジェクト追跡: get_object_traceback() で特定のオブジェクトがどこで生成されたか追跡できます。
• 起動時トレース: PYTHONTRACEMALLOC 環境変数でプログラム開始直後からトレースできます。

一方で、パフォーマンスへの影響があるため、本番環境での常時利用は避け、開発・テストフェーズでの利用に留めるべきです。

Pythonアプリケーションでメモリ使用量が気になる場合や、原因不明のメモリリークに悩まされている場合は、ぜひ tracemalloc を活用してみてください。きっと問題解決の大きな助けとなるはずです！ Happy Memory Debugging!