[feature] global extra's (key-value)

[ddofborg]

I would like to be able to set some global extra's to all log output. This is useful when logs are written to files or terminal from multiple processed running at the same time. This way each line can be connected by PID or some other useful key-value pair. Especially when other modules are also logging and you want to know what is was related to.

Code:

log.set('pid', os.getpid())
log.info("loading account")
account_id = load_account()
log.set('account', account_id)
log.info("computing")
compute(account_id)
log.info("unloading account")
unload(account_id)
log.set('account', None)
log.info("done")

Output:

2025-08-09 07:53:37 [INFO    ] [pid=123] loading account
2025-08-09 07:53:37 [INFO    ] [pid=123, account=456] computing
2025-08-09 07:53:37 [INFO    ] [pid=123, account=456] unloading account
2025-08-09 07:53:37 [INFO    ] [pid=123] done

What do you think?

[aparna2198]

@ddofborg you basically want global contextual logging in loguru, so you can dynamically add metadata (like PID or account ID) that is automatically included in all log lines without having to pass it each time.

[ddofborg]

Exactly!

[Delgan]

Hi @ddofborg. Have you considered using logger.contextualize()?

with logger.contextualize(pid=os.getpid()):
    log.info("loading account")
    account_id = load_account()
    with logger.contextualize(acount=account_id):
        log.info("computing")
        compute(account_id)
        log.info("unloading account")
        unload(account_id)
    log.info("done")

This is current the closest solution to what you suggest. I prefer not to extend the logger with a new set() / unset() API to Loguru.

However, if you really want to get rid of the context manager, It is possible to use a separate ContextVar on your own:

from contextvars import ContextVar

ctx = ContextVar("ctx", default={})

def set_context(**kwargs):
    current_context = ctx.get()
    for key, value in kwargs.items():
        if value is None:
            current_context.pop(key, None)
        else:
            current_context[key] = value
    ctx.set(current_context)


logger.configure(patcher=lambda record: record["extra"].update(ctx.get()))

set_context(pid=os.getpid())
logger.info("loading account")
account_id = load_account()
set_context(account=account_id)
logger.info("computing")
compute(account_id)
logger.info("unloading account")
unload(account_id)
set_context(account=None)
logger.info("done")

Note that Loguru does not (yet) use the extra dict in the default format, so you'll have to change it, for example:

logger.add(sys.stderr, format="{time} {level} {message} {extra}", level="INFO")

[aparna2198]

@Delgan @ddofborg

you can try something as below

from loguru import _logger

class LoggerWithGlobalExtras(_logger.Logger):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._global_extras = {}

    def set(self, key, value=None, **kwargs):
        """Set global extras to be applied to all log records."""
        if key is not None:
            self._global_extras[key] = value
        for k, v in kwargs.items():
            self._global_extras[k] = v

    def _log(self, level_id, static_level_no, from_decorator, options, *args, **kwargs):
        # Merge global extras with per-call extras
        options["extra"] = {**self._global_extras, **(options.get("extra") or {})}
        
        # Remove keys with None values
        options["extra"] = {k: v for k, v in options["extra"].items() if v is not None}
        
        super()._log(level_id, static_level_no, from_decorator, options, *args, **kwargs)

# Replace default logger instance
from loguru import logger
logger.__class__ = LoggerWithGlobalExtras

import os
from loguru import logger

logger.set("pid", os.getpid())
logger.info("loading account")

account_id = 456
logger.set("account", account_id)
logger.info("computing")
logger.info("unloading account")

logger.set("account", None)
logger.info("done")

[Delgan]

Yes, thanks @aparna2198 for sharing an additional workaround. This solution is truly "global", as opposed to my use of ContextVars. Note, however, that such an implementation requires a lock mechanism to protect you from data races in a multi-threading context.

[aparna2198]

agreed! we need to want to make LoggerWithGlobalExtras thread-safe so that self._global_extras won’t have race conditions if multiple threads call set() or log at the same time. we can perhaps use Reentrant lock

import threading
from loguru import _logger

class LoggerWithGlobalExtras(_logger.Logger):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._global_extras = {}
        self._extras_lock = threading.RLock()  # Reentrant lock for nested calls

    def set(self, key, value=None, **kwargs):
        """Set global extras to be applied to all log records."""
        with self._extras_lock:
            if key is not None:
                self._global_extras[key] = value
            for k, v in kwargs.items():
                self._global_extras[k] = v

    def _log(self, level_id, static_level_no, from_decorator, options, *args, **kwargs):
        with self._extras_lock:
            merged = {**self._global_extras, **(options.get("extra") or {})}
        # Remove keys with None values outside lock (safe now, local copy)
        options["extra"] = {k: v for k, v in merged.items() if v is not None}

        super()._log(level_id, static_level_no, from_decorator, options, *args, **kwargs)

# Replace default logger instance
from loguru import logger
logger.__class__ = LoggerWithGlobalExtras

import os
from loguru import logger

logger.set("pid", os.getpid())
logger.info("loading account")

account_id = 456
logger.set("account", account_id)
logger.info("computing")
logger.info("unloading account")

logger.set("account", None)
logger.info("done")