Le logger Python

La séparation de logs est quelque chose de commun en informatique. Il ne s'agit ni plus ni moins que d'isoler les différents niveaux dans des fichiers distincts. En sortie nous aurons alors un fichier critical.log, error.log, warning.log…

Le but est de compartimenter les messages afin d'en faciliter le traitement. Cette solution possède néanmoins un inconvénient de taille : si vous désirez mieux comprendre le déroulement des opérations ayant entraîné l'anomalie, vous êtes obligé de jouer avec plusieurs logs au lieu d'un seul.

En contrepartie, si vous ne désirez analyser qu'un seul niveau en particulier, alors cela vous facilitera la tâche.

Nous allons aborder ici la forme complète de logging pour la première fois. Avant toute chose, le code.

import logging


formatter = logging.Formatter("%(asctime)s -- %(name)s -- %(levelname)s -- %(message)s")

handler_critic = logging.FileHandler("critic.log", mode="a", encoding="utf-8")
handler_info = logging.FileHandler("info.log", mode="a", encoding="utf-8")

handler_critic.setFormatter(formatter)
handler_info.setFormatter(formatter)

handler_info.setLevel(logging.INFO)
handler_critic.setLevel(logging.CRITICAL)

logger = logging.getLogger("nom_programme")
logger.setLevel(logging.INFO)
logger.addHandler(handler_critic)
logger.addHandler(handler_info)

logger.debug('Debug error')
logger.info('INFO ERROR')
logger.critical('INFO ERROR2')

Tout d'abord, l'import qui ne change pas, et se passe de tout commentaire.

Vient ensuite, l'objet « Formatter ». Cet objet permet de définir le format désiré pour les messages. Nous reprenons le même format que dans notre exemple précédent, et ce pour tous les logs de sortie.

Nous créons ensuite deux handlers, un par fichier, pour le log critic, et un pour le log de type INFO. Nous leur passons le nom du fichier de sortie, le mode d'écriture et le type d'encodage à utiliser.

Ensuite, nous leur précisons le format des messages à utiliser. Dans notre cas il s'agira de l'objet Formatter précédemment créé.

Après cela, nous fixons leur niveau respectif de sensibilité.

Puis nous créons un objet de type logger en lui assignant un nom, un niveau minimal de sensibilité, et en le liant aux deux handlers précédemment créés.

Pour rappel, les handlers correspondent à la sortie des logs, et le logger à l'entrée, côté programme.

Enfin, les trois dernières lignes permettent de transmettre des messages de logs.

Copiez-collez ce code et exécutez-le. Analysons les fichiers de sortie.

Tout d'abord, nous remarquerons l'existence effective de deux fichiers, nommés critic.log et info.log.

Ensuite, nous constaterons que le code nous a permis de choisir dans quel fichier écrire telle ou telle info, en indiquant tout simplement dans quel logger nous désirions écrire.

Enfin, nous pouvons voir que tout niveau inférieur au seuil défini n'est toujours pas loggé, mais que les niveaux supérieurs le sont bien.

Nous avons ainsi effectué simplement une séparation de log en disposant d'un point d'entrée (logger) unique.

La rotation de logs est quelque chose de très utile et très usité. Il tombe sous le sens de chacun de nous que lorsqu'un fichier de log, un fichier texte rappelons-le, devient trop gros, il peut vite devenir difficile à ouvrir, exploiter, communiquer à un tiers…

Dans un tel cas, le plus simple nous dirons-nous est de commencer un nouveau fichier. Cela est effectivement une solution. Et c'est justement pour l'automatiser qu'existe la rotation de log. Quand notre fichier aura atteint une certaine taille, ou après un certain temps écoulé, notre log sera renommé avec un numéro en fin de nom, et un nouveau fichier sera alors créé.

import logging
from logging.handlers import RotatingFileHandler


formatter_debug = logging.Formatter("%(asctime)s -- %(name)s -- %(levelname)s -- %(message)s")
formatter_info = logging.Formatter("%(asctime)s -- %(name)s -- %(levelname)s -- %(message)s")

logger_debug = logging.getLogger("debug_log")
handler_debug = logging.handlers.RotatingFileHandler("debug.log", mode="a", maxBytes= 100, backupCount= 1 , encoding="utf-8")
handler_debug.setFormatter(formatter_debug)
logger_debug.setLevel(logging.DEBUG)
logger_debug.addHandler(handler_debug)

logger_info = logging.getLogger("info_log")
handler_info = logging.handlers.RotatingFileHandler("info.log", mode="a", maxBytes= 10, backupCount= 1,encoding="utf-8")
handler_info.setFormatter(formatter_info)
logger_info.setLevel(logging.INFO)
logger_info.addHandler(handler_info)

logger_debug.debug('Debug error')
logger_info.debug('DEBUG ERROR')
logger_info.info('INFO ERROR')
logger_info.critical('INFO ERROR2')

Nous allons ici nous concentrer sur les modifications. Tout d'abord l'import. En effet nous devons importer les nouveaux handlers utilisés directement.

Ensuite à la création des handlers, nous précisons notre nouvel handler en lui passant des arguments : nom, mode, taille maximale (maxBytes), valeur de départ pour la numérotation (backupcount), encodage utilisé.

Nous noterons ici la valeur faible de la taille maximale du fichier. Elle est réglée exprès pour que vous puissiez constater le fonctionnement. Nous noterons aussi que la découpe s'effectue en termes de lignes. Ainsi une ligne de log sera entièrement renseignée et seulement après, le log sera sauvegardé.

import logging
from logging.handlers import TimedRotatingFileHandler
import time


formatter_debug = logging.Formatter("%(asctime)s -- %(name)s -- %(levelname)s -- %(message)s")
formatter_info = logging.Formatter("%(asctime)s -- %(name)s -- %(levelname)s -- %(message)s")

logger_debug = logging.getLogger("debug_log")
handler_debug = logging.handlers.TimedRotatingFileHandler("debug.log", when="s", interval=5, encoding="utf-8")
handler_debug.setFormatter(formatter_debug)
logger_debug.setLevel(logging.DEBUG)
logger_debug.addHandler(handler_debug)

logger_info = logging.getLogger("info_log")
handler_info = logging.handlers.TimedRotatingFileHandler("info.log", when="s", interval=5, encoding="utf-8")
handler_info.setFormatter(formatter_info)
logger_info.setLevel(logging.INFO)
logger_info.addHandler(handler_info)

logger_debug.debug('Debug error')
logger_info.debug('DEBUG ERROR')
logger_info.info('INFO ERROR')
time.sleep(7)
logger_info.critical('INFO ERROR2')

Ici nous utilisons un handler qui permet de sauvegarder les logs non pas quand ils ont atteint une certaine taille, comme le précédent, mais au bout d'un certain temps.

Les deux arguments dédiés sont « when » qui permet de stipuler l'unité d'« interval ». When peut être au choix : S, M, H, D, W0 (pour lundi) à W6 (pour dimanche), midnight (00:00:00).

Dans notre exemple, un nouveau log est créé toutes les cinq secondes.