Comment s'entraîner à la journalisation en Python avec Logzero

Logzero est un package Python créé par Chris Hager qui simplifie la journalisation avec Python 2 et 3. Logzero facilite, en tant qu'instruction d'impression, l'affichage des informations et des détails de débogage.

Si vous vous demandez ce qu'est la journalisation, je vous recommande de lire l'article précédent que j'ai écrit sur « Comment exécuter des expériences d'apprentissage automatique avec le module de journalisation Python », en particulier les 3 premières sections.

Dans cet article, vous apprendrez :

Qu’est-ce que la journalisation ?
Pourquoi la journalisation est importante.
Applications de l'exploitation forestière dans différentes industries technologiques.

Logzero possède différentes fonctionnalités qui facilitent son utilisation dans les projets Python. Certaines de ces fonctionnalités sont :

Connexion facile à la console et/ou au fichier.
Fournit un objet enregistreur Python standard entièrement configuré.
Joli formatage, y compris des couleurs spécifiques au niveau dans la console.
fonctionne avec toutes sortes d’encodages de caractères et de caractères spéciaux.
Compatible avec Python 2 et 3.
Aucune autre dépendance Python.

Installation

Pour installer logzero avec pip, exécutez ce qui suit :

pip install -U logzero

Vous pouvez également installer logzero à partir du dépôt public Github :

git clone https://github.com/metachris/logzero.git
cd logzero
python setup.py install

Exemple de base

Nous commencerons par un exemple basique. Dans le fichier python, nous importerons l'enregistreur depuis logzero et essayerons 4 exemples de niveaux de journalisation différents.

#import logger from logzero
from logzero import logger

logger.debug("hello")
logger.info("info")
logger.warning("warning")
logger.error("error")

La sortie est colorée donc facile à lire.

Comme vous pouvez le constater, chaque niveau a sa propre couleur. Cela signifie que vous pouvez facilement identifier le niveau en vérifiant la couleur.

Écrire des journaux dans un fichier

La plupart du temps, les utilisateurs de Python ont tendance à écrire des journaux dans le fichier. Lorsque le système est en cours d'exécution, vous pouvez enregistrer les journaux dans le fichier et les consulter à des fins de vérification des erreurs et de maintenance. Vous pouvez également définir un fichier pour enregistrer toutes les entrées du journal dans legzero.

Nous importerons l'enregistreur et le fichier journal depuis logezero. La méthode du fichier journal nous aidera à configurer le fichier journal pour enregistrer nos entrées de journal.

Vos entrées de journal seront désormais enregistrées dans le fichier nommé my_logfile.log.

#import logger and logfile
from logzero import logger, logfile

#set logfile path
logfile('my_logfile.log')

# Log messages
logger.info("This log message saved in the log file")

La sortie dans my_logfile.log contient l'étiquette du niveau de journalisation (pour le niveau d'information étiqueté « I »), la date, l'heure, le nom du fichier python, le numéro de ligne et le message lui-même.

[I 200409 23:49:59 demo:8] This log message saved in the log file

Rotation d'un fichier journal

Vous n'avez pas besoin d'avoir un seul fichier journal enregistrant toutes les entrées du journal. Il en résulte un fichier journal volumineux dont l'ouverture et la fermeture du système nécessitent beaucoup de temps.

Vous pouvez utiliser les paramètres maxBytes et backupCount pour permettre au fichier de se déplacer à une taille prédéterminée. Lorsque la taille est sur le point d'être dépassée, le fichier est fermé et un nouveau fichier est ouvert silencieusement pour la sortie. Le basculement se produit chaque fois que le fichier journal actuel a une longueur proche de maxBytes. Si maxBytes ou backupCount est égal à zéro, le basculement ne se produit jamais.

Dans l'exemple ci-dessous, nous avons défini la valeur maxBytes sur 1 000 000 octets (1 Mo). Cela signifie que lorsque la taille dépasse 1 Mo, le fichier est fermé et un nouveau fichier est ouvert pour enregistrer les entrées du journal. Le nombre de sauvegardes à conserver est fixé à 3.

