logging – le module de journalisation Python

Le module logging en Python aide les développeurs à suivre les événements qui se produisent pendant l’exécution d’un programme, ce qui peut être utile pour le débogage. Il est recommandé d’utiliser le logging pour suivre le flux du code et pour résoudre les erreurs.

On utilise la journalisation pour collecter des informations et des données utiles. De plus, c’est l’une des fonctions les plus courantes pour les développeurs Web, non seulement pour détecter les erreurs, mais aussi pour collecter les données des utilisateurs telles que les adresses IP, qui peuvent être utilisées pour d’autres analyses commerciales.

Travailler avec le module logging

Le module de journalisation logging est une bibliothèque standard de Python, donc, nous n’avons pas à faire de configuration ou d’installation.

import logging

Voyons maintenant une démonstration de la façon dont nous pouvons enregistrer certains messages dans le terminal. Copiez simplement le code suivant dans votre IDE python et exécutez.

import logging 
logging.warning ("Ceci est un avertissement")

Exécution.

WARNING:root:Ceci est un avertissement

Le programme affiche un message d’avertissement. Le module logging a également d’autres niveaux de journalisation tels que les informations et les erreurs, pour nous faciliter la tâche.

Niveaux de journalisation Python

De nombreux niveaux de journalisation peuvent être utilisés pour différents niveaux de gravité. Les niveaux fournis par le module de journalisation python sont :

CRITIQUE
ERREUR
ATTENTION
INFO
DÉBOGUER
Ces niveaux sont indiqués dans l’ordre décroissant de leur gravité. Voyons comment utiliser ces niveaux dans notre programme. Copiez simplement le code suivant et exécutez-le.

logging.critical ("Ceci est un message critique") 
logging.error ("Ceci est un message d'erreur") 
logging.warning ("Ceci est un message d'avertissement") 
logging.info ("Ceci est un message d'information") 
logging.debug ("Ceci est un message de débogage")

Exécution.

CRITICAL:root:Ceci est un message critique
ERROR:root:Ceci est un message d'erreur
WARNING:root:Ceci est un message d'avertissement

Les messages DEBUG et INFO ne sont pas affichés dans le terminal, car le module logging, par défaut, n’affiche que les messages de niveau de sécurité supérieur ou égal à l’avertissement.

En fait, pour afficher INFO et DEBUG dans le terminal, nous devons modifier manuellement la configuration de base. Pour ce faire, nous pouvons utiliser la méthode basicConfig (**kwargs). Pour voir une simple démonstration de configuration, exécutez simplement le code suivant :

import logging 

logging.basicConfig (level = logging.DEBUG) 
logging.critical ("Ceci est un message critique") 
logging.error ("Ceci est un message d'erreur") 
logging.warning ("Ceci est un message d'avertissement") 
logging.info ("Ceci est un message d'information") 
logging.debug ("Ceci est un message de débogage")

Dans le code ci-dessus, nous avons défini le niveau de logging.DEBUG, ce qui signifie que tous les niveaux qui sont au-dessus du niveau de débogage seront enregistrés. Ainsi, dans le code ci-dessus, tous les messages seront enregistrés.

CRITICAL:root:Ceci est un message critique
ERROR:root:Ceci est un message d'erreur
WARNING:root:Ceci est un message d'avertissement
INFO:root:Ceci est un message d'information
DEBUG:root:Ceci est un message de débogage

Voyons en détail le fonctionnement de la méthode basicConfig().

Configurations de base du module logging

Le module fournit une méthode très utile basicConfig (** Kwargs), qui est utilisée pour définir les configurations de journalisation des données. Certains des paramètres couramment utilisés de la fonction basicConfig () sont :

level : utilisé pour définir le niveau de gravité, qui doit être enregistré.
filename : pour spécifier le fichier dans lequel nous voulons enregistrer les messages. Si nous ne définissons pas le fichier, il sera enregistré dans le terminal, comme nous l’avons vu jusqu’à présent.
filemode : pour écrire les journaux dans un fichier.

Ces paramètres acceptent le mode dans lequel le fichier journal doit être ouvert. Par défaut, il est défini sur le mode «a», ce qui signifie que le fichier s’ouvrira en mode ajout.

format : pour formater le message du journal tel que nous en avons besoin pour l’afficher.

