Chaque programmeur fait face à des erreurs lors de l'écriture de code pour développer une application. Le débogage est utilisé par le codeur pour résoudre les erreurs de l'application. Sa fonction de journalisation facilite le processus de débogage en enregistrant la sortie des messages d'erreur, d'avertissement et d'information dans un fichier. Ces messages aident les codeurs à suivre les événements, à comprendre la raison de la sortie indésirable et à modifier correctement le code pour créer une application sans erreur. Python a un module de journalisation intégré pour effectuer plus efficacement les tâches liées à la journalisation. Django est un framework python populaire qui utilise le module de journalisation intégré python à des fins de débogage. Comment le module de journalisation python peut être utilisé dans l'application Django à des fins de débogage sera expliqué dans ce tutoriel.

Différentes parties de Django Logging

La journalisation Django contient quatre types de configurations qui sont expliquées ci-dessous.

1. Django Logger
Le logger enregistre les événements lors de l'exécution de l'application, et la journalisation est appelée. Les entrées de journal sont stockées dans un fichier en les catégorisant dans différents niveaux de journal. Chaque niveau de journal indique la gravité des événements. Les objectifs de ces niveaux de journalisation sont mentionnés ci-dessous :

DÉBOGUER
Il fournit des informations système de bas niveau pour le débogage.

INFO
Il fournit des informations générales.

ERREUR
Il fournit des informations sur le problème majeur de l'application.

ATTENTION
Il fournit des informations sur le problème mineur de l'application.

CRITIQUE
Il fournit des informations sur le problème critique de l'application.

2. Gestionnaire Django
La tâche principale du gestionnaire est de transmettre les informations de journal qui sont stockées dans le fichier journal. Le module de journalisation contient de nombreux types de gestionnaires et plusieurs d'entre eux peuvent être définis pour le même enregistreur.

3. Formateur Django
Il est utilisé pour formater les données du journal. Les données du gestionnaire ne peuvent pas être envoyées directement au fichier journal et les données du gestionnaire nécessitent qu'elles soient converties à l'aide du formateur avant l'envoi. Le formateur convertit les enregistrements du journal dans la chaîne. Le format des données dépend de la logique métier du gestionnaire.

4. Filtre Django
Il est utilisé pour filtrer les messages du journal. Il n'est pas nécessaire de stocker tous les messages de journal dans le fichier journal. Différents gestionnaires peuvent être utilisés pour différents messages et les messages de journal requis peuvent être filtrés à l'aide des filtres requis.

Conditions préalables

Avant de pratiquer le script de ce didacticiel, vous devez effectuer les tâches suivantes :

Installez la version Django 3+ sur Ubuntu 20+ (de préférence)
Créer un projet Django
Exécutez le serveur Django pour vérifier que le serveur fonctionne correctement ou non.

Configurer une application Django

Exécutez la commande suivante pour créer une application Django nommée logapp.

$ python3 gérer.py startapp logapp

Exécutez la commande suivante pour créer l'utilisateur permettant d'accéder à la base de données Django. Si vous avez déjà créé l'utilisateur, vous n'avez pas besoin d'exécuter la commande.

$ python3 gérer.py createsuperuser

Ajoutez le nom de l'application dans le INSTALLED_APP partie de la py déposer.

INSTALLED_APPS = [
…
'logapp'
]

Définir les informations de journalisation dans les paramètres.py

Ouvrez le Les paramètres.py du dossier du projet Django et ajoutez le contenu suivant pour définir les informations de journalisation. Les propriétés du gestionnaires et bûcherons sont réglés ici. Selon les valeurs de propriété de journalisation, DÉBOGUER les informations de journalisation de niveau seront stockées dans un fichier journal nommé djangoapp.Journal quand l'application Django sera exécutée.

# Informations de journalisation Django
ENREGISTREMENT =
# Définir la version de journalisation
'version 1,
# Activer les loggers existants
'disable_existing_loggers' : False,
# Définir les gestionnaires
'gestionnaires' :
'déposer':
'niveau': 'DEBUG',
'classe' : 'journalisation.Gestionnaire de fichiers',
'nom de fichier': 'djangoapp.Journal',
,
'console':
'class': 'journalisation.StreamHandler',
,
,
# Définir les loggers
'enregistreurs' :
'django' :
'gestionnaires' : ['fichier'],
'niveau': 'DEBUG',
'propager' : vrai,
,
,

Ouvrez le djangoapp.Journal fichier pour vérifier que les entrées du journal sont stockées dans le fichier ou non.

Définir les informations de journalisation dans les vues.py

Les informations de journalisation peuvent être définies à l'aide du fichier de vue également. Ouvrez le vues.py fichier de la logapp dossier et remplacez le contenu par le script suivant. Dans ce script, formateurs, gestionnaires, et bûcherons les parties de la journalisation Django sont définies dans le configuration.dictConfig() méthode. DÉBOGUER les informations de journalisation de niveau seront stockées dans un fichier journal nommé djangoapp.Journal et sera imprimé dans la console lorsque l'application Django sera exécutée. indice() est utilisée pour envoyer un simple texte de titre au navigateur et le display_log() la fonction est définie pour envoyer un texte simple dans le terminal et un texte de titre au navigateur.

vues.py

# Importer le module de journalisation
importer la journalisation
# Importez HttpResponse pour envoyer des données au navigateur
de Django.http importer HttpResponse
# Définir les configurations de journalisation
enregistrement.configuration.dictConfig(
# Définir la version de journalisation
'version 1,
# Activer les loggers existants
'disable_existing_loggers' : False,
# Définir les formateurs
'formateurs' :
'console':
'format' : '%(message)s'
,
'déposer':
'format' : '%(message)s'
,
# Définir les gestionnaires
'gestionnaires' :
'console':
'classe' : 'journalisation.StreamHandler',
'formateur': 'console'
,
'déposer':
'niveau': 'DEBUG',
'classe' : 'journalisation.Gestionnaire de fichiers',
'formateur': 'fichier',
'nom de fichier': 'djangoapp.Journal'

,
# Définir les loggers
'enregistreurs' :
'django' :
'niveau': 'DEBUG',
'gestionnaires' : ['fichier', 'console'],

)
# Créer l'objet loggers
enregistreur = journalisation.getLogger('__nom__')
# Définir la fonction pour la page d'index
def index (demande):
return HttpResponse("

Ceci est une application Django

")
# Définir la fonction pour la page de journal
def display_log (demande) :
# Envoyer le test!! journaliser le message vers la sortie standard
enregistreur.error("Test du journal Django… ")
return HttpResponse("

Message de journalisation Django

Modifier le contenu de la URL.py fichier avec le script suivant. Dans le script, le chemin vide (") est défini pour appeler le indice() fonction des vues et des 'Journal/' chemin est utilisé pour appeler le display_log() fonction des vues.

URL.py

de Django.chemin d'importation des URL
à partir des vues d'importation de logapp
urlpatterns = [
chemin(", vues.indice),
chemin('log/', vues.display_log)
]

Exécutez l'URL suivante pour afficher la page d'index.

http://localhost:8000

Exécutez l'URL suivante pour appeler la méthode display_log() qui affichera un message texte dans le navigateur et un message texte dans le terminal. Les entrées de journal seront ajoutées dans le djangoapp.Journal déposer.

Conclusion

Deux façons d'utiliser la journalisation python dans l'application Django pour conserver les informations de journalisation au niveau DEBUG sont présentées dans ce didacticiel. Le concept de base concernant la journalisation Django devrait être compris par les lecteurs après avoir lu ce tutoriel.

Comment utiliser la journalisation Django?