Django Logging

Alle ontwikkelaars debuggen fouten. Het oplossen van die fouten kost tijd. Het helpt in de meeste gevallen om te weten wanneer en waar de fout is opgetreden. Ik zou zeggen dat Python’s foutmeldingen heel behulpzaam zijn. Maar zelfs deze berichten zijn nutteloos als het gaat om projecten met meerdere bestanden. Dat probleem en vele andere voordelen komen met logging.

Als Django ontwikkelaars, is het belangrijk dat we logging ook onder de knie krijgen. Backend technologieën hebben verschillende geweldige tools om logging te implementeren. Django biedt ook ondersteuning voor verschillende logging frameworks en modules. We zullen het implementeren met behulp van de basis en een van de populaire, logging module.

In deze tutorial, zullen we leren over loggen. De inhoud zal zijn:

• Wat is Logging?
• Python Logging Module
• Logging in Django

Klaar om te leren.

Wat is loggen?

Loggen is een techniek of medium waarmee we bepaalde gebeurtenissen kunnen volgen terwijl de software wordt uitgevoerd. Het is een belangrijke techniek voor ontwikkelaars. Het helpt hen om gebeurtenissen te volgen. Loggen is als een extra set ogen voor hen. Ontwikkelaars zijn niet alleen verantwoordelijk voor het maken van software, maar ook voor het onderhoud ervan. Loggen helpt enorm bij dat deel van het onderhoud.

Het houdt elke gebeurtenis bij die zich voordoet op elk moment. Dat betekent dat je in plaats van de lange tracebacks veel meer krijgt. Als er een fout optreedt, kunt u zien waar het systeem zich in bevond. Deze methode zal u helpen om fouten snel op te lossen. Omdat u in staat zult zijn om te vertellen waar de fout optrad.

Hoe werkt het? Wat is het idee erachter?

Het loggen wordt door een apart programma gedaan. Dat logprogramma is gewoon een file-writer. De logger zou bepaalde gebeurtenissen in tekstformaat vastleggen. De geregistreerde informatie wordt vervolgens opgeslagen in bestanden. De bestanden hiervoor worden logs genoemd. De logs zijn eenvoudige bestanden die worden opgeslagen met de extensie log. Ze bevatten de logs van opgetreden gebeurtenissen.

Wel, dit is slechts een van de meest gebruikte implementaties, zoals je kunt zien. Omdat we alleen de informatie opslaan, kun je meer manieren verzinnen om ermee om te gaan.

Okay, het is ons duidelijk dat loggen belangrijk is. Is het moeilijk? Nee absoluut niet maatje. Loggen is helemaal niet moeilijk. Iedereen die een beetje van de setup weet, kan dit gebruiken.

Als Python programmeur, krijg je hier ook extra mogelijkheden. We hebben een hele module waarmee we precies dat kunnen doen. Wat andere talen betreft, zijn er veel modules, Java heeft Log4j en JavaScript heeft zijn eigen loglevel. Dit zijn ook allemaal geweldige hulpmiddelen. Okay, dus we zullen ons hier bezighouden met Python (mijn favoriete taal).

Logging Module in Python

De logging module is een ingebouwde Python module. Het komt voorgeïnstalleerd met Python 3. De logging module wordt gebruikt om de gebeurtenissen bij te houden die zich voordoen als het programma draait. Dat kan worden uitgebreid tot een willekeurig aantal programma’s en is dus voor software eenvoudig op te zetten en te gebruiken.

Waarom logging module gebruiken?

Als ontwikkelaar kunnen we ons afvragen waarom we de logging module gebruiken. Het enige wat loggen doet is het schrijven naar een bestand of het afdrukken op de console. Dat kan allemaal worden bereikt door print statements te gebruiken. Wat is dan de noodzaak van een logging module? Dat is een goede vraag. Het antwoord daarop is dat logging een module is die geeft wat print niet kan.

We gebruiken de print functie om iets op de console te zetten. Dus, wanneer een functie optreedt, kunnen we een print verklaring krijgen dat de functie is uitgevoerd. Hoewel die aanpak werkt met kleinere toepassingen, is het inefficiënt.

Print functie wordt onderdeel van uw programma en als de software stopt met werken, krijgt u het resultaat niet. Ook, als er iets gebeurt en het systeem herstart, is de console ook leeg. Dus, wat ga je dan doen? Het antwoord daarop is logging module.

De logging module is in staat om:

• Multithreading uitvoering
• Berichten categoriseren via verschillende log niveaus
• Het is veel flexibeler en configureerbaar
• Geeft een meer gestructureerde informatie

Dus, er zijn 4 belangrijke onderdelen van de logging module. We zullen ze een voor een bekijken.

1. Loggers

