1

Imagine I have a FastAPI backend application exposing the following test endpoint:

@router.post("/my_test")
async def post_my_test(request: Request):
    a = do_stuff(request.var1)
    b = do_different_stuff(request.var2)
    return a + b

Inside my do_stuff() and do_different_stuff() a lot of (nested) business logic is executed. E.g. inside do_stuff we call another method which calls another method etc. When reaching the lowest level the resulting method does some calculation

async def calc_it(m, n):
    try:
        return m/n
    except ZeroDivisionError:
        logging.exception("Error occurred")
        return -1

Inside this method we explicitly handle the resulting error (let's assume it might be somewhat expected that in rare cases this happens). If this happens I woult want to log the complete request object from the top-level endpoint. I see the following possibilities on achieving this.

  1. Propagate the information that the error occured to the top-level method e.g. return -1, "err_occured" all the way up and log it inside post_my_test
  2. Propagate the whole request object all the way down to all low-level methods which execute stuff and log the request object inside calc_it
  3. Use some type of FastAPI Middleware object to intercept request and response or a separate Exception handler app.add_exception_handler(Exception, my_exception_handler) --> However I still want to handle the error (e.g. in this case return -1) inside the low-level method because I want to explicitly configure different fallback values in a lot of instances.

The 1. and 2. choice would obviously work however I have the feeling there should/could be some better solutions than propagating this all the way down/up. The 3. choice using a basic middleware won't work as it never sees the exception when we catch it with the low-level method try except statement.

I have the feeling there surely exists a smarter way of handling this. E.g. is there some global variable on a request-level I could modify which could pass the information that this complete request should be logged or not or are there any other ways of achieving this functionality without cluttering my code with up and down propagating information?

Thanks in advance for your help!

EDIT: I stumbled upon Is there a FastAPI way to access current Request data globally?? and Request context in FastAPI? which employ ContextVars to pass the data using imports. As clarified in my comment I could thus set the request object as ContextVar. So I basically pass the complete request object to all my methods down the line. Is this some kind of anti-pattern? (It feels kinda strange to pass a potentially huge object like this) IMO it could be better to pass the flag with this kind of information ("log_this_request") up to the endpoint logic using ContextVars, however as I'm using asnycio tasks I'm only able to pass it down to tasks but not "back up" to their parent.

Improve this question
3
  • Is it possible in your use case just to re-raise the exception? Commented Aug 19, 2024 at 14:16
  • I want to "regularly" continue calculating with the fallback value -1, so if I would re-raise this wouldn't work as some parent try except statement would just catch it and skip that regular calculation part. Or I could later recheck if the fallback value was set, however this seems also counter intuitive as I would need to do a lot of checks again and again. Commented Aug 19, 2024 at 14:29
  • I just stumbled upon ContextVars and it might be possible to set the request object as ContextVar and pass it down to all methods by using a simple import statement. However it also seems strange to pass this potentially "huge" request object in this way to all my methods. Any thoughts on that? I don't want to implement some huge anti-pattern but simultaneously want to stay pragmatic. Commented Aug 19, 2024 at 14:32

1 Answer 1

Reset to default
1

Yes - the correct answer would be " 2- Propagate the whole request object all the way down to all low-level methods which execute stuff and log the request object inside calc_it" - but instead of propagating it through function arguments to every intermediate function, use a separate data-storage which is unique per-request, so each function being run inside a request can access it.

This "data storage" happens to be implemented in the languague through the contextvars mechanism - and, as you found out, FastApi already makes use of those so that any function can retrieve information about the request which triggered it to be called.

As it turns out, you are worried about passing a huge object along: keep in mind that all Python passes along (or store in the contextvar, for this matter) is a reference to the object (the request object in this case) - so, no extra memory is allocated beyond the few bytes needed to note the reference itself.

Note however, that architecture wise it might not be interesting that calc_it would have to know about fastapi requests in order to log the error - (this way you keep low coupling in your system, allowing you to change the HTTP-API fraework in the future) So you could make use of your own contextvariables to indicate an error took place - and the top-level function would check that after the nested-calls return, and log it from there. (It is in a layer which "knows" about requests). If you find using raw contextvar.ContextVar complicated, the extracontext package I authored had a stable-release last week, and can wrap contextvars in a "more Pythonic" API, providing a namespace, for example.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

Awesome, Thanks! That is exactly what I wanted to know. Follow-Up: I am using asyncio TaskGroup to execute multiple tasks in an asnyc manner task = tg.create_task(my_func). When I quickly tested it, it only worked by passing ContextVars down to tasks but not "back up". Is this a problem e.g. as multiple tasks could modify the same ContextVar and thus it doesn't allow this behavior? I'll definitely check out your package
A new task in an asyncio context will by default, run on its own context. which means it can read contextvars written in the outter calls (e.g. the task which called .create_task ) but any writes are contained to that task itself. However - contextvar.ContextVars can hold a single value. If that value is a composite object (like a dict or a FastAPI request), changes made inside that object are visible in the other contexts .
extacontext by default provides a namespace isolated per context. (just like threading.locals -and might simplify a lot of things if your goal is to keep isolation. (It still won´t isolate composite object attributes, though)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.