works fine for me copy-pasting the exact same thing, only had to comment print(await request.json()) which crashed the app

@app.middleware("http")
async def func(request: Request, call_next):
    # print(await request.json())
    return await call_next(request)


@app.post("/bug")
def bug(arg: Mapping[str, str]):
    return {"Hello": "World"}

 ✗ curl -d '{"status":"ok"}' http://localhost:8000/bug
{"Hello":"World"}%             

works fine for me copy-pasting the exact same thing, only had to comment print(await request.json()) which crashed the app

That's exactly the point, the print statement, or more exactly the ``àwait``` inside blocks the application. The question is why ?
And the other question, more important for me is : how can I log my request payload if i'm not able to await it in middleware ?

I think the middleware is unnecessary, should you want to get your payload just do:

@app.post("/bug")
async def read_root(request: Request, arg: Mapping[str, str]):
    print(await request.json())
    return {"Hello": "World"}

I think the middleware is unnecessary, should you want to get your payload just do:

But i don't want to just get the payload of one request, i want to log the payloads of EVERY endpoints of my application. I don't want for that to add code in every endpoint, that's the purpose of a middleware.

@wyfo It appears this is sort of a Starlette problem -- if you try to access request.json() both inside of and outside of a middleware, you'll run into the same problem you are hitting with fastapi. This has to do with how the json is "cached" inside the starlette Request -- it isn't transferred to the next called asgi app.

You can reproduce the issue in the pure starlette example if you try to print the json contents inside your starlette endpoint:

• change def homepage(request): it to use async def
• add a line containing print(await request.json())

FastAPI grabs the request.json() as part of it's request handling, which is why you run into the issue even without explicitly trying to if using FastAPI.

In order for this to be handled properly, I think it would require fixes in starlette; I feel like I've seen this discussed in starlette issues, but I'm not sure. I'll reference it if I find it. Even if you weren't using FastAPI, you'd face this issue if you didn't do something funny with to store the json after the first time you read it.

On the other hand, I think there is a neat workaround for this use case (that actually requires FastAPI), since you don't need your middleware to modify anything before the next handler receives it:

from typing import Mapping

from starlette.requests import Request

from fastapi import FastAPI, APIRouter, Depends

app = FastAPI()
api_router = APIRouter()

@api_router.post("/")
def read_root(arg: Mapping[str, str]):
    return {"Hello": "World"}

async def log_json(request: Request):
    print(await request.json())

# the trick here is including log_json in the dependencies:
app.include_router(api_router, dependencies=[Depends(log_json)])

This requires you to add all endpoints to api_router rather than app, but ensures that log_json will be called for every endpoint added to it (functioning very similarly to a middleware, given that all endpoints pass through api_router).

This works because no new Request instance will be created as part of the asgi request handling process, so the json read off by FastAPI's processing will still be cached on the request when the log_json function is called.

@wyfo For what it's worth, it looks like consuming the body inside of middleware is somewhat broadly discouraged -- Kludex/starlette#495 (comment) (by the creator of starlette):

Consuming request data in middleware is problematic.
Not just to Starlette, but generally, everywhere.

On the whole you should avoid doing so if at all possible.

So the "workaround" I posted above may actually be a better way to handle this than middleware anyway.

@dmontagu
Thank you a lot ! For your workaround and for retrieving the starlette issue. I don't really understand the point of @tomchristie about that, but it seems I have to continue the discussion in the dedicated place.

Thanks for your help @euri10 and @dmontagu.

Agreed with all of @dmontagu's explanation and suggestion.

Thanks @wyfo for reporting back and closing the issue.

I guess, it's useful to use custom Request or Route in some cases.

class LoggedRoute(APIRoute):
    def get_route_handler(self):
        original_route_handler = super().get_route_handler()

        async def log_request_detail(request):
            ref = '{}:{}'.format(*request.scope.get('server', ('', '')))
            protocol = (f'{request.scope.get("type", "unknown").upper()}'
                        f'/'
                        f'{request.scope.get("http_version", "unknown")}')

            try:
                body = await request.json()
            except JSONDecodeError:
                body = {}

            logger.info(f'{ref} - "{request.method} {request.url.path} '
                        f'{protocol}" {body}')

            return await original_route_handler(request)

        return log_request_detail