De loggers zijn de objecten waar ontwikkelaars mee te maken krijgen. Ze kunnen worden opgevat als een functie die wordt aangeroepen wanneer ze worden aangeroepen. Wij gebruiken loggers in onze project bestanden. Wanneer de functie wordt aangeroepen, krijgen we een gedetailleerd rapport. De logger kan meerdere niveaus van antwoorden genereren. We kunnen het volledig aanpassen.

2. Handlers

Handlers zijn de objecten die de informatie uitzenden. Denk aan hen als krant handlers. Hun hoofdtaak is het verzenden van de informatie. Dat kan worden bereikt door de info in een logbestand te schrijven (Het standaard gedrag). Er zijn verschillende handlers die door de logging module worden geleverd.

We kunnen gemakkelijk meerdere handlers voor dezelfde logger instellen. Er zijn ook SMTP Handlers die de log records naar je mailen. De handlers bevatten meestal business logica voor het loggen van informatie.

3. Formatters

De formatters zijn degenen die de gegevens formatteren. Handlers kunnen de informatie niet verzenden, omdat het een Python datatype is. Voordat het naar iemand kan worden gestuurd, moet het worden omgezet.

De logs zijn standaard in Log Records formaat. Dat is de klasse die vooraf is gedefinieerd door het logging framework. Het geeft verschillende methodes aan die ontwikkelaars kunnen gebruiken. Dat formaat kan niet direct over een netwerk worden verstuurd of in een tekstbestand worden geschreven. Om dat te converteren of te formatteren, hebben we formatteerders nodig. Er zijn verschillende formatters voor verschillende handlers.

Standaard zetten de formatters het Log Record om in String. Dit gedrag kan gemakkelijk worden veranderd en u kunt dit aanpassen zoals u wilt. Dit formaat kan worden gebaseerd op de business logica die we schrijven in Handlers.

4. Filters

Het laatste stuk van de logging module is filters. De filters, zoals de naam al zegt, filteren de berichten. Niet elk bericht dat we doorgeven hoeft te worden opgeslagen of getransporteerd. Of er kunnen verschillende handlers zijn voor verschillende berichten. Dat is allemaal mogelijk met behulp van filters.

We kunnen filters gebruiken met zowel loggers als handlers.

Okay, dus nu hebben we een basis idee gekregen van de logging module. Het voorziet ons ook van berichtniveaus. De berichtniveaus zijn gedefinieerd als:

DEBUG: Het is verbose systeeminformatie wanneer alles goed loopt. Het vertelt u meer precieze details over de toestand van het systeem. De ernstgraad is 10.

INFO: De info zal minder uitgebreide systeeminformatie produceren, maar is vergelijkbaar met debug. Het geeft in het algemeen een overzicht van wat het systeem aan het uitvoeren is. De ernstgraad is 20.

WAARSCHUWING: Dit bevat informatie over problemen op laag niveau. De problemen kunnen worden genegeerd omdat ze het systeem niet doen stoppen. Het verdient echter aanbeveling deze problemen op te lossen.

Het ernstpunt is 30.

ERROR: Deze melding is ernstig. De fout bevat informatie over het ernstige probleem dat zich heeft voorgedaan. Het probleem kan de werking van het programma hebben gestopt en vereist onmiddellijke aandacht.

De ernstgraad is 40.

CRITICAL: De meest kritieke melding. Dit bericht wordt gegeven wanneer het probleem heeft geleid tot het stoppen van het systeem. Dat betekent dat de hele toepassing is gestopt als gevolg van dit probleem.

Het ernstpunt is 50.

Het ernstpunt bepaalt welke prioriteit wordt gegeven. Stel, we stellen het log-niveau in op 30. Dan zal de logger de informatie loggen of opslaan als het niveau groter dan of gelijk aan 30 is. Dus, je hoeft alleen maar te bevestigen welk niveau van logging je wilt. We zullen er meer over leren in de volgende sectie.

We kunnen logging eenvoudig implementeren door de module te importeren. Aangezien het een ingebouwde module is, hoeven we deze niet via pip te installeren.

Je hoeft dit alleen maar in je Python-bestand te schrijven en we kunnen loggers gebruiken.

Code:

import logginglogging.warning("DataFlair Logging Tutorials")

De output die door de code wordt gegenereerd, staat hieronder. Zoals u kunt zien, wordt het logboek afgedrukt op de console, het heeft log-niveau, logger-naam en bericht. root is de standaard logger-naam. We zullen dit soort functies gebruiken met onze views in Django.

Bekijk een volledige tutorial over Python Logging Module

Logging in Django

Django biedt logging door gebruik te maken van de logging module van Python. De logging module kan eenvoudig worden geconfigureerd.

Wanneer we logging in Django willen gebruiken zijn er bepaalde stappen die moeten worden gevolgd. De procedure zal als volgt zijn:

1. We zullen onze settings.py configureren voor verschillende loggers, handlers, filters.
2. We zullen de loggers code opnemen in views of een andere module van Django waar nodig.

