High increase of memory usage from 0.121.x (and onwards) #14742

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

import inspect

import fastapi

app = fastapi.FastAPI()
deps = {}

LIMIT = 100

def create_dependencies(index: int):
    """Factory to create a dependency that depends on the next one in the chain."""

    # The base case: the last dependency (100) doesn't depend on anything
    if index == LIMIT:
        def dependency_100() -> str:
            return "100"

        return dependency_100

    # Recursive-style case: depend on the index + 1
    next_dep_func = deps.get(index + 1)

    async def dependency_node(sub_dep: str = fastapi.Depends(next_dep_func)) -> str:
        return f"{index} -> {sub_dep}"

    # Rename the function for FastAPI's internal dependency resolution/debugging
    dependency_node.__name__ = f"get_dep{index}"
    return dependency_node


# Build the chain of dependencies from 100 down to 0
for i in range(LIMIT, -1, -1):
    deps[i] = create_dependencies(i)

def create_dynamic_endpoint_function(param_count: int):
    """
    Creates a function with 'param_count' arguments, each having a default value.
    FastAPI will inspect __signature__ to resolve dependencies.
    """
    parameters = []
    for i in range(param_count):
        # Logic to determine the default value (e.g., a specific dependency)
        # Here we use the existing 'deps' dictionary built above
        default_val = fastapi.Depends(deps.get(i, lambda: i))
        
        param = inspect.Parameter(
            name=f"arg_{i}",
            kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
            default=default_val,
            annotation=str
        )
        parameters.append(param)

    # Define the actual runtime logic of the function
    async def dynamic_wrapper(**kwargs):
        return {
            "message": "Called dynamic endpoint", 
            "param_count": len(kwargs),
            # "values": kwargs # Uncomment to see the resolved values
        }

    # Override the signature so FastAPI sees 'arg_0', 'arg_1', etc.
    dynamic_wrapper.__signature__ = inspect.Signature(parameters)
    
    return dynamic_wrapper

# Register two routes with 50 parameters dynamically
app.add_api_route(
    "/dynamic-health", 
    create_dynamic_endpoint_function(50), 
    methods=["GET"]
)

app.add_api_route(
    "/dynamic-health", 
    create_dynamic_endpoint_function(50), 
    methods=["POST"]
)

Description

We're currently using FastAPI 0.120.4 in production which uses less than 400MB of memory.

Using memray to profile the total memory usage, I got:

However, when we tried to upgrade to 0.121.3, we found that an out-of-memory (OOM) error was raised.

I did a profile of the total memory usage with 0.121.3 and I got:

When I dig deeper in the flamegraph, I found the following difference between the two versions.
With 0.120.4:

With 0.121.3:

As you can see from the flamegraph, 0.121.3 shows more memory consumption from get_flat_dependant function.

Also, running memray in live mode showed the following:

As we can see there, __get__ from functools is consuming a lot of memory.

So, I checked the PR scope was introduced for dependencies and I found the following change where functools.cached_property was introduced: https://github.com/fastapi/fastapi/pull/14262/files#diff-4d1d65ce33d5ef7383c87f7edeb3928bc0537016daba6d1a6b8b27a7af8f8aaaR46-R52

With all this information, I did two tests.

1. I tried changing the cache_key as a property

2. I tried reverting the initialization of cache_key to use __post__init__:

As you can see in both examples, total memory consumption was reduced to something very similar as version 0.120.4.

Lastly, I also tried running FastAPI with all versions from 0.120 to the latest 0.128 in Docker and I got the following resources usage metrics:

Also, this shows an increment of memory usage. I also noticed that in the latest versions more cached properties were introduced, so changing only cache_key is not enough and more cached properties need to be updated.

From the information I was able to gather, I can't really say if this is a memory leak or just more memory consumption.
Also, I wasn't able to reproduce this with a minimal example yet since I believe the issue is noticeable when many dependencies are used.

I'd appreciate any help of feedback about this issue.

Thanks

Operating System

Linux, macOS

Operating System Details

No response

FastAPI Version

0.121.3

Pydantic Version

2.12.5

Python Version

3.12.9

Additional Context

No response