Possible memory leak in aiohttp-client instrumentation

[larnaldo-dev]

Describe your environment

OS: Microsoft Windows 11 Enterprise, 10.0.26100 Build 26100
Python version: Python 3.13.13 (tags/v3.13.13:01104ce, Apr 7 2026, 19:25:48) [MSC v.1944 64 bit (AMD64)
Package version: opentelemetry-instrumentation-aiohttp-client 0.65b0

What happened?

Possible memory leak when instrumenting aiohttp client connections. Every new connection creates a meter at

opentelemetry-python-contrib/instrumentation/opentelemetry-instrumentation-aiohttp-client/src/opentelemetry/instrumentation/aiohttp_client/__init__.py

Line 395 in 466ae4c

meter = get_meter(

and it is never cleaned up.

Steps to Reproduce

This setup is based on the sample code from https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/aiohttp_client/aiohttp_client.html.

import asyncio
import aiohttp
from opentelemetry.instrumentation.aiohttp_client import (
    AioHttpClientInstrumentor
)
import tracemalloc

# Enable instrumentation
AioHttpClientInstrumentor().instrument()


# Create a session and make an HTTP get request
async def get(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url, ssl=False) as response:
            await response.text()

async def main():
    # Enable tracemalloc
    tracemalloc.start()
    before = tracemalloc.take_snapshot()

    for i in range(1000):
        print(f"Request {i+1}")
        await get("<URL>")
        await asyncio.sleep(5)  # Add a small delay

    after = tracemalloc.take_snapshot()
    stats = after.compare_to(before, 'lineno')
    for stat in stats[:10]:
        print(stat)
    tracemalloc.stop()


if __name__ == "__main__":
    asyncio.run(main())

Expected Result

The expected result is no memory leaks.

Actual Result

This is the snapshot diff

\venv\Lib\site-packages\opentelemetry\metrics\_internal\__init__.py:163: size=143 KiB (+143 KiB), count=1001 (+1001), average=146 B
\venv\Lib\site-packages\opentelemetry\metrics\_internal\__init__.py:581: size=112 KiB (+112 KiB), count=1000 (+1000), average=115 B
\venv\Lib\site-packages\opentelemetry\instrumentation\_semconv.py:697: size=78.1 KiB (+78.1 KiB), count=1000 (+1000), average=80 B
\venv\Lib\site-packages\opentelemetry\metrics\_internal\__init__.py:199: size=62.5 KiB (+62.5 KiB), count=1000 (+1000), average=64 B
\venv\Lib\site-packages\opentelemetry\metrics\_internal\__init__.py:498: size=54.7 KiB (+54.7 KiB), count=1000 (+1000), average=56 B
\venv\Lib\site-packages\opentelemetry\metrics\_internal\__init__.py:200: size=54.7 KiB (+54.7 KiB), count=1000 (+1000), average=56 B
\venv\Lib\site-packages\opentelemetry\metrics\_internal\__init__.py:499: size=54.5 KiB (+54.5 KiB), count=997 (+997), average=56 B
\venv\Lib\site-packages\opentelemetry\metrics\_internal\__init__.py:584: size=31.2 KiB (+31.2 KiB), count=1000 (+1000), average=32 B

Additional context

No response

Would you like to implement a fix?

No

Tip

_{React with 👍 to help prioritize this issue. Please use comments to provide useful context, avoiding +1 or me too, to help us triage it. Learn more here.}

[HarperZ9]

I can reproduce this with no network and no sleep, which isolates the growth to ClientSession.__init__ rather than per request:

import asyncio, gc, aiohttp
from opentelemetry.instrumentation.aiohttp_client import AioHttpClientInstrumentor
from opentelemetry.metrics._internal import _ProxyMeter
from opentelemetry.metrics._internal.instrument import _ProxyHistogram

AioHttpClientInstrumentor().instrument()

async def build(n):
    for _ in range(n):
        s = aiohttp.ClientSession()   # no request, no server
        await s.close()

def counts():
    gc.collect()
    return (sum(isinstance(o, _ProxyMeter) for o in gc.get_objects()),
            sum(isinstance(o, _ProxyHistogram) for o in gc.get_objects()))

async def main():
    print("baseline", counts())
    await build(500); print("after 500", counts())
    await build(500); print("after 1000", counts())

asyncio.run(main())

Output (aiohttp-client instrumentation 0.65b0, opentelemetry-api 1.44.0, aiohttp 3.14.3):

baseline (0, 0)
after 500 (500, 500)
after 1000 (1000, 1000)

One _ProxyMeter and one _ProxyHistogram accumulate per ClientSession constructed, with zero HTTP requests.

Root cause: instrumented_init wraps ClientSession.__init__ and calls create_trace_config(...) on every construction (__init__.py L664). create_trace_config calls get_meter(...) (L392) and meter.create_histogram(...) (L401/L409) each time. Under the default proxy meter provider these return proxy instruments that are retained for the process lifetime, so they pile up one per session.

Scope, since it matters for severity: this is specific to the default proxy provider. With a real SDK MeterProvider configured, get_meter is cached by scope, so the meter count stays at 1 and I did not see growth or any duplicate-instrument warnings over 1000 constructions. That matches the original report, whose tracemalloc frames are all in opentelemetry/metrics/_internal/__init__.py (the proxy layer), i.e. no SDK meter provider was active.

Fix direction: hoist the meter and histogram creation out of the per-__init__ path. Build them once at instrumentation/config setup and reuse across sessions, so instrumented_init does not create new instruments on every construction. That removes the proxy accumulation and avoids the redundant per-session work in the SDK case too.

(_ProxyMeter / _ProxyHistogram are private, used only for the diagnostic count.) Happy to open a PR with the hoist plus a regression test asserting a bounded instrument count across many constructions.