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 des tâches liées à l'exploitation forestière plus efficacement. 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ée dans ce tutoriel.

Différentes parties de la journalisation de Django

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

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

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

2. INFO
   Il fournit des informations générales.

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

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

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

2. Gestionnaire de django
La tâche principale du gestionnaire est de transmettre les informations du journal 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. Django Foral
Il est utilisé pour formater les données de 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 en utilisant le formateur avant d'envoyer. Le formateur convertit les enregistrements du journal en 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 de 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 tutoriel, vous devez effectuer les tâches suivantes:

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

Configurer une application Django

1. Exécutez la commande suivante pour créer une application django nommée se connecter.

$ python3 gérer.py startApp LogApp

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

$ python3 gérer.py créeuperuser

3. Ajouter le nom de l'application dans le Installé_app partie de la py déposer.

Installé_apps = [
…
'LogApp'
]]

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

Ouvrir le paramètres.py Fixer à partir du dossier du projet Django et ajouter le contenu suivant pour définir les informations de journalisation. Les propriétés du gestionnaires et bûcherons sont définis ici. Selon les valeurs des propriétés de l'exploitation forestière, DÉBOGUER Les informations de journalisation de niveau seront stockées dans un fichier journal nommé djangoapp.enregistrer Lorsque l'application Django sera exécutée.

# Informations sur la journalisation de Django
Logging =
# Définissez la version forestière
'version 1,
# Activer les enregistreurs existants
'Disable_Existing_Loggers': Faux,
# Définir les gestionnaires
'Handlers':
'déposer':
«Niveau»: «débogage»,
«Classe»: «journalisation.Filehandler ',
«nom de fichier»: «djangoapp.enregistrer',
,
'console':
«Classe»: «journalisation.StreamHandler ',
,
,
# Définir les bûcherons
'Loggers':
'django':
'Handlers': ['fichier'],
«Niveau»: «débogage»,
'propager': vrai,
,
,

Ouvrir le djangoapp.enregistrer Fichier pour vérifier les entrées de journal est stockée dans le fichier ou non.

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

Les informations de journalisation peuvent être définies à l'aide du fichier de vue également. Ouvrir le vues.py fichier à partir du se connecter dossier et remplacez le contenu par le script suivant. Dans ce script, formateurs, gestionnaires, et bûcherons Des parties de l'exploitation forestière de Django sont définis dans le configurer.dictConfig () méthode. DÉBOGUER Les informations de journalisation de niveau seront stockées dans un fichier journal nommé djangoapp.enregistrer et sera imprimé dans la console lorsque l'application Django sera exécutée. indice() La fonction est utilisée pour envoyer un texte simple en 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
journalisation d'importation
# Importez HttpResponse pour envoyer des données au navigateur
De Django.HTTP Import httpResponse
# Définir les configurations de journalisation
enregistrement.configurer.dictConfig (
# Définissez la version forestière
'version 1,
# Activer les enregistreurs existants
'Disable_Existing_Loggers': Faux,
# Définir les formateurs
'formateurs':
'console':
«Format»: «% (message) s»
,
'déposer':
«Format»: «% (message) s»
,
# Définir les gestionnaires
'Handlers':
'console':
«Classe»: «journalisation.StreamHandler ',
«Formatter»: «console»
,
'déposer':
«Niveau»: «débogage»,
«Classe»: «journalisation.Filehandler ',
«Formatter»: «fichier»,
«nom de fichier»: «djangoapp.enregistrer'

,
# Définir les bûcherons
'Loggers':
'django':
«Niveau»: «débogage»,
'Handlers': ['File', 'Console'],



)
# Créer l'objet Loggers
Logger = journalisation.getlogger ('__ name__')
# Définissez la fonction de la page d'index
index def (demande):
retourner httpResponse ("

Ceci est une application Django

")
# Définissez la fonction de la page de journal
def display_log (demande):
# Envoyez le test!! Enregistrer le message à Standard Out
bûcheron.Erreur ("Tester Django Log…")
retourner httpResponse ("

Message de journalisation de Django

")

Modifier le contenu du URL.py fichier avec le script suivant. Dans le script, le chemin du chemin vide (”) est défini pour appeler le indice() fonction des vues et du 'enregistrer/'Le 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 LogApp
urlpatterns = [
Path (", vues.indice),
Path ('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 d'affichage_log () qui affichera un message texte dans le navigateur et un message texte dans le terminal. Les entrées de journal seront annexées dans le djangoapp.enregistrer déposer.

Conclusion

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