Is there a FastAPI way to access current Request data globally?

Question

Within the FastAPI framework:

While request data can certainly be passed around as an argument, I would like to know if it is possible for a function to access information about the current request without being passed an argument.

Disclaimer: I do not think global access to Request data a good practice, and yet I have a use case where it would be very good to be able to do.

Answer 1

A solution provided here defines a context manager, that you can access globally. For each request, you are extracting the relevant information (like headers) & pass it to the context manager.

Since fastapi is built with Starlette, you can use the library starlette-context. It is creating a context object that you can use without passing it as argument. The main caveat is that you still need to pass a request object to all your routes.

EDIT: In starlette-context==0.3.0 new middleware has been added. Starlette team started to discourage (here) the use of their BaseHTTPMiddleware, in particulary for StreamingResponse/FileResponse endpoints. You might want to use RawContextMiddleware which also doesn't require the request object but it's experimental as there is no documentation in Starlette for writing custom middleware without the interface. But it seems to be working.

Sample code from this lib to illustrate:

import uvicorn
from fastapi import FastAPI
from starlette.requests import Request
from starlette.responses import JSONResponse
from starlette.middleware import Middleware

from starlette_context import context, plugins
from starlette_context.middleware import RawContextMiddleware

middleware = [
    Middleware(
        RawContextMiddleware,
        plugins=(
            plugins.RequestIdPlugin(),
            plugins.CorrelationIdPlugin()
        )
    )
]

app = FastAPI(debug=True, middleware=middleware)


@app.route('/')
async def index(request: Request):  # This argument is still needed here
    return JSONResponse(context.data)  # Your context data


uvicorn.run(app, host="0.0.0.0")

Answer 2

You can get/set arbitrary attributes on request.state from Starlette.

https://www.starlette.io/requests/#other-state

Please refer the below issue for detailed explanation and implementation:

https://github.com/tiangolo/fastapi/issues/633

Answer 3

Wanted to provide an updated answer here. My original comment is on a starlette issue, here.

I am using FastAPI, and needed a way to access information on the request object outside of a view. I initially looked at using starlette-context but found the below solution to work for my needs.

Credit to Marc (see starlette issue above) for the basis of this solution.

As noted by Colin Le Nost above, the authors warn against using BaseHTTPMiddleware -- the parent class Marc's middleware inherits from.

Instead, the suggestion is to use a raw ASGI middleware. However, there isn't much documentation for this. I was able to use Starlette's AuthenticationMiddleware as a reference point, and develop what I needed in combination with Marc's wonderful solution of ContextVars.

# middleware.py
from starlette.types import ASGIApp, Receive, Scope, Send

REQUEST_ID_CTX_KEY = "request_id"

_request_id_ctx_var: ContextVar[str] = ContextVar(REQUEST_ID_CTX_KEY, default=None)

def get_request_id() -> str:
    return _request_id_ctx_var.get()

class CustomRequestMiddleware:
    def __init__(
        self,
        app: ASGIApp,
    ) -> None:
        self.app = app

    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
        if scope["type"] not in ["http", "websocket"]:
            await self.app(scope, receive, send)
            return

        request_id = _request_id_ctx_var.set(str(uuid4()))

        await self.app(scope, receive, send)

        _request_id_ctx_var.reset(request_id)

And then in the app setup:

# main.py
app.add_middleware(CustomRequestMiddleware)

And finally, the non-view function:

# myfunc.py
import get_request_id

request_id = get_request_id()

This should enable you to use ContextVars as a way to get any info from the request object you need, and make it available outside of view function. Thanks again to everyone in this thread for all the help, and I hope the above is useful!

Answer 4

I would typically do this using producer-consumer style messaging queue. I have an example repo showing how I use a global queue to push data from a post request to a WebSocket that broadcasts this to clients.

While this might not be your exact use case, you should be able to adapt it to suit.

The guts of it are a Notifier class which pushes data to the queue:

async def push(self, msg: str):
    await self.channel.default_exchange.publish(
        Message(msg.encode("ascii")),
        routing_key=self.queue_name,
    )

And on the consumer side, I have a _notify function that receives messages from the queue and sends it through the WebSocket:

async def _notify(self, message: IncomingMessage):
    living_connections = []
    while len(self.connections) > 0:
        websocket = self.connections.pop()
        await websocket.send_text(f"{message.body}")
        living_connections.append(websocket)
    self.connections = living_connections

Answer 5

you can use starlette Request

for example:

from starlette.requests import Request
from fastapi import FastApi

app = FastApi()
@app.get('/')
def get(request:Request):
    requests_header = request.headers
    return "Hi"