La journalisation des données de la variable avec la nouvelle chaîne de format

EDIT: prendre un coup d'oeil à la StyleAdapter approche @Dunes de réponse à la différence de cette réponse; il permet d'utiliser d'autres styles de mise en forme sans le passe-partout tout en appelant enregistreur de méthodes (debug(), info(), error(), etc).

De la documentation — Utilisation d'autres styles de mise en forme:

La journalisation des appels (logger.debug(), logger.info (), etc.) seulement prendre
les paramètres positionnels de l'enregistrement réel message lui-même, avec
paramètres de mot clé utilisé que pour déterminer les options pour gérer
l'enregistrement réel appel (par exemple, la exc_info mot-clé paramètre
indiquent que le traçage de l'information doit être connecté, ou l'extra
mot-clé paramètre pour indiquer des informations contextuelles supplémentaires à
dans le journal). Si vous ne pouvez pas le faire directement la journalisation des appels à l'aide
str.format() ou de la ficelle.La syntaxe du modèle, parce que de l'intérieur, la journalisation
utilise le package %-mise en forme de fusionner la chaîne de format et la variable
les arguments. Il n'y aurait pas de changement tout en préservant arrière
compatibilité, depuis l'abattage des appels qui sont là-bas dans l'existant
le code va être l'aide d' %-les chaînes de format.

Et:

Il est, cependant, d'une façon que vous pouvez utiliser {} et $- mise en forme de
construire vos messages de journal. Rappelons que pour un message vous
pouvez utiliser un objet arbitraire comme un format de message de la chaîne, et que la
la journalisation paquet d'appel str() sur l'objet pour obtenir le réel
chaîne de format.

Copier-coller de ce wherever module:

class BraceMessage(object):
    def __init__(self, fmt, *args, **kwargs):
        self.fmt = fmt
        self.args = args
        self.kwargs = kwargs

    def __str__(self):
        return self.fmt.format(*self.args, **self.kwargs)

Alors:

from wherever import BraceMessage as __

log.debug(__('Message with {0} {name}', 2, name='placeholders'))

Remarque: le formatage est retardée jusqu'à ce qu'il est nécessaire, par exemple, si les messages de DÉBOGAGE ne sont pas connectés, puis la mise en forme n'est pas réalisée à tous.

C'était ma solution pour le problème quand j'ai trouvé l'enregistrement seulement utilise printf mise en forme de style. Il permet la journalisation des appels à restent les mêmes: il n'est pas de la syntaxe comme log.info(__("val is {}", "x")). Le changement de code est d'envelopper l'enregistreur dans un StyleAdapter.

from inspect import getargspec

class BraceMessage(object):
    def __init__(self, fmt, args, kwargs):
        self.fmt = fmt
        self.args = args
        self.kwargs = kwargs

    def __str__(self):
        return str(self.fmt).format(*self.args, **self.kwargs)

class StyleAdapter(logging.LoggerAdapter):
    def __init__(self, logger):
        self.logger = logger

    def log(self, level, msg, *args, **kwargs):
        if self.isEnabledFor(level):
            msg, log_kwargs = self.process(msg, kwargs)
            self.logger._log(level, BraceMessage(msg, args, kwargs), (), 
                    **log_kwargs)

    def process(self, msg, kwargs):
        return msg, {key: kwargs[key] 
                for key in getargspec(self.logger._log).args[1:] if key in kwargs}

D'Usage:

log = StyleAdapter(logging.getLogger(__name__))
log.info("a log message using {type} substiution", type="brace")

Il est intéressant de noter que cette mise en oeuvre a des problèmes si les mots clés utilisés pour attelle de substitution inclure level, msg, args, exc_info, extra ou stack_info. Ce sont les noms d'argument utilisé par le log méthode de Logger. Si vous avez besoin de l'un de ces noms, puis modifier process pour exclure ces noms ou tout simplement supprimer log_kwargs de la _log appel. Sur une autre note, cette mise en œuvre est également ignore silencieusement mal orthographié les mots-clés destiné à l'Enregistreur (par exemple. ectra).

Comme d'autres réponses mentionner, le corset-style de mise en forme introduit en Python 3.2 est utilisée uniquement sur la chaîne de format, pas le journal des messages.

Pour permettre corset-style de mise en forme sur le réel message de log, nous pouvons singe-patch un peu de l'enregistreur de données de code.

Les correctifs suivants la logging module pour créer un get_logger fonction qui retourne un enregistreur de frappe qui utilise le nouveau style de mise en forme pour chaque enregistrement de journal qu'elle gère.

import functools
import logging
import types

def _get_message(record):
    """Replacement for logging.LogRecord.getMessage
    that uses the new-style string formatting for
    its messages"""
    msg = str(record.msg)
    args = record.args
    if args:
        if not isinstance(args, tuple):
            args = (args,)
        msg = msg.format(*args)
    return msg

def _handle_wrap(fcn):
    """Wrap the handle function to replace the passed in
    record's getMessage function before calling handle"""
    @functools.wraps(fcn)
    def handle(record):
        record.getMessage = types.MethodType(_get_message, record)
        return fcn(record)
    return handle

def get_logger(name=None):
    """Get a logger instance that uses new-style string formatting"""
    log = logging.getLogger(name)
    if not hasattr(log, "_newstyle"):
        log.handle = _handle_wrap(log.handle)
    log._newstyle = True
    return log

Utilisation:

>>> log = get_logger()
>>> log.warning("{!r}", log)
<logging.RootLogger object at 0x4985a4d3987b>

Notes:

• Entièrement compatible avec la normale méthodes de journalisation (il suffit de remplacer logging.getLogger avec get_logger)
• Sera seulement affecter des enregistreurs créé par le get_logger fonction (ne pas briser la 3ème partie de paquets).
• Si l'enregistreur de données est accessible à nouveau à partir d'un logging.getLogger() appel, le nouveau style de mise en forme s'applique toujours.
• kwargs ne sont pas pris en charge (il est impossible d'entrer en conflit avec le haut -exc_info, stack_info, stacklevel et extra).
• Performances devraient être minimes (réécriture d'une seule fonction de pointeur pour chaque message de log).
• La mise en forme du message est retardée jusqu'à ce qu'elle est sortie (ou pas du tout si le message de log est filtré).
• Args sont stockés sur logging.LogRecord objets comme d'habitude (utile dans certains cas avec un journal personnalisé gestionnaires).
• En regardant le journalisation module de code source il me semble qu'il doit travailler tout le chemin du retour à la version 2.6 de Python quand str.format a été mis en place (mais je ne l'ai testé en 3.5 et plus)

Voici quelque chose de très simple qui fonctionne:

debug_logger: logging.Logger = logging.getLogger("app.debug")

def mydebuglog(msg: str, *args, **kwargs):
    if debug_logger.isEnabledFor(logging.DEBUG):
        debug_logger.debug(msg.format(*args, **kwargs))

Alors:

mydebuglog("hello {} {val}", "Python", val="World")