Decorator: disable tracing at the decorated function level

[klemenstraeger]

Hi there,
we have a use case where we want to disable the tracing with langfuse for certain requests (specified in the request body). However by using
langfuse_context.configure(enabled=request.enable_tracing)

only the following requests are not logged. However the requests where we don't want to trace the request are logged in Langfuse.

Do we need to call flush() after disabling the client or is there another option to temporarily disable tracing for certain requests?

@router.post(
    "/chat",
)
@observe(capture_input=ENVIRONMENT == "dev")
async def get(
request: UserRequest,
...
) 
    langfuse_context.configure(enabled=request.enable_tracing)
    
    
    ... do stuff

PS: We use FastAPI + Litellm as a Wrapper

[dosubot[bot]]

Hey @klemenstraeger! I'm here to help you with any bugs, questions, or contributions you have. Let's tackle this together!

To disable tracing for specific requests in Langfuse, you should ensure that the enabled parameter in the langfuse_context.configure() method is set correctly for each request. However, it seems that setting enabled=request.enable_tracing might not be working as expected for disabling tracing on certain requests.

Here are a few things to consider:

1. Configuration Scope: Ensure that the langfuse_context.configure() method is called at the right scope. It should be set at the beginning of the request handling to ensure it affects the entire request lifecycle.

2. Decorator Behavior: The @observe decorator might still capture traces if it is not respecting the enabled state dynamically. You might need to check if the decorator has built-in support for dynamically checking the enabled state or if additional logic is needed to conditionally apply the decorator.

3. Flush Method: The flush() method is used to send queued events immediately, but it does not disable tracing. It ensures that all events are sent before the application exits, which is useful for short-lived applications ^[1][2].

4. Custom Logic: If the built-in mechanisms do not support dynamic disabling, consider implementing custom logic to bypass the tracing logic based on your request conditions.

If these suggestions do not resolve the issue, you might need to explore further customization or check for updates in the Langfuse documentation or codebase that might address this specific use case.

To continue talking to Dosu, mention @dosu.

[hassiebp]

hi @klemenstraeger - do I understand you correctly that you wish for some kind of switch on the execution level that controls whether a function and all its potentially nested decorated functions are traced or not? Something like

@observe
def main(*args, **kwargs):
    return 1

main(langfuse_enabled=False)

Having this fine grained control would be definitely a new feature to be added, currently we support an enabled switch on the global level only.

[hassiebp]

A workaround would be something like this:

@observe
def llm_call:
    return 1

def llm_call_with_switch(langfuse_traced=True):
   return llm_call if langfuse_traced else llm_call.__wrapped__

llm_call_with_switch(langfuse_traced=False)

This would return the original wrapped function by the decorator. However, if that function calls other decorated functions, they would be still traced if not wrapped similarly. So I agree that a switch would be a nice feature to add.

[klemenstraeger]

Exactly we need to disable and enable tracing on run time level.

[hassiebp]

Got it! Converted this discussion to an Idea to track it as a feature request 👍🏾