Message PyLint: interpolation-format-de-journalisation

Pour le code suivant:

logger.debug('message: {}'.format('test'))

pylint produit l'avertissement suivant:

interpolation-format-de-journalisation (W1202):

Utilisez le formatage% dans les fonctions de journalisation et transmettez les paramètres% en tant qu'arguments Utilisé lorsqu'une instruction de journalisation a une forme d'appel de «journalisation. (Format_string.format (format_args ...))». De tels appels devraient utiliser le formatage% à la place, mais laisser l'interpolation à la fonction de journalisation en passant les paramètres comme arguments.

Je sais que je peux désactiver cet avertissement, mais j'aimerais le comprendre. J'ai supposé que l'utilisation format()était la meilleure façon d'imprimer des instructions en Python 3. Pourquoi n'est-ce pas vrai pour les instructions de journalisation?

Ce n'est pas vrai pour l'instruction logger car elle s'appuie sur l'ancien format "%" comme string pour fournir une interpolation paresseuse de cette chaîne en utilisant des arguments supplémentaires donnés à l'appel du logger. Par exemple au lieu de faire:

logger.error('oops caused by %s' % exc)

tu devrais faire

logger.error('oops caused by %s', exc)

donc la chaîne ne sera interpolée que si le message est effectivement émis.

Vous ne pouvez pas bénéficier de cette fonctionnalité lors de l'utilisation .format().

Selon la section Optimisation de la loggingdocumentation:

Le formatage des arguments de message est différé jusqu'à ce qu'il ne puisse pas être évité. Cependant, le calcul des arguments passés à la méthode de journalisation peut également être coûteux, et vous voudrez peut-être éviter de le faire si l'enregistreur va simplement rejeter votre événement.

Peut-être que cette différence de temps peut vous aider.

La description suivante n'est pas la réponse à votre question, mais elle peut aider les gens.

Pour pylint 2.4: Il y a 3 options pour le style journalisation dans le .pylintrcfichier: old, new,fstr

fstroption ajoutée en 2.4 et supprimée en 2.5

Description du .pylintrcfichier (v2.4):

[LOGGING]

# Format style used to check logging format string. `old` means using %
# formatting, `new` is for `{}` formatting,and `fstr` is for f-strings.
logging-format-style=old

pour l' ancien ( logging-format-style=old):

foo = "bar"
self.logger.info("foo: %s", foo)

pour nouveau ( logging-format-style=new):

foo = "bar"
self.logger.info("foo: {}", foo)
# OR
self.logger.info("foo: {foo}", foo=foo)

Remarque : vous ne pouvez pas utiliser .format()même si vous sélectionneznew option.

pylint donne toujours le même avertissement pour ce code:

self.logger.info("foo: {}".format(foo))  # W1202
# OR
self.logger.info("foo: {foo}".format(foo=foo))  # W1202

pour fstr ( logging-format-style=fstr):

foo = "bar"
self.logger.info(f"foo: {foo}")

Personnellement, je préfère l'option fstr à cause de PEP-0498 .

D'après mon expérience, une raison plus convaincante que l'optimisation (pour la plupart des cas d'utilisation) de l'interpolation paresseuse est qu'elle joue bien avec les agrégateurs de journaux comme Sentry.

Considérez un message de journal «utilisateur connecté». Si vous interpolez l'utilisateur dans la chaîne de format, vous avez autant de messages de journal distincts que d'utilisateurs. Si vous utilisez une interpolation paresseuse comme celle-ci, l'agrégateur de journaux peut plus raisonnablement interpréter cela comme le même message de journal avec un tas d'instances différentes.