Python: Avertissements et limite de journalisation de la journalisation

Question

Je souhaite unifier l'ensemble de la fonction de journalisation de mon application. Tout avertissement est une exception, puis je l’attrape et le transmets à l’enregistreur. Mais la question: existe-t-il dans la journalisation une installation de mise en sourdine? Parfois, l'enregistreur devient trop bavard. Parfois, pour des avertissements trop bruyants, existe-t-il une limite verbeuse dans les avertissements?

http://docs.python.org/library/logging.html

http://docs.python.org/library/warnings.html

Answer 1

Non seulement il existe niveaux de consignation , mais il existe un vraiment manière de les configurer . Si vous utilisez des objets logger nommés (par exemple, logger = logging.getLogger (...) ), vous pouvez les configurer correctement. Cela vous permettra de configurer la verbosité pour chaque sous-système, un sous-système étant défini par la hiérarchie de journalisation.

L'autre option consiste à utiliser logging.Filter et Filtres d'avertissement pour limiter la sortie . Je n’avais jamais utilisé cette méthode auparavant, mais il semble que cela conviendrait mieux à vos besoins.

Donnez à PEP-282 une lecture pour une bonne description en prose de le package Python logging . Je pense qu'il décrit la fonctionnalité beaucoup mieux que la documentation du module.

Modifier après clarification

Vous pourrez peut-être gérer la partie journalisation de cette opération à l'aide d'une classe personnalisée basée sur logging.Logger et enregistrée avec logging.setLoggerClass () . On dirait vraiment que vous voulez quelque chose de similaire au "Dernier message répété 9 fois" de syslog. Malheureusement, je ne connais aucune implémentation de cela. Vous voudrez peut-être voir si twisted.python.log prend en charge cette fonctionnalité.

Answer 2

de la source même que vous avez mentionnée. il y a les niveaux de log, utilisez les à bon escient;)

LEVELS = {'debug': logging.DEBUG,
          'info': logging.INFO,
          'warning': logging.WARNING,
          'error': logging.ERROR,
          'critical': logging.CRITICAL}

Answer 3

Cela posera un problème si vous envisagez de passer tous les appels de journalisation à partir d’un gestionnaire d’erreur aveugle qui ne connaît rien du code qui a généré l’erreur, comme l’affirme votre question. Comment allez-vous décider quels appels de journalisation sont effectués et lesquels ne le sont pas?

La pratique la plus courante consiste à utiliser ces blocs pour récupérer, si possible, et consigner une erreur (vraiment, si c'est une erreur pour laquelle vous n'avez pas été préparé, vous voulez en savoir plus; utilisez un niveau élevé) . Mais ne comptez pas sur ces blocs pour toutes vos informations d'état / de débogage. Mieux vaut saupoudrer votre code avec les appels de journalisation avant qu’il ne parvienne au gestionnaire d’erreur. De cette façon, vous pouvez observer des informations utiles sur l’exécution d’un système lorsque celui-ci n’échoue PAS et vous pouvez effectuer des appels de consignation de gravité différente. Par exemple:

import logging
from traceback import format_exc
logger = logging.getLogger() # Gives the root logger.  Change this for better organization
# Add your appenders or what have you
def handle_error(e):
    logger.error("Unexpected error found")
    logger.warn(format_exc()) #put the traceback in the log at lower level
    ... #Your recovery code
def do_stuff():
    logger.info("Program started")
    ... #Your main code
    logger.info("Stuff done")
if __name__ == "__main__":
    try:
        do_stuff()
    except Exception,e:
        handle_error(e)