Proof me wrong

@dmontagu I used your method, and I get a RuntimeError: Stream consumed exception in the log_request_json function. Do you see what I did wrong?

import logging
import fastapi

import routers

logger = logging.getLogger(__name__)
app = fastapi.FastAPI()

async def log_request_json(request: fastapi.Request):
    logger.debug("request parameters: %s", await request.json())

app.include_router(routers.api_router, dependencies=[fastapi.Depends(log_request_json)])

How to use two await keyword within a function to log all the endpoint,if I use so my application does not working.

How to use two await keyword within a function to log all the endpoint,if I use so my application does not working.

@PrasannaVpk Do you mean health-check?

I cant able to log body json for all post request. Can you please suggest a alternative how to log the request json. Right now it goes to infinite loop and not responding.

 
@app.middleware("http")
async def log_requests(request: Request, call_next):

    
    
    body = await request.body()
    body_req = json.loads(body.decode("utf-8"))
    
    start_time = time.time()
    
    response = await call_next(request)
    
    
    process_time = (time.time() - start_time) * 1000
    formatted_process_time = '{0:.2f}'.format(process_time)

    log_json={
              "uuid":str(uuid.uuid4()),
              "ts":formatted_process_time,
              "env":os.environ.get("ENV"),
              "region":os.environ.get("REGION"),
              "name":os.environ.get("NAME"),
              "type":"request",
              "method":request.method,
              "useragent":request.headers["user-agent"],
              "status_code":response.status_code,
              "url":request.url.path,
              "query":request.query_params,
              "body": body_req ,
              "length":response.headers["content-length"],
              'ts':formatted_process_time
              }
   
    pprint(log_json)
    
   
    return response

class Item(BaseModel):
    name:str
    


@app.post("/hello_world")
async def hello_world(item:Item):
    pprint(item)
    return item

@karthick-optisol Check out this doc https://fastapi.tiangolo.com/advanced/custom-request-and-route/#accessing-the-request-body-in-an-exception-handler.
Implements it in a custom Route is much easier.

 async def set_body(request: Request, body: bytes):
     async def receive() -> Message:
         return {"type": "http.request", "body": body}
     request._receive = receive
 
 async def get_body(request: Request) -> bytes:
     body = await request.body()
     await set_body(request, body)
     return body
 
 @app.middleware("http")
 async def app_entry(request: Request, call_next):
     
     await set_body(request, request.body())
 
     print(await get_body(request))
 
     response = await call_next(request)
     return response

what is "Message" there?

from starlette.types import Message

@fawwazihsanr

 async def set_body(request: Request, body: bytes):
     async def receive() -> Message:
         return {"type": "http.request", "body": body}
     request._receive = receive
 
 async def get_body(request: Request) -> bytes:
     body = await request.body()
     await set_body(request, body)
     return body
 
 @app.middleware("http")
 async def app_entry(request: Request, call_next):
     
     await set_body(request, request.body())
 
     print(await get_body(request))
 
     response = await call_next(request)
     return response

await set_body(request, request.body()) -> await set_body(request, await request.body())

Looks like await should be added.

For anyone who is looking for class-based middleware:

class LoggingMiddleware(BaseHTTPMiddleware):

    def __init__(self, app):
        super().__init__(app)

    async def set_body(self, request: Request):
        receive_ = await request._receive()

        async def receive() -> Message:
            return receive_

        request._receive = receive

    async def dispatch(self, request, call_next):
        await self.set_body(request)
        body = await request.body()
        json_body = await request.json()

        print(body)
        print(json_body)

        response = await call_next(request)

        return response

Many thanks for @liukelin

This workaround works as expected many thanks @king-peanut.

The unique condition is that this should be placed as the last middleware (the first to be loaded into the app, take care about the reverse ordering), if not it will freeze.

@king-peanut Your solution solves the hanging issue. However, whenever I do request.json() again in the endpoint function (besides doing it in the middleware), the byte string data is read again and converted to the python dictionary again. This can cause extra latency when the payload is large.