Voyons comment nous pouvons utiliser ces configurations.

Le paramètre level est utilisé pour définir le niveau de gravité.

import logging

logging.basicConfig (level = logging.INFO)
logging.critical ("Ceci est un message critique")
logging.error ("Ceci est un message d'erreur")
logging.warning ("Ceci est un message d'avertissement")
logging.info ("Ceci est un message d'information")
logging.debug ("Ceci est un message de débogage")

Exécution.

CRITICAL:root:Ceci est un message critique
ERROR:root:Ceci est un message d'erreur
WARNING:root:Ceci est un message d'avertissement
INFO:root:Ceci est un message d'information

Comme vous pouvez le constater, les messages qui sont au-dessus des niveaux d’informations sont affichés, mais le message au niveau de débogage ne s’affiche pas.

Connexion à un fichier

La meilleure méthode est d’enregistrer les journaux dans un fichier texte que nous sauvegardons et analysrons plus tard. Cependant, il est universellement adopté d’enregistrer les journaux dans un fichier avec l’extension .log. Ces fichiers sont connus sous le nom de fichiers journaux et sont utilisés pour stocker les journaux des programmes, des applications Web et d’autres logiciels.

Nous pouvons enregistrer les journaux dans un fichier en utilisant la fonction basicConfig(). Nous devons définir le nom du fichier où nous voulons enregistrer les journaux dans le paramètre filename de la fonction basicConfig(), après quoi les enregistrements seront automatiquement reportés dans le fichier journal que nous spécifions.

import logging

logging.basicConfig (level = logging.INFO, filename = "mylog.log")
logging.critical ("Ceci est un message critique")
logging.error ("Ceci est un message d'erreur")
logging.warning ("Ceci est un message d'avertissement ")
logging.info (" Ceci est un message d'information ")
logging.debug (" Ceci est un message de débogage ")

Lors de l’exécution du code, vous pouvez voir qu’un nouveau fichier mylog.log a été créé dans le répertoire de travail actuel. Lors de l’ouverture du fichier avec un éditeur de texte, vous remarquerez peut-être que les journaux ont été enregistrés dans le fichier.

Si nous exécutons encore le code, nous verrons que le journal sera ajouté au fichier. Nous pouvons changer cela en spécifiant le paramètre filemode dans la fonction basiconfig(). Par défaut, le paramètre filemode est défini sur «a», ou append qui signifie ajouter. Mais parfois, nous voulons également supprimer les données précédemment enregistrées et écrire de nouveaux journaux. Pour ce faire, nous pouvons donner au paramètre filemode la valeur «w», qui signifie écriture.

Formatage des journaux

Voyons un exemple pour voir comment utiliser le paramètre format dans la fonction basicConfig() pour changer le format du journal.

import logging

logging.basicConfig (level = logging.INFO, format = '%(filename)s: %(levelname)s: %(message)s')
logging.critical ("Ceci est un message critique")
logging.error ( "Ceci est un message d'erreur")
logging.warning ("Ceci est un message d'avertissement")
logging.info ("Ceci est un message d'information")
logging.debug ("Ceci est un message de débogage")

Exécution.

test.py: CRITICAL: Ceci est un message critique
test.py: ERROR: Ceci est un message d'erreur
test.py: WARNING: Ceci est un message d'avertissement
test.py: INFO: Ceci est un message d'information

Comme vous pouvez le voir dans la sortie, le nom du fichier a également été affiché. Nous pouvons utiliser le paramètre format pour indiquer de nombreux autres formats.

% (asctime)s : utilisé pour afficher l’heure de lecture humaine dans les journaux. Pour voir comment il affiche l’heure, exécutez le code suivant :

import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s : %(message)s')
logging.warning("Ceci est un message d'avertissement")

Lors de l’exécution du code, vous pouvez voir la sortie, comme indiqué ci-dessous.

2021-02-05 03:54:35,240 : Ceci est un message d'avertissement

%(created)f : affiche l’heure à laquelle le journal est créé.

%(filename)s : pour afficher le nom du fichier dans le message du journal. Exécutez le code suivant :

import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s : %(filename)s : %(message)s')
logging.warning("Ceci est un message d'avertissement")

