Django Logging

Alle udviklere debug fejl. Opløsningen af disse fejl tager tid. Det hjælper i de fleste tilfælde at vide, hvornår og hvor fejlen opstod. Jeg vil sige, at Pythons fejlmeddelelser er ganske nyttige. Men selv disse meddelelser bliver ubrugelige, når der er tale om projekter med flere filer. Dette problem og mange andre fordele kommer med logning.

Som Django-udviklere er det vigtigt, at vi også mestrer logning. Backend-teknologier har forskellige gode værktøjer til at implementere logning. Django giver også understøttelse for forskellige loggingframeworks og -moduler. Vi vil implementere det ved hjælp af det grundlæggende og et af de populære, loggingmodul.

I denne tutorial vil vi lære om logging. Indholdet vil være:

• Hvad er logning?
• Python logningsmodul
• Logning i Django

Klar til at lære. Lad os komme i gang.

Hvad er logning?

Logning er en teknik eller et medie, som kan lade os spore nogle begivenheder, mens softwaren udføres. Det er en vigtig teknik for udviklere. Den hjælper dem med at spore begivenheder. Logning er som et ekstra sæt øjne for dem. Udviklere er ikke kun ansvarlige for at lave software, men også for at vedligeholde dem. Logning hjælper enormt meget med den del af vedligeholdelsen.

Det sporer alle hændelser, der opstår til enhver tid. Det betyder, at du i stedet for de lange tracebacks får meget mere. Denne gang, når der opstår en fejl, kan du se, hvor systemet var i. Denne metode vil hjælpe dig med at løse fejl hurtigt. Da du vil være i stand til at fortælle, hvor fejlen opstod.

Hvordan virker det? Hvad er ideen bag?

Logningen håndteres af et separat program. Dette logningsprogram er simpelthen en filskriver. Loggeren siges at registrere visse begivenheder i tekstformat. De registrerede oplysninger gemmes derefter i filer. Filerne til dette kaldes logfiler. Logfilerne er simple filer, der gemmes med log-udvidelsen. De indeholder logfilerne af de hændelser, der er sket.

Dette er blot en af de mest anvendte implementeringer, som du kan se. Da vi blot gemmer oplysningerne, kan du finde på flere måder at håndtere dem på.

Okay, det er klart for os, at logning er vigtig. Er det svært? Nej absolut ikke kammerat. Logning er slet ikke svært overhovedet. Enhver, der ved en lille smule om opsætning, kan bruge dette.

Som Python-programmør får du også ekstra funktioner her. Vi har fået et helt modul, der lader os udføre netop dette. Hvad angår andre sprog, er der mange moduler, Java har Log4j og JavaScript har sit eget loglevel. Alle disse er også fantastiske værktøjer. Okay, så vi vil her beskæftige os med Python (mit yndlingssprog).

Loggingmodul i Python

Loggingmodulet er et indbygget Python-modul. Det leveres præinstalleret med Python 3. Logningsmodulet bruges til at holde styr på de hændelser, der opstår, mens programmet kører. Det kan udvides til et vilkårligt antal programmer og dermed for software, det er nemt at opsætte og bruge.

Hvorfor bruge logningsmodulet?

Som udvikler kan man spørge, hvorfor man bruger logningsmodulet. Alt, hvad logning gør, er at skrive til en fil eller udskrive det på konsollen. Alt det kan opnås ved at bruge print statements. Hvad er behovet for et logningsmodul så?. Det er et gyldigt spørgsmål. Svaret på det er, at logging er et modul, der giver det, som print ikke kan.

Vi bruger print-funktionen til at udsende noget på konsollen. Så når en funktion opstår, kan vi få en print-meddelelse om, at funktionen blev udført. Selv om den fremgangsmåde fungerer med mindre programmer, er den ineffektiv.

Print-funktionen bliver en del af dit program, og hvis softwaren holder op med at fungere, får du ikke resultatet. Hvis der sker noget, og systemet genstartes, er konsollen også slettet, hvis der sker noget. Så hvad vil du så gøre? Svaret på det er logningsmodulet.

Logningsmodulet er i stand til:

• Multithreading-eksekvering
• Kategorisering af meddelelser via forskellige logningsniveauer
• Det er meget mere fleksibelt og konfigurerbart
• Giver en mere struktureret information

Der er altså 4 hoveddele i logningsmodulet. Vi vil se på dem en efter en.

1. Loggere

