Django Logging

Alle Entwickler debuggen Fehler. Die Behebung dieser Fehler braucht Zeit. In den meisten Fällen hilft es, wenn man weiß, wann und wo der Fehler aufgetreten ist. Ich würde sagen, dass die Fehlermeldungen von Python recht hilfreich sind. Aber selbst diese Meldungen sind nutzlos, wenn es um Projekte mit mehreren Dateien geht. Dieses Problem und viele andere Vorteile bringt das Logging mit sich.

Als Django-Entwickler ist es wichtig, dass wir auch das Logging beherrschen. Backend-Technologien haben verschiedene großartige Tools, um Logging zu implementieren. Auch Django bietet Unterstützung für verschiedene Logging-Frameworks und -Module. Wir werden es mit dem grundlegenden und einem der populärsten, dem Logging-Modul, implementieren.

In diesem Tutorial werden wir über Logging lernen. Der Inhalt wird sein:

• Was ist Logging?
• Python Logging Modul
• Logging in Django

Bereit zum Lernen. Fangen wir an.

Was ist Logging?

Logging ist eine Technik oder ein Medium, mit dem wir einige Ereignisse verfolgen können, während die Software ausgeführt wird. Es ist eine wichtige Technik für Entwickler. Es hilft ihnen, Ereignisse zu verfolgen. Die Protokollierung ist wie ein zusätzliches Paar Augen für sie. Entwickler sind nicht nur für die Erstellung von Software verantwortlich, sondern auch für deren Wartung. Logging hilft bei diesem Teil der Wartung ungemein.

Es verfolgt jedes Ereignis, das zu jeder Zeit auftritt. Das bedeutet, dass man statt der langen Rückverfolgungen viel mehr bekommt. Wenn ein Fehler auftritt, können Sie dieses Mal sehen, in welchem Zustand sich das System befand. Diese Methode wird Ihnen helfen, Fehler schnell zu beheben. Denn Sie können erkennen, wo der Fehler aufgetreten ist.

Wie funktioniert das? Was ist die Idee dahinter?

Die Protokollierung wird von einem separaten Programm durchgeführt. Dieses Protokollierungsprogramm ist einfach ein Dateischreiber. Der Logger soll bestimmte Ereignisse im Textformat aufzeichnen. Die aufgezeichneten Informationen werden dann in Dateien gespeichert. Die Dateien dafür werden Logs genannt. Die Logs sind einfache Dateien, die mit der Erweiterung log gespeichert werden. Sie enthalten die Protokolle der aufgetretenen Ereignisse.

Wie Sie sehen, ist dies nur eine der am häufigsten verwendeten Implementierungen. Da wir die Informationen nur speichern, können Sie sich weitere Möglichkeiten ausdenken, damit umzugehen.

Okay, es ist uns klar, dass die Protokollierung wichtig ist. Ist es schwierig? Nein, absolut nicht, Kumpel. Logging ist überhaupt nicht schwierig. Jeder, der sich ein bisschen mit der Einrichtung auskennt, kann das nutzen.

Als Python-Programmierer bekommst du hier auch zusätzliche Funktionen. Wir haben ein ganzes Modul, mit dem wir genau das erreichen können. Was andere Sprachen angeht, gibt es viele Module, Java hat Log4j und JavaScript hat sein eigenes Loglevel. All das sind ebenfalls erstaunliche Werkzeuge. Okay, also werden wir uns hier mit Python (meiner Lieblingssprache) beschäftigen.

Logging Modul in Python

Das Logging Modul ist ein eingebautes Python Modul. Es wird mit Python 3 vorinstalliert. Das Logging-Modul wird verwendet, um die Ereignisse zu protokollieren, die während der Ausführung des Programms auftreten. Es kann auf eine beliebige Anzahl von Programmen erweitert werden und ist daher für Software einfach einzurichten und zu verwenden.

Warum das Logging-Modul verwenden?

Als Entwickler kann man sich fragen, warum man das Logging-Modul verwendet. Alles, was das Logging tut, ist das Schreiben in eine Datei oder das Drucken auf der Konsole. All das kann durch die Verwendung von print-Anweisungen erreicht werden. Wozu braucht man dann ein Logging-Modul? Das ist eine berechtigte Frage. Die Antwort darauf ist, dass Logging ein Modul ist, das das bietet, was print nicht kann.

