`logger.contextualize` and threading

[zmeir]

Hi,

First just wanted to say I'm really enjoying this package. It made logging fun and simple for me.

I have a question/issue when trying to log from a thread inside a logger.contextualize scope.

Here's my example:

import sys
import asyncio
import threading
from loguru import logger, _defaults

logger.remove(None)
logger.add(sys.stderr, format=_defaults.LOGURU_FORMAT + " | {extra}")

def thread_func():
    logger.info("hello thread")

async def async_func():
    logger.info("hello async")

async def main():
    with logger.contextualize(a=1):
        await async_func()
        threading.Thread(target=thread_func, daemon=True).start()

asyncio.run(main())

And here's my output:

2025-03-06 09:36:54.691 | INFO     | __main__:async_func:13 - hello async | {'a': 1}
2025-03-06 09:36:54.691 | INFO     | __main__:thread_func:10 - hello thread | {}

As you can see, the context isn't passed to the thread function, only to the async one.

Is there something I'm missing to make the context pass to the thread? Or is this capability not supported?

Version info:

• OS: macOS 14.7.2 (23H311)
• Python: 3.12.8
• Loguru: 0.7.3

[Delgan]

Hi @zmeir.

This is actually part of the design. Internally, logger.contextualize() relies on the contextvars built-in Python library. This offers interesting guarantees regarding thread-safety, in particular that it affects only current thread and current async context. This features proves to be very useful when working with multiple threads in parallel, such as a web framework for example. This ensures that the context from two workers does not inadvertently override each other when called concurrently.

[zmeir]

Hi @Delgan,

Thanks for the explanation. I understand the internals now, although I'm still a bit surprised by the behavior. I understand that you don't want to "leak" the context to other threads, but wouldn't a thread spawned from within the contextualize block constitute as a thread "belonging" to that context? I mean that logically; I understand that the technical part is very different.

To clarify my example - in my real use-case I have a FastAPI app that spawns threads from within the endpoint function. I want logs from the function as well at any spawned threads to share the same context as they all come from the same request. For example:

import sys
import threading

from loguru import logger, _defaults
from fastapi import FastAPI, Request, params


logger.remove(None)
logger.add(sys.stderr, format=_defaults.LOGURU_FORMAT + " | {extra}")

app = FastAPI()


@app.middleware("http")
async def log_requests(request: Request, call_next):
    with logger.contextualize(**request.query_params):
        response = await call_next(request)
    return response


async def async_logic():
    logger.info("async logic")


def thread_logic():
    logger.info("thread logic")


@app.get("/hello")
async def hello(name: str = params.Query("name")):
    await async_logic()
    threading.Thread(target=thread_logic, daemon=True).start()
    return {"Hello": name}


if __name__ == "__main__":
    import uvicorn

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

Then if you head over to http://localhost:8000/hello?name=someone you will see the following in your application logs:

2025-03-17 09:20:11.859 | INFO     | __main__:async_logic:23 - async logic | {'name': 'someone'}
2025-03-17 09:20:11.860 | INFO     | __main__:thread_logic:27 - thread logic | {}

My current workaround is to wrap the thread execution with something that would copy the async context of the parent thread into the spawned thread. Something like this:

@app.get("/hello")
async def hello(name: str = params.Query("name")):
    import contextvars
    await async_logic()
    threading.Thread(target=contextvars.copy_context().run, args=(thread_logic,), daemon=True).start()
    return {"Hello": name}

Then you get these application logs:

2025-03-17 09:27:29.715 | INFO     | __main__:async_logic:22 - async logic | {'name': 'someone'}
2025-03-17 09:27:29.715 | INFO     | __main__:thread_logic:26 - thread logic | {'name': 'someone'}

Do you have a better solution?
Do you think that maybe this sort of feature could be supported internally by loguru at some point? (with the proper configuration/toggle)

[ripperdoc]

I had this same issue, and currently trying to solve it with this simple helper code:

from loguru._logger import context

# Inside a class
self.logger = logger.bind(**context.get()) # result of get() defaults to {}

# In callback running on other thread but defined in the class
self.speech.session_started.connect(
   lambda evt: self.logger.debug("SESSION STARTED: {}".format(evt))
)

Then in code that is called from other contexts, such as callbacks in other threads, they are pointed to self.logger. Works so far, but I am sure I'm missing something that might break?