# Set a rotating logfile
logzero.logfile("my_logfile.log", maxBytes=1000000, backupCount=3)

Définir un niveau de journalisation minimum

Le niveau de journalisation signifie définir le niveau d'importance d'un message de journal donné. Vous pouvez également définir un niveau de journalisation différent pour le gestionnaire de fichiers en utilisant l'argument loglevel dans la méthode logfile.

Dans l'exemple ci-dessous, nous définissons le niveau de journalisation sur warning. Cela signifie que toutes les entrées de journal inférieures au niveau d'avertissement ne seront pas enregistrées dans un fichier journal.

#import logzero package
from logzero import logger, logfile
import logging

# You can also set a different loglevel for the file handler
logfile("my_logfile.log", loglevel=logging.WARNING)

# Log messages
logger.info("This log message saved in the log file")
logger.warning("This log message saved in the log file")

Définir un formateur personnalisé

La manière dont vous souhaitez que l'enregistrement du journal soit formaté dépend de vous. Il existe différentes manières de formater votre enregistrement de journal. Vous pouvez inclure la date, l'heure et le niveau de journalisation dans votre format afin de savoir quand le journal a été envoyé et à quel niveau.

L'exemple ci-dessous montre comment configurer le format des enregistrements de journal.

#import logzero package
import logzero
from logzero import logger, logfile
import logging

#set file path
logfile("my_logfile.log")

# Set a custom formatter
my_formatter = logging.Formatter('%(filename)s - %(asctime)s - %(levelname)s: %(message)s');
logzero.formatter(my_formatter)

# Log messages
logger.info("This log message saved in the log file")
logger.warning("This log message saved in the log file")

Dans l'exemple ci-dessus, nous avons configuré le format du journal en incluant le nom du fichier, la date, l'heure, le nom du niveau de journalisation et le message.

Voici le résultat dans my_logfile.log :

demo.py - 2020-04-10 00:51:44,706 - INFO: This log message saved in the log file
demo.py - 2020-04-10 00:51:44,707 - WARNING: This log message saved in the log file

Instances d'enregistreur personnalisées

Au lieu d'utiliser l'enregistreur par défaut, vous pouvez également configurer des instances d'enregistreur spécifiques avec logzero.setup_logger(..). Vous pouvez configurer et renvoyer une instance de journalisation entièrement configurée avec différents paramètres tels que nom, nom du fichier journal, formateur, maxBytes, backupCount et niveau de journalisation.

Voici un exemple pratique de configuration de la journalisation avec une instance d'enregistreur personnalisée :

import logzero package
from logzero import logger, logfile, setup_logger
import logging

# Set a custom formatter
my_formatter = logging.Formatter('%(filename)s - %(asctime)s - %(levelname)s: %(message)s');


#create custom logger instance
custom_logger = setup_logger(
 name="My Custom Logger",
 logfile="my_logfile.log",
 formatter=my_formatter,
 maxBytes=1000000,
 backupCount=3,level=logging.INFO)

# Log messages
custom_logger.info("This log message saved in the log file")
custom_logger.warning("This log message saved in the log file")

Dans l'exemple ci-dessus, nous avons défini une instance d'enregistreur personnalisée appelée custom_logger avec différentes valeurs de paramètres configurées.

Conclure

Dans cet article, vous avez appris les bases, ainsi que quelques exemples, sur la façon d'utiliser le package Logezero Python. Vous pouvez en savoir plus sur les fonctionnalités disponibles dans la documentation. Vous pouvez maintenant commencer à implémenter le package logzero dans votre prochain projet Python.

Si vous avez appris quelque chose de nouveau ou avez apprécié la lecture de cet article, partagez-le afin que d'autres puissent le voir. D’ici là, rendez-vous dans le prochain article ! Je suis également joignable sur Twitter @Davis_McDavid