Wir verwenden die Funktion print, um etwas auf der Konsole auszugeben. Wenn also eine Funktion auftritt, können wir eine Druckanweisung erhalten, dass die Funktion ausgeführt wurde. Dieser Ansatz funktioniert zwar bei kleineren Anwendungen, ist aber ineffizient.

Die Druckfunktion wird Teil des Programms, und wenn die Software nicht mehr funktioniert, erhält man das Ergebnis nicht. Und wenn etwas passiert und das System neu gestartet wird, ist die Konsole ebenfalls leer. Was werden Sie dann tun? Die Antwort darauf ist das Logging-Modul.

Das Logging-Modul ist in der Lage:

• Multithreading-Ausführung
• Meldungen über verschiedene Log-Levels zu kategorisieren
• Es ist viel flexibler und konfigurierbar
• Gibt eine strukturiertere Information

So, es gibt 4 Hauptteile des Logging-Moduls. Wir werden sie uns nacheinander ansehen.

1. Logger

Die Logger sind die Objekte, mit denen die Entwickler arbeiten. Sie können als eine Funktion verstanden werden, die aufgerufen wird, wenn sie aufgerufen werden. Wir verwenden Logger in unseren Projektdateien. Wenn die Funktion aufgerufen wird, erhalten wir also einen detaillierten Bericht. Der Logger kann mehrere Ebenen von Antworten erzeugen. Wir können ihn in vollem Umfang anpassen.

2. Handler

Handler sind die Objekte, die die Informationen ausgeben. Man kann sie sich als Zeitungsabwickler vorstellen. Ihre Hauptaufgabe ist es, die Informationen zu übermitteln. Das kann durch das Schreiben der Informationen in eine Protokolldatei erreicht werden (das Standardverhalten). Es gibt verschiedene Handler, die vom Logging-Modul bereitgestellt werden.

Wir können leicht mehrere Handler für denselben Logger einrichten. Es gibt auch SMTP-Handler, die Ihnen die Log-Einträge per E-Mail zusenden. Die Handler enthalten normalerweise Geschäftslogik für die Protokollierung von Informationen.

3. Formatierer

Die Formatierer sind diejenigen, die die Daten formatieren. Sie sehen, dass Handler die Informationen nicht senden können, da es sich um einen Python-Datentyp handelt. Bevor sie an irgendjemanden gesendet werden können, müssen sie konvertiert werden.

Die Logs sind standardmäßig im Log Records Format. Das ist die Klasse, die vom Logging-Framework vordefiniert ist. Es gibt verschiedene Methoden für Entwickler zu verwenden. Dieses Format kann nicht direkt über ein Netzwerk gesendet oder in eine Textdatei geschrieben werden. Um es zu konvertieren oder zu formatieren, benötigen wir Formatierer. Es gibt verschiedene Formatierer für verschiedene Handler.

Standardmäßig konvertieren die Formatierer den Log Record in einen String. Dieses Verhalten kann leicht geändert werden, und Sie können es nach Belieben anpassen. Dieses Format kann auf der Geschäftslogik basieren, die wir in Handlers schreiben.

4. Filter

Der letzte Teil des Logging-Moduls sind Filter. Die Filter, wie der Name schon sagt, filtern die Nachrichten. Nicht jede Nachricht, die wir übergeben, muss gespeichert oder transportiert werden. Oder es kann verschiedene Handler für verschiedene Nachrichten geben. All das ist mit Hilfe von Filtern möglich.

Wir können Filter sowohl mit Loggern als auch mit Handlern verwenden.

Okay, jetzt haben wir also eine grundlegende Vorstellung vom Logging-Modul. Es stellt uns auch Meldungsebenen zur Verfügung. Die Meldungsebenen sind wie folgt definiert:

DEBUG: Es handelt sich um ausführliche Systeminformationen, wenn alles gut läuft. Sie gibt genauere Informationen über den Zustand des Systems. Sein Schweregrad ist 10.