Loggerne er de objekter, som udviklerne har med at gøre. De kan forstås som en funktion, der vil blive påberåbt, når de bliver kaldt. Vi bruger loggere i vores projektfiler. Når funktionen påkaldes, får vi således en detaljeret rapport, når funktionen påkaldes. Loggeren kan generere flere niveauer af svar. Vi kan tilpasse den i fuldt omfang.

2. Handlers

Handlers er de objekter, der udsender oplysningerne. Tænk på dem som avishandlere. Deres hovedopgave er at udsende oplysningerne. Det kan gøres ved at skrive oplysningerne i en logfil (standardadfærd). Der er forskellige handlers, der leveres af logningsmodulet.

Vi kan nemt opsætte flere handlers for den samme logger. Der er også SMTP-handlere, som sender logoprotokollerne pr. mail til dig. Handlerne indeholder normalt forretningslogik til logning af oplysninger.

3. Formatters

Det er formatters, der formaterer dataene. Du kan se, at handlers ikke kan sende oplysningerne, da det er en Python-datatype. Før det kan sendes til nogen, skal det konverteres.

Logfilerne er som standard i Log Records-format. Det er den klasse, der er foruddefineret af logningsrammen. Den giver forskellige metoder til udviklere, som de kan bruge. Det format kan ikke sendes direkte over et netværk eller skrives i en tekstfil. For at konvertere det eller formatere det, har vi brug for formatere. Der findes forskellige formatters til forskellige handlere.

Som standard vil formatters konvertere logoptagelsen til String. Denne adfærd kan nemt ændres, og du kan tilpasse dette som du ønsker. Dette format kan være baseret på den forretningslogik, som vi skriver i Handlers.

4. Filtre

Den sidste del af logningsmodulet er filtre. Filtrene filtrerer, som navnet antyder, meddelelserne. Ikke alle de meddelelser, vi videregiver, behøver at blive gemt eller transporteret. Eller der kan være forskellige handlers for forskellige meddelelser. Alt dette kan opnås ved hjælp af filtre.

Vi kan bruge filtre med både loggere og handlers.

Okay, så nu har vi fået en grundlæggende idé om logningsmodulet. Det giver os også beskedniveauer. Meddelelsesniveauerne er defineret som:

DEBUG: Det er verbose systemoplysninger, når alt kører fint. Det fortæller dig mere præcise detaljer om systemets tilstand. Dens alvorlighedspunkt er 10.

INFO: info giver mindre verbose systemoplysninger, men svarer til debug. Den fortæller generelt et overblik over, hvad systemet er ved at udføre. Dens alvorlighedspunkt er 20.

WARNING: Denne indeholder oplysninger om problemer på lavt niveau. Problemerne kan ignoreres, da de ikke får systemet til at stoppe. Det anbefales dog, at disse problemer skal løses.

Dets alvorlighedspunkt er 30.

ERROR: Denne meddelelse er alvorlig. Fejlen vil indeholde oplysninger om det store problem, der er opstået. Problemet kan have stoppet programmets funktion og kræver øjeblikkelig opmærksomhed.

Sværhedsgraden er 40.

CRITICAL: Den mest kritiske meddelelse. Denne meddelelse udsendes, når problemet har fået systemet til at stoppe. Det betyder, at hele applikationen er stoppet på grund af dette problem.

Sværhedsgraden er 50.

Sværhedsgraden bestemmer, hvilken prioritet der skal gives. Lad os antage, at vi indstiller logniveauet til at være 30. Så vil loggeren logge eller gemme oplysningerne, når niveauet er større end eller lig med 30. Så du skal blot bekræfte, hvilket logningsniveau du ønsker. Vi vil lære mere om dem i det videre afsnit.

Vi kan nemt implementere logning ved at importere modulet. Da det er et indbygget modul, behøver vi ikke installere det via pip.

Du skal blot skrive dette i din Python-fil, og vi kan bruge loggers.

Kode:

import logginglogging.warning("DataFlair Logging Tutorials")

Det output, der genereres af koden, er lige herunder. Som du kan se, udskrives loggen på konsollen, den har log-niveau, logger-navn og besked. root er standard-logger-navnet. Vi vil bruge disse slags funktioner med vores visninger i Django.

Udforsk en komplet tutorial om Python Logging Module

Logning i Django

Django giver logning ved hjælp af logningsmodulet i Python. Logningsmodulet kan nemt konfigureres.

Når vi ønsker at bruge logning i Django, er der visse trin, der skal følges. Proceduren vil være som følger:

1. Vi vil konfigurere vores settings.py til forskellige loggere, handlers, filtre.
2. Vi vil inkludere logger-koden i views eller et andet modul i Django, hvor det er nødvendigt.

