Django Logging

Tous les développeurs déboguent les erreurs. La résolution de ces erreurs prend du temps. Il est utile dans la plupart des cas de savoir quand et où l’erreur s’est produite. Je dirais que les messages d’erreur de Python sont assez utiles. Mais même ces messages deviennent inutiles lorsqu’il s’agit de projets comportant plusieurs fichiers. Ce problème et de nombreux autres avantages viennent avec la journalisation.

En tant que développeurs Django, il est important que nous maîtrisions également la journalisation. Les technologies backend ont divers outils formidables pour mettre en œuvre la journalisation. Django aussi fournit un support pour divers frameworks et modules de journalisation. Nous allons l’implémenter en utilisant le module de base et l’un des plus populaires, le module de journalisation.

Dans ce tutoriel, nous allons apprendre la journalisation. Le contenu sera :

• Qu’est-ce que la journalisation ?
• Module de journalisation Python
• Logging dans Django

Prêts à apprendre. Commençons.

Qu’est-ce que la journalisation ?

La journalisation est une technique ou un moyen qui peut nous permettre de suivre certains événements lors de l’exécution du logiciel. C’est une technique importante pour les développeurs. Elle les aide à suivre les événements. La journalisation est comme une paire d’yeux supplémentaire pour eux. Les développeurs ne sont pas seulement responsables de la création de logiciels, mais aussi de leur maintenance. La journalisation aide énormément à cette partie de la maintenance.

Elle suit chaque événement qui se produit à tout moment. Cela signifie qu’au lieu des longs traçages, vous obtenez beaucoup plus. Cette fois, lorsqu’une erreur se produit, vous pouvez voir dans quelle situation se trouvait le système. Cette méthode vous aidera à résoudre les erreurs rapidement. Comme vous serez en mesure de dire où l’erreur s’est produite.

Comment cela fonctionne-t-il ? Quelle est l’idée derrière cela ?

La journalisation est gérée par un programme séparé. Ce programme de journalisation est simplement un rédacteur de fichiers. On dit que le logger enregistre certains événements au format texte. Les informations enregistrées sont ensuite sauvegardées dans des fichiers. Ces fichiers s’appellent des journaux. Les journaux sont de simples fichiers enregistrés avec l’extension log. Ils contiennent les journaux des événements survenus.

Bien, ce n’est qu’une des implémentations les plus utilisées, comme vous pouvez le voir. Puisque nous ne faisons que stocker l’information, vous pouvez trouver d’autres façons de la traiter.

Ok, il est clair pour nous que la journalisation est importante. Est-ce difficile ? Non, absolument pas, mon pote. La journalisation n’est pas difficile du tout. Toute personne qui connaît un peu la configuration peut l’utiliser.

Etant un programmeur Python, vous avez des fonctionnalités supplémentaires ici aussi. Nous avons un module entier qui nous permet d’accomplir exactement cela. Quant aux autres langages, il existe de nombreux modules, Java a Log4j et JavaScript a son propre loglevel. Tous ces outils sont également étonnants. Bon, nous allons donc traiter ici avec Python (mon langage préféré).

Module de journalisation en Python

Le module de journalisation est un module Python intégré. Il est livré préinstallé avec Python 3. Le module de journalisation est utilisé pour garder une trace des événements qui se produisent lors de l’exécution du programme. Cela peut être étendu à un nombre quelconque de programmes et donc pour les logiciels, il est facile à mettre en place et à utiliser.

Pourquoi utiliser le module de journalisation ?

En tant que développeur, on peut se demander pourquoi utiliser le module de journalisation. Tout ce que fait le logging est d’écrire dans un fichier ou de l’imprimer sur la console. Tout cela peut être réalisé en utilisant les instructions print. Alors quel est le besoin d’un module de journalisation ? C’est une bonne question. La réponse à cela est que la journalisation est un module qui donne ce que print ne peut pas.

Nous utilisons la fonction print pour sortir quelque chose sur la console. Ainsi, quand une fonction se produit, nous pouvons obtenir une déclaration print que la fonction a exécuté. Bien que cette approche fonctionne avec de petites applications, elle est inefficace.

La fonction print devient une partie de votre programme et si le logiciel cesse de fonctionner, vous n’aurez pas le résultat. De plus, si quelque chose se produit et que le système redémarre, la console est également effacée. Alors, que ferez-vous ? La réponse à cela est le module de journalisation.

Le module de journalisation est capable de :

• Exécution multithreading
• Catégorisation des messages via différents niveaux de journalisation
• C’est beaucoup plus flexible et configurable
• Donne une information plus structurée

Donc, il y a 4 parties principales du module de journalisation. Nous allons les examiner une par une.

1. Loggers

Les loggers sont les objets avec lesquels les développeurs traitent. Ils peuvent être compris comme une fonction qui sera invoquée lorsqu’ils seront appelés. Nous utilisons les loggers dans nos fichiers de projet. Ainsi, lorsque la fonction est invoquée, nous obtenons un rapport détaillé. Le logger peut générer plusieurs niveaux de réponses. Nous pouvons le personnaliser au maximum.

