Enhancement request: option to run LifespanCycle on Mangum __init__ rather than on each __call__

[jrobbins-LiveData]

While in some sense "Lambda is stateless", in practice AWS recommends

Initialize SDK clients and database connections outside of the function handler, and cache static assets locally in the /tmp directory. Subsequent invocations processed by the same instance of your function can reuse these resources. This saves cost by reducing function run time.

If I instance Mangum outside of my function handler, it would be great to have the option for my lifespan asynccontextmanager to run once, e.g. at the onset of the first handler call, rather than on every call. This would support use-cases like caching a database connection per AWS recommendation without resorting to workarounds.

This option would allow treating the model of lifespan to cover the actual lifespan of the Lambda function instance, and so, at least to me, seems like a "natural" mapping of the concept of "lifespan".

[aryaniyaps]

Are there any updates on this?

[aryaniyaps]

Here's how Im overcoming this limitation currently:
(intializing beanie is a costly operation that takes around 1-1.2s)

@asynccontextmanager
async def app_lifespan(app: FastAPI) -> AsyncGenerator[None]:
    with sentry_sdk.start_transaction(
        name="App Lifespan", op="lifespan"
    ) as transaction:
        # we need to manually keep track of resource initialization here
        # because Mangum runs the application lifespan on every request.
        # ref: https://github.com/Kludex/mangum/issues/342
        if not app.state.has_initialized:
            logger = get_logger(__name__)
            logger.debug("Initializing application secrets")
            # load secrets during startup
            with sentry_sdk.start_span(op="settings.get", description="SecretSettings"):
                get_settings(SecretSettings)
            database_settings = get_settings(DatabaseSettings)
            logger.debug("Initializing database connection")
            await initialize_database(
                database_url=str(database_settings.database_url),
                default_database_name=database_settings.default_database_name,
            )
            # we need to manually keep track of resource initialization here
            # because Mangum runs the application lifespan on every request.
            app.state.has_initialized = True
        yield


def create_app() -> FastAPI:
    """Create an application instance."""
    app_settings = get_settings(AppSettings)
    app = FastAPI(
        version="0.0.1",
        debug=app_settings.debug,
        openapi_url=app_settings.openapi_url,
        root_path=app_settings.root_path,
        lifespan=app_lifespan,
    )
    # we need to manually keep track of resource initialization here
    # because Mangum runs the application lifespan on every request.
    # ref: https://github.com/Kludex/mangum/issues/342
    app.state.has_initialized = False
    # register routes here etc..
    return app

[aryaniyaps]

even though this works, this still adds about 100ms latency to the application for dummy lifespan calls, which could be removed if the lifespan setup was designed to just invoke on the initial call!

[zhukovgreen]

@aryaniyaps thanks for your solution. One alternative, which is also covering expensive teardown logic (for >=python3.12) is this:

@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
    """FastAPI app lifespan definition."""

    async with AsyncExitStack() as stack:
        for router in routers.values():
            await stack.enter_async_context(router)
        yield


app = FastAPI(lifespan=lifespan)

if not os.environ.get("IS_LOCAL_TEST"):
    ctx = lifespan(app)
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)

    loop.run_until_complete(ctx.__aenter__())
    atexit.register(
        lambda: loop.run_until_complete(
            ctx.__aexit__(
                None,
                None,
                None,
            )
        )
    )

handler = Mangum(
    app=app,
    lifespan="off",
)

This has few advantages - startup and shutdown logic will work correctly (startup at lambda init and shutdown when lambda is shutting down (for py3.12 they have proper signals and lets app properly shutdown, but even for 3.10 this works for not heavy teardown logic). Also this work the same for other asgi servers, like uvicorn.

Problem with this solution is that yielding in startup event is not changing the app state.

[aryaniyaps]

@aryaniyaps thanks for your solution. One alternative, which is also covering expensive teardown logic (for >=python3.12) is this:

@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncIterator[None]:
"""FastAPI app lifespan definition."""

async with AsyncExitStack() as stack:
    for router in routers.values():
        await stack.enter_async_context(router)
    yield

app = FastAPI(lifespan=lifespan)

if not os.environ.get("IS_LOCAL_TEST"):
ctx = lifespan(app)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)

loop.run_until_complete(ctx.__aenter__())
atexit.register(
    lambda: loop.run_until_complete(
        ctx.__aexit__(
            None,
            None,
            None,
        )
    )
)

handler = Mangum(
app=app,
lifespan="off",
)
This has few advantages - startup and shutdown logic will work correctly (startup at lambda init and shutdown when lambda is shutting down (for py3.12 they have proper signals and lets app properly shutdown, but even for 3.10 this works for not heavy teardown logic). Also this work the same for other asgi servers, like uvicorn.

Problem with this solution is that yielding in startup event is not changing the app state.

I tried out AWS Lab's lambda web adapter and it runs the lifespan as expected- only once!

https://github.com/awslabs/aws-lambda-web-adapter

Do check it out if you don't want the above workaround!
(disclaimer- this is an alternative to mangum that isn't a code library. its a lambda extension that can directly be used in container images)