Okay, så lad os komme i gang.

Skab et nyt projekt

Vi vil oprette et nyt projekt til logning. Du kan derefter bruge logningen i eksisterende projekter. Så for at oprette et nyt projekt skal du udføre denne kommando på kommandolinjen:

$ django-admin startproject dataflairlogs

Dette vil starte det nye projekt. Nu skal vi konfigurere settings.py for projektet.

Konfigurering af indstillinger

For at inkludere logning i Django skal vi konfigurere dens indstillinger. Det er ret nemt at gøre det. Ved at konfigurere logningsindstillinger mener vi at definere:

• Loggers
• Handlers
• Filters
• Formatters

Da Django arbejder med forskellige moduler, bruger vi derfor dictConfig-metoden.

Der er også andre rå metoder, men dictConfig er hvad Djangos standardadfærd.

Kopier blot denne kode i din settings.py

Kode:

# 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') }, },}

Forstå koden:

Jeg ved godt, at koden er lidt stor, men den er meget let at forstå. Vi får en indbygget variabel LOGGING fra Django. Loggingens standardværdier kommer fra denne ordbog. Da vi konfigurerer indstillinger ved hjælp af en ordbog kaldes det dictConfig-metoden. Der er nogle vigtige nøgler inde i LOGGING-ordbogen.

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

Lad os diskutere dem en efter en. Versionsnøglen fortæller skemaversionen. Det er vigtigt, at den har en værdi. Den er som standard 1.

Den næste nøgle er disable_existing_loggers. Denne nøgle er til at fortælle Django, at den ikke skal deaktivere loggere. Som standard bruger Django nogle af sine egne loggere. Disse loggere er forbundet med Django ORM og andre indre dele af Django. Denne nøgle er som standard True. Så den vil deaktivere disse loggere.

Der er forskellige databaseforespørgsler og funktionskald, som loggerne logger. Derfor anbefales det, at du ikke True denne nøgle.

Handlers er den 3. nøgle. Som vi diskuterede, håndterer handlers meddelelsen og videregiver dem til konsollen, filen osv. Selve handlers er en ordbog. Denne ordbog-nøgle navne vil være navnene på handlers. Der er forskellige handlers, der leveres af logningsmodulet. Vi bruger to handlers her.

1. FileHandler: logger-name – filehandler

FileHandleren gemmer logfilerne i en fil. Som du kan se, har vi givet filnavnet som dataflair-debug.log.

Niveauet definerer, indtil hvilket niveau loggeren skal overføre logs.

Note:

Logfiler gemmes generelt med .log-udvidelsen. Denne fil kan kun redigeres med tilladelser. Den kan kun tilføjes.

2. StreamHandler: loggernavn – console

Streamhandleren vil streame loggen på konsollen. Dette er ikke en anbefalet metode. Der er en grænse for antallet af tegn, indtil kommandolinjen viser dig logger. Da logs er for store til at håndtere via kommandolinjen, har vi derfor brug for file-handlers.

Der er flere handlers som mailhandlers, AdminEmailHandler osv.

Den AdminEmailHandler er en god tilføjelse til opensource-modulet.

Loggers er dem, der vil logge dine server- eller softwareoplysninger. Loggere er også en ordbogstype. Den har en lignende arkitektur som handlers. Selv om der er forskellige attributter og andre egenskaber.

Django indeholder også et sæt loggere. Der er forskellige loggere som django, django.requests. og flere.

Har du tjekket vores seneste Django request & response Tutorial

Nu skal du bare følge disse trin for at implementere logning:

Start din server.

$ python manage.py runserver

Det øjeblik du trykker på enter vil der komme en række logs og en masse af det. Dette skete, fordi vi satte standardniveauet til debug. Alle disse logs er faktisk meddelelser fra standardloggerne.

Du kan oprette dine brugerdefinerede loggere i de efterfølgende filer. På den måde kan du få logs fra specifikke filer.

Her er output af den fil, der genereres efter logning.

Dette er logs. Der er mange logfiler, men kun advarselsniveauer eller højere niveauer skal meddeles.

Summary

Logføring er ret vigtig. Hvis det er implementeret korrekt, kan det spare dig en masse tid. Generelt udføres logning, når projektet er færdigt.

Logningsmodulet er det grundlæggende for logning med Django eller et andet python-projekt. Der er også andre løsninger som, celery, travis osv. Disse loghåndteringsprogrammer gør det også nemt at håndtere logs. De kan lette opgaven med at søge, om begivenhederne er opstået eller ej, og hvad årsagen var.