BackgroundTask context not returning Memory when using aiohttp client

[rumbarum]

BackgroundTask with aiohttp keep memory more than using same code on router.

Here is example,

# without background task
import aiohttp
from starlette.applications import Starlette
from starlette.background import BackgroundTask
from starlette.responses import JSONResponse
from starlette.routing import Route


async def aiohttp_run():
    async with aiohttp.ClientSession(
        connector=aiohttp.TCPConnector(enable_cleanup_closed=True),
    ) as client:
        async with client.get("...") as resp:
            r = await resp.json()


async def hello_world(request):
    r = await aiohttp_run()
    message = {"message": "hello world"}
    return JSONResponse(message)


routes = [Route("/", endpoint=hello_world, methods=["GET"])]

app = Starlette(routes=routes)

# with backgroundtask
import aiohttp
from starlette.applications import Starlette
from starlette.background import BackgroundTask
from starlette.responses import JSONResponse
from starlette.routing import Route


async def aiohttp_run():
    async with aiohttp.ClientSession(
        connector=aiohttp.TCPConnector(enable_cleanup_closed=True),
    ) as client:
        async with client.get("...") as resp:
            r = await resp.json()


async def hello_world(request):
    task = BackgroundTask(aiohttp_run)
    message = {"message": "hello world"}
    return JSONResponse(message, background=task)


routes = [Route("/", endpoint=hello_world, methods=["GET"])]

app = Starlette(routes=routes)

Description

I run with this command using memray,

memray run --live .venv/bin/uvicorn report:app --host 0.0.0.0 --port 8000

and send request with locust,
concurrent 1 user, ramp 1

# locustfile.py
from locust import HttpUser, task

class HelloWorldUser(HttpUser):
    @task
    def hello_world(self):
        self.client.get("/")

starlette 0.41.3
macOs 14.5
python 3.11.9
aiohttp 3.11.7

[Kludex]

Can you send the Connection: close header from the client to see what happens?

[rumbarum]

Okay

[rumbarum]

@Kludex
Not working.

[rumbarum]

I think this image showing what consuming memory. But I don't know why it is different on Bg.

[rumbarum]

Maybe python problem, I will try it on 3.12.x!

[rumbarum]

@Kludex
The result on Python 3.12.7 is the same as on 3.11.9.
I suspect the BackgroundTask context handler might be involved, as the code in the Router works well.

[adriangb]

?Just curious could you try to see if this still happens with https://github.com/adriangb/asgi-background?

[rumbarum]

I will let you know result.

[rumbarum]

Result is as same as Starlette's BackgroundTask.

[luzzodev]

Hello @rumbarum, @Kludex i have done some researches and now i can give you more details about this situation.

Short Answer: there is not problem with BackgroundTask, aiohttp or anything related with that.

Long Answer with explanation:

1. According with your locust settings your are testing an endpoint with 1 user --> 1 connection x time ( keep in mind this for later)
2. When you use aiohttp_run inside the endpoint you are basically waiting for the response before responding to the client.
3. When you create and add aiohttp_run to a BackgroundTask, you are basically "schedulig" a task after the response and returning the response.

So where is the difference?
Referring to point 1 you are using just a single blocking call to the the endpoint you are testing and this makes a huge difference between point 2 and 3.
What is the difference? --> The number of scheduled task ( each task is a request )
If you refer to point 2 the number of active scheduled task is constant that is 2 + the current request = 3
If you refer to point 3 the number of active scheduled task is not constant but it grows indefinitely due to the difference from time needed to the endpoint to generate the response ( in your example is quite 0 ) and time needed to complete the BackgroundTask in this case is for sure bigger than the response one. So basically what is happening is that you are accumulating tasks.

To give you a more concrete example:

• time_bg_task = 1s
• time_endpoint_response = 0.1s

If you are testing point N1:
locust client makes a new request every 1.1s

If you are testing point N2:
locust client makes a new request every 0.1s
the first Background task will be completed at 1.1 s and and that time you will have already 10 scheduled task in queue.

You can make a small change to your locust file to reproduce the same scenario in point 1 using point 2.
Just sleep for an amount of time equal or bigger than the time required to complete one call of aiohttp_run between each locust client request.

Supposing aiohttp_run takes 1s

class HelloWorldUser(HttpUser):
    @task
    def hello_world(self):
        self.client.get("/")
        time.sleep(1.2)

Said that BackgroundTask should not be used on high rate endpoints as a base rule ( this is my opinion ).

[rumbarum]

@luzzodev
Thank you for your kind explanation. I really appreciate that!