How can I detect and verify a memory leak in Flask's request context caused by uncleaned g data?

To confirm whether storing large temporary objects in Flask’s g proxy creates a memory leak, you can measure memory usage over many requests and verify that the teardown_appcontext callback releases those objects. The following approach uses only standard Python tools and Flask’s built‑in signals.

1. Create a test route that puts a sizable object in g.

   from flask import Flask, g
   import json
   
   app = Flask(__name__)
   
   @app.before_request
   def load_big():
       # Simulate a large temporary payload (e.g., 1 MB list)
       g.big_data = list(range(250_000))  # ~2 MB of ints
   
   @app.route('/')
   def index():
       return 'OK'
   
   # Optional: explicit cleanup via teardown_appcontext
   @app.teardown_appcontext
   def cleanup_g(exc=None):
       g.big_data = None  # break reference
   

2. Run a loop of requests and capture memory snapshots. Use tracemalloc (or psutil) to take a snapshot before the loop, after each N requests, and after the loop.

   import tracemalloc
   from flask.testing import FlaskClient
   
   tracemalloc.start()
   client = FlaskClient(app)
   
   snapshot0 = tracemalloc.take_snapshot()
   for i in range(0, 5000, 100):
       for _ in range(100):
           client.get('/')
       snapshot = tracemalloc.take_snapshot()
       top_stats = snapshot.compare_to(snapshot0, 'lineno')
       print(f'After {i+100} requests:')
       for stat in top_stats[:5]:
           print(stat)
   

3. Assert that memory growth stabilizes. If the increase between snapshots plateaus (or returns to near‑zero after the teardown_appcontext cleanup), the leak is controlled. Without the cleanup, you will see a steady upward trend.

4. Verify that g is empty after teardown. Connect to the appcontext_tearing_down signal and inspect the proxy’s internal object.

   from flask import appcontext_tearing_down
   
   @appcontext_tearing_down
   def assert_g_empty(sender, **extra):
       # Get the real object behind the proxy
       real_g = g._get_current_object()
       assert not vars(real_g), f'g still holds {vars(real_g)} after teardown'
   

   If the assertion never fires, the context is properly cleared.

5. Rollback / fix. If the leak persists, ensure that any object stored in g is either:
   • removed in a teardown_appcontext handler (as shown), or
   • replaced with a lightweight placeholder, or
   • not stored in g at all for long‑lived data.
   Re‑run the memory test to confirm the trend disappears.