INFO: Info liefert weniger ausführliche Systeminformationen, ist aber ähnlich wie Debug. Sie gibt im Allgemeinen einen Überblick darüber, was das System gerade ausführt. Sein Schweregrad ist 20.

WARNING: Dies enthält Informationen über Probleme auf niedriger Ebene. Die Probleme können ignoriert werden, da sie das System nicht zum Stillstand bringen. Es wird jedoch empfohlen, diese Probleme zu beheben.

Der Schweregrad ist 30.

FEHLER: Diese Meldung ist schwerwiegend. Der Fehler enthält Informationen über das aufgetretene Hauptproblem. Das Problem kann den Betrieb des Programms gestoppt haben und muss sofort behoben werden.

Der Schweregrad ist 40.

CRITICAL: Die kritischste Meldung. Diese Meldung wird ausgegeben, wenn das Problem zum Anhalten des Systems geführt hat. Das bedeutet, dass die gesamte Anwendung aufgrund dieses Problems zum Stillstand gekommen ist.

Ihr Schweregrad ist 50.

Der Schweregrad bestimmt, welche Priorität gegeben werden soll. Angenommen, wir setzen den Log-Level auf 30. Dann wird der Logger die Informationen protokollieren oder speichern, wenn der Level größer oder gleich 30 ist. Sie müssen also nur bestätigen, welche Protokollierungsstufe Sie wünschen. Wir werden im nächsten Abschnitt mehr darüber erfahren.

Wir können die Protokollierung leicht implementieren, indem wir das Modul importieren. Da es ein eingebautes Modul ist, müssen wir es nicht über pip installieren.

Schreiben Sie dies einfach in Ihre Python-Datei und wir können Logger verwenden.

Code:

import logginglogging.warning("DataFlair Logging Tutorials")

Die Ausgabe, die durch den Code generiert wird, ist gleich unten. Wie Sie sehen können, wird das Log auf der Konsole ausgegeben, es hat log-level, logger-name und message. root ist der Standard-Logger-Name. Wir werden diese Art von Funktionen mit unseren Views in Django verwenden.

Entdecke ein komplettes Tutorial über das Python Logging Modul

Logging in Django

Django bietet Logging durch die Verwendung des Logging Moduls von Python. Das Logging-Modul kann einfach konfiguriert werden.

Wenn wir Logging in Django verwenden wollen, müssen wir bestimmte Schritte befolgen. Die Vorgehensweise ist wie folgt:

1. Wir werden unsere settings.py für verschiedene Logger, Handler und Filter konfigurieren.
2. Wir werden den Code der Logger in Views oder jedes andere Modul von Django einbinden, wo es nötig ist.

Okay, dann fangen wir mal an.

Erstelle ein neues Projekt

Wir werden ein neues Projekt für die Protokollierung erstellen. Sie können dann die Protokollierung in bestehenden Projekten verwenden. Um also ein neues Projekt zu erstellen, führen Sie diesen Befehl in der Kommandozeile aus:

$ django-admin startproject dataflairlogs

Damit wird das neue Projekt gestartet. Nun werden wir die settings.py des Projekts konfigurieren.

Einstellungen konfigurieren

Um das Logging in Django einzubinden, müssen wir die Einstellungen konfigurieren. Das ist ziemlich einfach. Mit dem Konfigurieren der Logging-Einstellungen meinen wir das Definieren von:

• Loggers
• Handlers
• Filters
• Formatters

Da Django mit verschiedenen Modulen arbeitet, verwenden wir die dictConfig Methode.

Es gibt auch andere rohe Methoden, aber dictConfig ist das Standardverhalten von Django.

Kopieren Sie einfach diesen Code in Ihre 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') }, },}

Verstehen Sie den Code:

Ich weiß, dass der Code ein bisschen groß ist, aber er ist sehr einfach zu verstehen. Wir bekommen von Django eine eingebaute Variable LOGGING. Die Standardwerte für die Protokollierung stammen aus diesem Wörterbuch. Da wir die Einstellungen mit Hilfe eines Wörterbuchs konfigurieren, wird die Methode dictConfig genannt. Es gibt einige wichtige Schlüssel innerhalb des LOGGING Wörterbuchs.

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