Dans la sortie, le nom du fichier a été affiché. Ceci est utile lorsque vous travaillez sur un projet impliquant plusieurs fichiers afin que nous puissions obtenir rapidement le fichier contenant l’erreur.

2021-02-05 04:00:09,210 : test.py : Ceci est un message d'avertissement

%(levelname)s : afficher le nom du niveau utilisé comme WARNING, DEBUG, etc.

%(levelno)s : pour afficher la valeur numérique du niveau dont le message fait partie.

%(lineno)d : utilisé pour afficher le numéro de la ligne actuelle du message. C’est très utile pour connaître le numéro de la ligne où nous devons voir l’erreur, ce qui facilite le processus de débogage.

import logging
Format = '%(asctime)s : %(filename)s:%(lineno)d: %(message)s'
logging.basicConfig(level=logging.INFO, format= Format)
logging.warning("C'est un message d'avertissement")

Ce code affichera également le numéro de la ligne.

2021-02-05 04:03:49,104 : test.py:4: C'est un message d'avertissement

%(message)s : utilisé pour afficher le message que nous avons enregistré.

%(pathname)s : pour afficher le chemin complet du fichier du code source.

%(process)d : affiche l’ID du processus si disponible.

%(processname)s : affiche le nom du processus s’il est disponible.

%(thread)d : pour afficher l’ID du thread si disponible.

%(threadName)s : afficher le nom du thread s’il est disponible.

Journalisation des données variables

Nous avons donné les messages dans les journaux par nous-mêmes, qui sont des données statiques. Pourtant, dans les applications du monde réel, les données que nous avons enregistrées seront principalement des informations dynamiques de notre application. En fait, nous devons générer les variables avec le journal des messages. Nous pouvons le faire de plusieurs manières.

Par exemple, nous pouvons inclure les variables et formater la chaîne avec des espaces réservés, puis les transmettre au journal des messages afin que les valeurs des variables soient affichées dans les enregistrements.

Par exemple, exécutez le code ci-dessous.

import logging
var_message = "internal Error"
logging.warning(f"The server has been stopped due to {var_message}")

Comme vous pouvez le voir, la valeur stockée dans la variable est également affichée.

WARNING:root:Le serveur a été arrêté en raison de internal Error

Journalisation des traces de pile

Le module logging peut également être utilisé pour capturer des traces de pile. Les traces de pile sont les messages d’exception qui sont émis lorsqu’une erreur s’est produite dans le programme. Nous pouvons capturer l’exception en définissant le paramètre exc_info sur True lors de l’appel de la fonction de journalisation. Ce paramètre est utile, car nous pouvons enregistrer le message d’exception complet avec notre message d’erreur dans un fichier ou un écran de terminal.

import logging
try:
    a = 1/0
except Exception as e:
    logging.error("An Error has been Occured", exc_info=True)

Lors de l’exécution du code, l’exception sera enregistrée dans le terminal. Vous verrez la sortie du code, comme indiqué ci-dessous. Vous pouvez également enregistrer l’exception dans un fichier en utilisant le paramètre filename dans la méthode basicConfig(), comme nous l’avons vu ci-dessus.

ERROR:root:An Error has been Occured
Traceback (most recent call last):
  File "/home/henke/test.py", line 3, in <module>
    a = 1/0
ZeroDivisionError: division by zero

Cette méthode est également essentielle dans la construction d’une grande application, car nous pouvons gérer les exceptions avec la journalisation, ce qui est excellent pour le processus de débogage.

Les objets de journalisation avec le module logging

Le module fournit également des classes utiles qui peuvent être utilisées pour une meilleure journalisation, principalement pour une application plus importante. Voyons quelques-unes des classes les plus utilisées.

Loggers : les objets sont utilisés pour appeler directement les fonctions.
Handlers : pour envoyer les messages du journal à l’emplacement de sortie souhaité, c’est-à-dire un fichier ou une console.
Filters : utilisé pour filtrer l’affichage des enregistrements du journal.
Formatters : pour formater la sortie des messages des journaux.

Dans cet article, nous avons appris les bases de la journalisation en python. Le module logging est un moyen simple et puissant. Donc, désormais vous pouvez utiliser facilement la journalisation dans vos applications Python.

Je vous conseille de commencer à utiliser cet outil avec les petits programmes, car cela vous aidera à avoir une bonne base avant de s’attaquer à de grands projets.