Python - Comment vider le journal? (django)

Je travaille avec Django-nonrel sur Google App Engine, qui m'oblige à utiliser la journalisation.debug() au lieu de print().

La "journalisation" module est fourni par Django, mais je vais avoir un moment difficile de l'utiliser au lieu de les imprimer().

Par exemple, si j'ai besoin de vérifier le contenu dans la variable x, je vais mettre

logging.debug('x is: %s' % x). Mais si le programme est en panne peu de temps après (sans chasse d'eau, le flux de données), alors il n'est jamais imprimé.

Donc pour le débogage, j'ai besoin de debug() pour être vidées avant que le programme des sorties en cas d'erreur, et ce n'est pas le cas.

  • pas de réponse à votre question, mais pourquoi voudriez-vous utiliser print de toute façon?!
  • Que voulez-vous dire exactement par "rinçage" le journal?
  • Espérons que l'exemple ci facilite la compréhension.
  • Je voudrais essayer quelque chose comme le AdminEmailHandler journalisation gestionnaire pour des cas spécifiques comme votre exemple. Un enregistrement de base de données gestionnaire serait le meilleur choix, vous ne savez pas si il y en a Sentry alternative là-bas.
  • Peut-être pas la bonne, mais cela fonctionne pour moi.Espérons que cela aide quelqu'un. J'ai essayé en utilisant la méthode flush (), mais ne fonctionne pas. Comme je l'ai sortie de mon application en utilisant sys.sortie(..), j'ai créé une méthode wrapper(exit()) autour d'elle...qui attendaient 1 seconde(time.sleep(1)) avant de quitter l'Application. Je suis également de contracter une erreur inattendue et appelant exit() méthode. Ce délai semble flushout en attente des messages de log
InformationsquelleAutor Rucent88 | 2012-11-01
  1. 13

    Je pense que cela peut fonctionner pour vous, en supposant que vous êtes seulement en utilisant une(ou par défaut) gestionnaire:

    >>> import logging
>>> logger = logging.getLogger()
>>> logging.debug('wat wat')
>>> logger.handlers[0].flush()

    C'est assez mal vu dans la documentation, si.

    Le code de l'Application ne doit pas instancier directement et utiliser des instances de Gestionnaire. Au lieu de cela, le Gestionnaire de classe est une classe de base qui définit l'interface que tous les gestionnaires doivent avoir et établit certains comportement par défaut que les classes enfant peut utiliser (ou remplacer).
    http://docs.python.org/2/howto/logging.html#handler-basic

    Et il pourrait être une performance de vidange, mais si vous êtes vraiment coincé, cela peut vous aider dans votre débogage.

    • Euh, comment awre gens censés de rincer leurs journaux, si le seul moyen est de passer par un gestionnaire que vous n'êtes pas censé accès? Que les sons cassés.
    • Non, ce n'est pas du tout ce que dit la documentation. La citation ci-dessus signifie que vous ne devez instancier et utiliser des sous-classes de Gestionnaire, au lieu de Gestionnaire directement. Votre code n'utilise le gestionnaire de classes sont déjà instancié par quelqu'un d'autre, il n'y a pas de problème.
    • Très utile en effet; je trouve toujours ça très étrange que je ne suis pas en mesure de dire stupide logger dans sa config qu'il est toujours chasse; mais que mon code client de la faire respecter.
    • Il retourne "hors de portée". J'ai initialisé, l'enregistreur de données à l'aide d'un .fichier ini avec deux gestionnaires. la journalisation.hasHandlers() renvoie la valeur true. enregistreur.les gestionnaires d'[0].flush() IndexError: list index out of range
    InformationsquelleAutor Mike Shultz
  2. 9

    Si le cas est que vous avez un programme en python qui doit vider ses journaux lors de la sortie, utilisez logging.shutdown().

    De la documentation python:

    de journalisation.shutdown()

    Informe le système de connexion pour effectuer une ordonnée
    arrêt par le rinçage et la fermeture de tous les gestionnaires. Ce doit être appelé
    à la fermeture de l'application et de ne plus utiliser le système d'enregistrement doit être
    après cette appel.

    InformationsquelleAutor Risadinha
  3. 7

    J'ai lutté avec un problème similaire, et voici comment je l'ai résolu. Au lieu d'utiliser logging module directement à la sortie de vos journaux, initialiser votre propre enregistreur comme suit:

    import sys
import logging


def init_logger():
    logger = logging.getLogger()

    h = logging.StreamHandler(sys.stdout)
    h.flush = sys.stdout.flush
    logger.addHandler(h)

    return logger

    Ensuite, utilisez à la place de logging dans votre code:

    def f():
    logger = init_logger()
    logger.debug('...')

    Comme un résultat, vous n'aurez pas de problèmes avec le rinçage des journaux plus.

    InformationsquelleAutor constt
  4. 5

    Django exploitation forestière s'appuie sur le standard de python module de journalisation.

    Ce module est un module au niveau de la méthode: logging.shutdown() qui nettoie tous les gestionnaires et arrête le système de journalisation (c'est à dire la journalisation ne peut plus être utilisé après il est appelé)

    Inspectant le code de cette fonction montre qu'actuellement (python 2.7) le module de journalisation, contient une liste de références faibles à tous les gestionnaires d'une variable de niveau module appelé _handlerList de sorte que tous les gestionnaires peuvent être vidées en faisant quelque chose comme

    [h_weak_ref().flush() for h_weak_ref in logging._handlerList]

    parce que cette solution utilise les données internes du module @Mikes solution ci-dessus est la meilleure, mais qu'elle s'appuie sur l'accès à un enregistreur, il peut être schématisée comme suit:

     [h.flush() for h in my_logger.handlerList]
    InformationsquelleAutor tjb