Python journalisation plusieurs fichiers en utilisant le même enregistreur de données

C'est mon scénario: je veux ouvrir une session mon_module de l'activité. Ce qui doit être fait, selon la méthode exécutée (disons, d'ENTRÉE et de SORTIE), de deux fichiers différents.

J'ai donc deux Gestionnaires, chacun d'un point à un autre fichier (my_in_.log & my_out_.journal), avec le même niveau de journal. Je voudrais savoir si je peux utiliser le même enregistreur de données pour atteindre ce ou je dois définir des deux enregistreurs de frappe. Mon config est:

[loggers]
keys=root, my_log

[handlers]
keys=my_in_hand, my_out_hand

[formatters]
keys=generic_form


...


[logger_my_log]
level=NOTSET
handlers=my_in_hand, my_out_hand
qualname=ws_log

[handler_my_in_hand]
class=handlers.TimeRotatingFileHandler
level=NOTSET
formatter=generic_form
args=('my_in_.log', 'h', 1, 0, None, False, True)

[handler_my_out_hand]
class=handlers.TimeRotatingFileHandler
level=NOTSET
formatter=generic_form
args=('my_out_.log', 'h', 1, 0, None, False, True)

Dois-je définir un logger par gestionnaire et/ou de destination? (parce que je veux connecter les différentes informations dans des fichiers différents)
Est-il un moyen pour indiquer à l'enregistreur de données gestionnaire qui va le faire? Je veux dire, j'ai deux gestionnaires pour un bûcheron, puis choisissez qu'un seul gestionnaire de journal d'une méthode.

Merci beaucoup!

OriginalL'auteur Alberto Megía | 2013-03-04

  1. 7

    Vous devez instancier un Gestionnaire pour chaque destination, vous souhaitez envoyer votre journal, puis ajouter les 2 maîtres de votre enregistreur.
    Le suivant devrait fonctionner (ne pas le tester tout de même):

    logger = logging.getLogger()
handler1 = logging.TimedRotatingFileHandler()
handler2 = logging.TimedRotatingFileHandler()
logger.addHandler(handler1)
logger.addHandler(handler2)

    Bien sûr ajouter toute la configuration et les options de mise en forme, vous pourriez avoir besoin. Fondamentalement, c'est juste pour vous montrer que lorsque vous instanciez la journalisation handler, vous pouvez l'ajouter à l'enregistreur de données. À partir de ce moment, vos enregistrements de journal sera émise pour chaque gestionnaire ajouté à l'enregistreur de données.

    Peut-être que je ne suis pas clair: je ne veux pas le journal de mes dossiers à chaque handler ajouté à l'enregistreur de données. Ce que je veux, c'est pour sélectionner le gestionnaire de journal de l'enregistrement, qui est, un enregistreur -> deux gestionnaires, mais de choisir le dossier de destination qui sera attribuée. Réutiliser le même enregistreur de données avec les différents gestionnaires, mais certains dossiers seront enregistrées par un gestionnaire, et certains avec l'autre... Est-ce possible ou je dois définir d'autres logger? MERCI BEAUCOUP! 🙂
    Vous devez définir votre propre méthode qui prend en argument le journal de destination et utilise en interne le droit de gestionnaire pour le message de log.
    Donc @mike vous voulez dire que je dois ajouter et supprimer enregistreur de gestionnaire pour le sélectionner lors de l'exécution? Cela peut ne pas être ma meilleure option, car ce module est de mon point de vue frontal dans un service web... avec à chaque demande, je dois passer des gestionnaires... :S
    eh bien, puisque c'est une action fréquente, ajout/suppression de gestionnaires avant d'ouvrir une session, le message n'est pas la bonne approche (bien évidemment).
    Je suppose que dans ce cas, alors vous avez besoin de définir 2 enregistreurs avec 2 maîtres-chiens, un de chaque. de cette façon, vous pourrez garder des contextes séparés et clair

    OriginalL'auteur drekyn

  2. 3

    Finalement, j'ai décidé de définir des deux enregistreurs de frappe, parce que:

    • Pour différents purposses. Dans mon cas, l'un des journaux de demande d'entrée à un service web, et de l'autre les journaux de la réponse. Et ils utilisent différents fichiers

    • Je suis en utilisant un enregistrement de fichier de config, dans un choc frontal web service. Ajout/suppression de gestionnaires avant l'enregistrement de messages n'est pas la bonne approche, comme @mike dit. Merci à @drekyn trop!

    Voici mon fichier de configuration de la journalisation, juste pour la référence, si quelqu'un est intéressé par:

    [loggers]
keys=root, ws_in_log, ws_out_log

[handlers]
keys=consoleHandler, ws_in_hand, ws_out_hand

[formatters]
keys=generic_form

[logger_root]
handlers=consoleHandler
level=NOTSET

[logger_ws_in_log]
level=NOTSET
handlers=ws_in_hand
qualname=ws_in_log

[logger_ws_out_log]
level=NOTSET
handlers=ws_out_hand
qualname=ws_out_log

[handler_ws_in_hand]
class=logging.handlers.TimedRotatingFileHandler
level=NOTSET
formatter=generic_form
args=('/path/ws_in_.log', 'h', 1, 0, None, False, True)

[handler_ws_out_hand]
class=logging.handlers.TimedRotatingFileHandler
level=NOTSET
formatter=generic_form
args=('/path/em/ws_out_.log', 'h', 1, 0, None, False, True)

[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=generic_form
args=(sys.stdout,)

[formatter_generic_form]
format='%(asctime)s - %(levelname)s - %(message)s'
datefmt='%Y-%m-%d %H:%M:%S'
class=

    Vous voir!

    OriginalL'auteur Alberto Megía

  3. 3

    ce que vous voulez, c'est

    1. créer 2 NON RACINE de bûcherons.
    2. faire gestionnaire pour chacun, le point sur différents fichier

    3. ajouter un gestionnaire approprié enregistreur de

      logger1 = logging.getLogger('general_logger')
logger2 = logging.getLogger('some_other_logger')

log_handler1 = logging.handlers.RotatingFileHandler(file_1, *args)
log_handler2 = logging.handlers.RotatingFileHandler(file_2, *args)

logger1.addHandler(log_handler1)
logger2.addHandler(log_handler2)

    puis

        logger1.info("this will be logged to file_1 ")
    logger2.info("this will be logged to file_2 ")

    Veuillez noter que si vous créez une RACINE enregistreur et un autre enregistreur, de la racine de l'enregistreur de journal tout ce que cette autre contrôleur est d'essayer de se connecter.

    En d'autres termes, si

        root_logger = logging.getLogger()
    logger2 = logging.getLogger('some_other_logger')

    root_log_handler = logging.handlers.RotatingFileHandler(file_1, *args)
    log_handler2 = logging.handlers.RotatingFileHandler(file_2, *args)

    root_logger.addHandler(root_log_handler)
    logger2.addHandler(log_handler2)

    puis

        root_logger.info("this will be logged to file_1 ")
    logger2.info("this will be logged to file_1 AND file_2 ")

    OriginalL'auteur Denis Kanygin