2. Handlers

Les handlers sont les objets qui émettent l’information. Pensez à eux comme à des manipulateurs de journaux. Leur tâche principale est de transmettre l’information. Cela peut être réalisé en écrivant l’info dans un fichier journal (Le comportement par défaut). Il existe divers gestionnaires fournis par le module de journalisation.

Nous pouvons facilement configurer plusieurs gestionnaires pour le même journal. Il existe également des gestionnaires SMTP qui vous enverront par courrier les enregistrements du journal. Les handlers contiennent généralement une logique d’entreprise pour la journalisation des informations.

3. Formateurs

Les formateurs sont ceux qui formatent les données. Vous voyez les handlers ne peuvent pas envoyer l’information car c’est un type de données Python. Avant de pouvoir l’envoyer à qui que ce soit, il faut la convertir.

Les logs sont par défaut au format Log Records. C’est la classe prédéfinie par le framework de journalisation. Elle donne différentes méthodes aux développeurs pour les utiliser. Ce format ne peut pas être directement envoyé sur un réseau ou écrit dans un fichier texte. Pour le convertir ou le formater, nous avons besoin de formateurs. Il existe différents formateurs pour différents handlers.

Par défaut, les formateurs vont convertir l’enregistrement du journal en String. Ce comportement peut être facilement modifié et vous pouvez le personnaliser comme vous le souhaitez. Ce format peut être basé sur la logique métier que nous écrivons dans les Handlers.

4. Filtres

La dernière pièce du module de journalisation est les filtres. Les filtres, comme leur nom l’indique, filtrent les messages. Tous les messages que nous passons n’ont pas besoin d’être stockés ou transportés. Ou bien il peut y avoir différents gestionnaires pour différents messages. Tout cela est réalisable avec l’aide des filtres.

Nous pouvons utiliser les filtres avec les loggers et les handlers.

Ok, donc maintenant nous avons une idée de base du module de journalisation. Il nous fournit également des niveaux de messages. Les niveaux de messages sont définis comme:

DEBUG : C’est une information système verbeuse lorsque tout fonctionne bien. Il vous donnera des détails plus précis sur l’état du système. Son point de gravité est de 10.

INFO : L’info produira des informations système moins verbeuses mais est similaire au débogage. Il indique généralement un aperçu de ce que le système exécute. Son point de gravité est 20.

WARNING : Il contient des informations concernant des problèmes de bas niveau. Ces problèmes peuvent être ignorés car ils ne provoquent pas l’arrêt du système. Bien que, il est recommandé que ces problèmes doivent être résolus.

Son point de gravité est 30.

ERROR : Ce message est sérieux. L’erreur contiendra des informations sur le problème majeur qui s’est produit. Le problème peut avoir arrêté le fonctionnement du programme et nécessite une attention immédiate.

Son point de gravité est 40.

CRITIQUE : Le message le plus critique. Ce message est émis lorsque le problème a provoqué l’arrêt du système. Cela signifie que toute l’application s’est arrêtée à cause de ce problème.

Son point de gravité est 50.

Le point de gravité détermine quelle priorité doit être donnée. Supposons que nous définissions le niveau de journalisation à 30. Alors, l’enregistreur enregistrera ou stockera les informations lorsque le niveau est supérieur ou égal à 30. Il vous suffit donc de confirmer le niveau de journalisation que vous souhaitez. Nous en apprendrons davantage à leur sujet dans la section suivante.

Nous pouvons facilement mettre en œuvre la journalisation en important le module. Comme c’est un module intégré, nous n’avons pas besoin de l’installer via pip.

Il suffit d’écrire ceci dans votre fichier Python et nous pouvons utiliser les loggers.

Code:

import logginglogging.warning("DataFlair Logging Tutorials")

La sortie générée par le code est juste en dessous. Comme vous pouvez le voir, le log est imprimé sur la console, il a log-level, logger-name et message. root est le logger-name par défaut. Nous utiliserons ce genre de fonctions avec nos vues dans Django.

Explore un tutoriel complet sur le module de journalisation de Python

La journalisation dans Django

Django fournit la journalisation en utilisant le module de journalisation de Python. Le module de journalisation peut être facilement configuré.

Lorsque nous voulons utiliser la journalisation dans Django, il y a certaines étapes à suivre. La procédure sera la suivante :

1. Nous configurerons notre settings.py pour divers loggers, handlers, filtres.
2. Nous inclurons le code des loggers dans les vues ou tout autre module de Django où cela est nécessaire.

Ok, alors commençons.

Créer un nouveau projet

Nous créerons un nouveau projet pour la journalisation. Vous pourrez ensuite utiliser la journalisation dans les projets existants. Donc, pour créer un nouveau projet, exécutez cette commande dans la ligne de commande:

$ django-admin startproject dataflairlogs

Cela va démarrer le nouveau projet. Maintenant, nous allons configurer settings.py du projet.

Configuration des paramètres

Pour inclure la journalisation dans Django, nous devons configurer ses paramètres. Faire cela est assez facile. Par configuration des paramètres de journalisation, nous voulons dire définir :