Lassen Sie uns diese einzeln besprechen. Der Versionsschlüssel gibt die Schemaversion an. Es ist wichtig, dass er einen Wert hat. Er ist standardmäßig 1.

Der nächste Schlüssel ist disable_existing_loggers. Mit diesem Schlüssel wird Django angewiesen, Logger nicht zu deaktivieren. Standardmäßig verwendet Django einige seiner eigenen Logger. Diese Logger sind mit Django ORM und anderen inneren Teilen von Django verbunden. Dieser Schlüssel ist standardmäßig True. Daher werden diese Logger deaktiviert.

Es gibt verschiedene Datenbankabfragen und Funktionsaufrufe, die von den Loggern aufgezeichnet werden. Es wird daher empfohlen, diesen Schlüssel nicht auf True zu setzen.

Handler ist der dritte Schlüssel. Wie wir bereits besprochen haben, behandeln Handler die Nachricht und geben sie an die Konsole, die Datei usw. weiter. Die Handler selbst sind ein Wörterbuch. Die Namen der Wörterbuch-Schlüssel sind die Namen der Handler. Es gibt verschiedene Handler, die vom Logging-Modul bereitgestellt werden. Wir verwenden hier zwei Handler.

1. FileHandler: logger-name – filehandler

Der FileHandler wird die Protokolle in einer Datei speichern. Wie Sie sehen können, haben wir den Dateinamen dataflair-debug.log angegeben.

Der Level legt fest, bis zu welchem Level der Logger Protokolle übertragen soll.

Hinweis:

Log-Dateien werden generell mit der Endung .log gespeichert. Diese Datei kann nur mit Berechtigungen bearbeitet werden. Sie kann nur angehängt werden.

2. StreamHandler: Loggername – console

Der StreamHandler wird das Log auf die Konsole streamen. Dies ist keine empfohlene Methode. Es gibt eine Grenze von Zeichen, bis die Kommandozeile Logs anzeigt. Da die Logs zu groß für die Kommandozeile sind, brauchen wir File-Handler.

Es gibt weitere Handler wie Mailhandler, AdminEmailHandler usw.

Der AdminEmailHandler ist eine großartige Ergänzung des OpenSource-Moduls.

Logger sind diejenigen, die Ihre Server- oder Softwareinformationen protokollieren. Logger sind ebenfalls ein Wörterbuchtyp. Sie haben eine ähnliche Architektur wie Handler. Allerdings gibt es unterschiedliche Attribute und andere Eigenschaften.

Django bietet auch eine Reihe von Loggern. Es gibt verschiedene Logger wie django, django.requests. und mehr.

Haben Sie unser letztes Django request & response Tutorial

Nun, um Logging zu implementieren, müssen Sie nur diese Schritte befolgen:

Starten Sie Ihren Server.

$ python manage.py runserver

In dem Moment, in dem Sie Enter drücken, wird es eine Reihe von Logs geben und zwar eine Menge. Das passiert, weil wir die Standardstufe auf Debug eingestellt haben. Alle diese Logs sind eigentlich Nachrichten von den Standard-Loggern.

Sie können Ihre eigenen Logger in den Folgedateien erstellen. Auf diese Weise können Sie Logs von bestimmten Dateien erhalten.

Hier ist die Ausgabe der Datei, die nach dem Logging erzeugt wird.

Das sind die Logs. Es gibt eine Menge von Logs, aber nur Warnungen oder höhere Stufen sollen gemeldet werden.

Zusammenfassung

Logging ist ziemlich wichtig. Wenn es richtig implementiert ist, kann es Ihnen viel Zeit sparen. Im Allgemeinen wird die Protokollierung nach Abschluss des Projekts durchgeführt.

Das Protokollierungsmodul ist die Grundlage für die Protokollierung mit Django oder einem anderen Python-Projekt. Es gibt auch andere Lösungen wie celery, travis usw. Diese Log-Handler machen es auch einfach, mit Logs umzugehen. Sie können die Suche erleichtern, ob die Ereignisse aufgetreten sind oder nicht und was die Ursache war.