Okee, dus laten we aan de slag gaan.

Maak een nieuw Project

We zullen een nieuw project maken voor het loggen. U kunt dan de logging in bestaande projecten gebruiken. Dus, om een nieuw project aan te maken, voer dit commando uit in de commandoregel:

$ django-admin startproject dataflairlogs

Dit zal het nieuwe project starten. Nu zullen we settings.py van het project configureren.

Configuring Settings

Om logging in Django op te nemen, moeten we de instellingen configureren. Dat doen is vrij eenvoudig. Met het configureren van logging-instellingen bedoelen we het definiëren van:

• Loggers
• Handlers
• Filters
• Formatters

Omdat Django met verschillende modules werkt, gebruiken we daarom de dictConfig methode.

Er zijn ook andere ruwe methoden, maar dictConfig is wat Django’s standaard gedrag.

Kopieer deze code in uw 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') }, },}

Begrijp de code:

Ik weet dat de code een beetje groot is, maar het is heel gemakkelijk te begrijpen. We krijgen een ingebouwde variabele LOGGING van Django. De standaard waarden van de logging komen uit deze dictionary. Omdat we de instellingen configureren met behulp van een woordenboek wordt dit de dictConfig methode genoemd. Er zijn enkele belangrijke sleutels binnen het LOGGING woordenboek.

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

Laten we ze een voor een bespreken. De versie sleutel vertelt de schema versie. Het is belangrijk dat deze waarde heeft. Het is standaard 1.

De volgende sleutel is disable_existing_loggers. Deze sleutel is om Django te vertellen om loggers niet uit te schakelen. Standaard gebruikt Django een aantal van zijn eigen loggers. Deze loggers zijn verbonden met Django ORM en andere interne onderdelen van Django. Deze sleutel is standaard True. Dus, het zal deze loggers uitschakelen.

Er zijn verschillende database queries en functie-aanroepen die de loggers loggen. Daarom is het aan te raden deze sleutel niet op True te zetten.

Handlers is de 3e sleutel. Zoals we besproken hebben, handlers behandelen de berichten en geven ze door aan console, bestand, enz. De handlers zelf is een woordenboek. De namen van die woordenboek-sleutel zijn de namen van de handlers. Er zijn verschillende handlers voorzien door de logging module. Wij gebruiken hier twee handlers.

1. FileHandler: logger-naam – filehandler

De FileHandler slaat de logs op in een bestand. Zoals u kunt zien, hebben we de bestandsnaam gegeven als dataflair-debug.log.

Het niveau definieert, tot welk niveau de logger logs moet vastleggen.

Note:

Log bestanden worden over het algemeen opgeslagen met de extensie .log. Dit bestand kan alleen worden bewerkt met machtigingen. Het kan alleen worden toegevoegd.

2. StreamHandler: logger naam – console

De stream handler zal het log op console streamen. Dit is geen aanbevolen methode. Er is een limiet van karakters tot de commandoregel je logs toont. Omdat logs te groot zijn om via de command line te verwerken, hebben we file-handlers nodig.

Er zijn meer handlers zoals mailhandlers, AdminEmailHandler enz.

De AdminEmailHandler is een geweldige toevoeging aan de opensource module.

Loggers zijn degenen die je server of software informatie loggen. Loggers zijn ook een dictionary type. Het heeft een vergelijkbare architectuur als handlers. Hoewel, er zijn verschillende attributen en andere eigenschappen.

Django biedt ook een set van loggers. Er zijn verschillende loggers zoals django, django.requests. en meer.

Heb je onze laatste Django request & response Tutorial

Nu, om logging te implementeren, hoeft u alleen maar deze stappen te volgen:

Start uw server.

$ python manage.py runserver

Op het moment dat je op enter drukt zal er een reeks van logs zijn en een heleboel van dat. Dit is gebeurd omdat we het standaard level op debug hebben gezet. Al deze logs zijn eigenlijk berichten van de standaard loggers.

Je kunt je eigen aangepaste loggers maken in de opeenvolgende bestanden. Op die manier kunt u logboeken van specifieke bestanden krijgen.

Hier is de uitvoer van het bestand dat wordt gegenereerd na het loggen.

Dit zijn de logboeken. Er zijn een heleboel logs, maar alleen waarschuwingen of hoger worden gemeld.

Samenvatting

Logging is behoorlijk belangrijk. Als het goed wordt uitgevoerd, kan het je veel tijd besparen. Over het algemeen wordt het loggen gedaan nadat het project is voltooid.

Logging module is de basis van het loggen met Django of een ander python project. Er zijn ook andere oplossingen zoals, celery, travis etc. Deze log handlers maken het ook gemakkelijk om logs te verwerken. Zij kunnen de taak verlichten van het zoeken of de gebeurtenissen zich hebben voorgedaan of niet en wat de oorzaak was.