• Loggers
• Handlers
• Filtres
• Formatteurs

Puisque Django fonctionne avec différents modules donc, nous utilisons la méthode dictConfig.

Il y a aussi d’autres méthodes brutes, mais dictConfig est ce que le comportement par défaut de Django.

Il suffit de copier ce code dans votre settings.py

Code:

# DataFlair #Logging InformationLOGGING = { 'version': 1, # Version of logging 'disable_existing_loggers': False, #disable logging # Handlers ############################################################# 'handlers': { 'file': { 'level': 'DEBUG', 'class': 'logging.FileHandler', 'filename': 'dataflair-debug.log', },######################################################################## 'console': { 'class': 'logging.StreamHandler', }, }, # Loggers #################################################################### 'loggers': { 'django': { 'handlers': , 'level': 'DEBUG', 'propagate': True, 'level': os.getenv('DJANGO_LOG_LEVEL', 'DEBUG') }, },}

Comprendre le code:

Je sais que le code est un peu gros mais il est très facile à saisir. Nous obtenons une variable intégrée LOGGING de Django. Les valeurs par défaut de la journalisation proviennent de ce dictionnaire. Puisque nous configurons les paramètres en utilisant un dictionnaire, cela s’appelle la méthode dictConfig. Il y a quelques clés importantes à l’intérieur du dictionnaire LOGGING.

1. version
2. disable_existing_loggers
3. handlers
4. loggers

Discutons-les une par une. La clé version indique la version du schéma. Il est important qu’elle ait une valeur. Elle est par défaut 1.

La clé suivante est disable_existing_loggers. Cette clé sert à indiquer à Django de ne pas désactiver les loggers. Par défaut, Django utilise certains de ses propres loggers. Ces enregistreurs sont connectés à l’ORM de Django et à d’autres parties internes de Django. Cette clé est par défaut True. Donc, elle désactivera ces loggers.

Il y a diverses requêtes de base de données et appels de fonctions que les loggers enregistrent. Par conséquent, il est recommandé de ne pas True cette clé.

Handlers est la 3e clé. Comme nous l’avons discuté, les handlers traitent le message et les passent à la console, au fichier, etc. Le handlers lui-même est un dictionnaire. Les noms des clés de ce dictionnaire seront les noms des handlers. Il existe plusieurs gestionnaires fournis par le module de journalisation. Nous utilisons ici deux handlers.

1. FileHandler : logger-name – filehandler

Le FileHandler va stocker les logs dans un fichier. Comme vous pouvez le voir, nous avons donné le nom de fichier comme dataflair-debug.log.

Le niveau définit, jusqu’à quel niveau le logger doit commettre les journaux.

Note:

Les fichiers journaux sont généralement stockés avec l’extension .log. Ce fichier ne peut être édité qu’avec des permissions. Il peut seulement être ajouté.

2. StreamHandler : nom du logger – console

Le gestionnaire de flux diffusera le journal sur la console. Ce n’est pas une méthode recommandée. Il y a une limite de caractères jusqu’à ce que la ligne de commande vous montre les journaux. Puisque les journaux sont trop gros pour être gérés par la ligne de commande, nous avons donc besoin de file-handlers.

Il y a plus de handlers comme mailhandlers, AdminEmailHandler etc.

Le AdminEmailHandler est un grand ajout au module opensource.

Loggers sont ceux qui vont enregistrer les informations de votre serveur ou logiciel. Les loggers sont également un type de dictionnaire. Il a une architecture similaire à celle des handlers. Bien qu’il y ait différents attributs et autres propriétés.

Django fournit également un ensemble de loggers. Il existe divers loggers comme django, django.requests. et plus encore.

Avez-vous vérifié notre dernier tutoriel Django request & response

Maintenant, pour mettre en œuvre la journalisation, il suffit de suivre ces étapes :

Démarrez votre serveur.

$ python manage.py runserver

Au moment où vous appuyez sur entrée, il y aura une série de journaux et beaucoup de cela. Cela s’est produit parce que nous avons mis le niveau par défaut sur debug. Tous ces logs sont en fait des messages provenant des loggers par défaut.

Vous pouvez créer vos loggers personnalisés dans les fichiers consécutifs. De cette façon, vous pouvez obtenir des journaux à partir de fichiers spécifiques.

Voici la sortie du fichier qui est généré après la journalisation.

Voici les journaux. Il y a beaucoup de journaux mais seuls les niveaux d’avertissement ou supérieurs seront notifiés.

Summary

La journalisation est assez importante. Si elle est mise en œuvre correctement, alors elle peut vous faire gagner beaucoup de temps. Généralement, la journalisation est faite après que le projet soit terminé.

Le module de journalisation est les bases de la journalisation avec Django ou un autre projet python. Il existe également d’autres solutions comme, celery, travis etc. Ces gestionnaires de logs permettent également de manipuler facilement les logs. Ils peuvent faciliter la tâche de recherche si les événements se sont produits ou non et quelle en était la cause.