Django-loggning

Alla utvecklare felsöker fel. Lösningen av dessa fel tar tid. Det hjälper i de flesta fall att veta när och var felet uppstod. Jag skulle säga att Pythons felmeddelanden är ganska hjälpsamma. Men även dessa meddelanden blir värdelösa när man talar om projekt med flera filer. Det problemet och många andra fördelar kommer med loggning.

Som Django-utvecklare är det viktigt att vi också behärskar loggning. Backend-teknologier har olika bra verktyg för att implementera loggning. Django har också stöd för olika ramverk och moduler för loggning. Vi kommer att implementera den med hjälp av den grundläggande och en av de populära loggningsmodulen.

I den här handledningen kommer vi att lära oss om loggning. Innehållet kommer att vara:

• Vad är loggning?
• Python loggningsmodul
• Loggning i Django

Riktigt att lära. Låt oss börja.

Vad är loggning?

Loggning är en teknik eller ett medium som kan låta oss spåra vissa händelser när programvaran körs. Det är en viktig teknik för utvecklare. Den hjälper dem att spåra händelser. Loggning är som en extra uppsättning ögon för dem. Utvecklare är inte bara ansvariga för att göra programvaror utan också för att underhålla dem. Loggning hjälper till oerhört mycket med den delen av underhållet.

Det spårar varje händelse som inträffar hela tiden. Det innebär att du i stället för långa spårningar får mycket mer. Den här gången när ett fel inträffar kan du se i vilken systemet befann sig. Den här metoden hjälper dig att lösa fel snabbt. Eftersom du kommer att kunna se var felet inträffade.

Hur fungerar det? Vad är tanken bakom det?

Loggningen hanteras av ett separat program. Detta loggningsprogram är helt enkelt en filskrivare. Loggprogrammet sägs registrera vissa händelser i textformat. Den registrerade informationen sparas sedan i filer. Filerna för detta kallas loggar. Loggarna är enkla filer som sparas med tillägget logg. De innehåller loggar över inträffade händelser.

Det här är bara en av de mest använda implementeringarna, som du kan se. Eftersom vi bara lagrar informationen kan du komma på fler sätt att hantera den.

Okej, det står klart för oss att loggning är viktigt. Är det svårt? Nej absolut inte kompis. Loggning är inte alls svårt. Vem som helst som vet lite om upplägget kan använda detta.

Som Pythonprogrammerare får du extra funktioner här också. Vi har en hel modul som låter oss åstadkomma just detta. När det gäller andra språk finns det många moduler, Java har Log4j och JavaScript har sin egen loglevel. Alla dessa är också fantastiska verktyg. Okej, så vi kommer att behandla Python (mitt favoritspråk) här.

Loggningsmodul i Python

Loggningsmodulen är en inbyggd Pythonmodul. Den är förinstallerad med Python 3. Loggningsmodulen används för att hålla reda på de händelser som inträffar när programmet körs. Det kan utökas till ett valfritt antal program och därmed för mjukvara, det är lätt att installera och använda.

Varför använda loggningsmodulen?

Som utvecklare kan man fråga sig varför man använder loggningsmodulen. Allt loggning gör är att skriva till en fil eller skriva ut det på konsolen. Allt detta kan åstadkommas genom att använda print statements. Vad är då behovet av en loggningsmodul?. Det är en berättigad fråga. Svaret på det är att loggning är en modul som ger det som print inte kan.

Vi använder print-funktionen för att skriva ut något på konsolen. Så när en funktion inträffar kan vi få ett utskriftsutlåtande om att funktionen utfördes. Även om det tillvägagångssättet fungerar med mindre program är det ineffektivt.

Utskriftsfunktionen blir en del av ditt program och om programmet slutar fungera får du inte resultatet. Dessutom, om något inträffar och systemet startas om, är konsolen också rensad. Så vad ska du göra då? Svaret på det är loggningsmodulen.

Loggningsmodulen kan:

• Multitrådsexekvering
• Kategorisera meddelanden via olika loggningsnivåer
• Det är mycket mer flexibelt och konfigurerbart
• Ge en mer strukturerad information

Det finns alltså 4 huvuddelar i loggningsmodulen. Vi ska titta på dem en efter en.

1. Loggers

Loggers är de objekt som utvecklarna hanterar. De kan förstås som en funktion som anropas när de anropas. Vi använder loggers i våra projektfiler. När funktionen åberopas får vi således en detaljerad rapport. Loggern kan generera flera nivåer av svar. Vi kan anpassa den till fullo.

2. Handlers

Handlers är de objekt som avger informationen. Tänk på dem som tidningshanterare. Deras huvuduppgift är att överföra informationen. Det kan åstadkommas genom att skriva informationen i en loggfil (standardbeteendet). Det finns olika handlers som tillhandahålls av loggningsmodulen.

Vi kan enkelt ställa in flera handlers för samma loggare. Det finns också SMTP-hanterare som skickar loggningsregistren till dig via e-post. Handlerna innehåller vanligtvis affärslogik för loggningsinformation.

3. Formatters

Formaterarna är de som formaterar data. Du ser att handlers inte kan skicka informationen eftersom det är en Python-datatyp. Innan den kan skickas till någon måste den konverteras.

Loggarna är som standard i formatet Log Records. Det är den klass som är fördefinierad av loggningsramverket. Den ger olika metoder som utvecklare kan använda. Det formatet kan inte skickas direkt över ett nätverk eller skrivas i en textfil. För att konvertera det eller formatera det behöver vi formatörer. Det finns olika formatörer för olika handläggare.

Som standard kommer formatörerna att konvertera Log Record till String. Detta beteende kan enkelt ändras och du kan anpassa detta som du vill. Detta format kan baseras på den affärslogik som vi skriver i Handlers.

4. Filter

Den sista delen av loggningsmodulen är filter. Filtren filtrerar, som namnet antyder, meddelandena. Alla meddelanden som vi skickar behöver inte lagras eller transporteras. Eller så kan det finnas olika handläggare för olika meddelanden. Allt detta kan åstadkommas med hjälp av filter.

Vi kan använda filter med både loggers och handlers.

Okej, så nu har vi fått en grundläggande idé om loggningsmodulen. Den förser oss också med meddelandenivåer. Meddelandenivåerna definieras som:

DEBUG: Det är utförlig systeminformation när allt går bra. Den ger dig mer exakta detaljer om systemets tillstånd. Dess allvarlighetsgrad är 10.

INFO: Info ger mindre utförlig systeminformation men liknar debug. Den ger i allmänhet en översikt över vad systemet exekverar. Dess allvarlighetsgrad är 20.

VARNING: Detta innehåller information om problem på låg nivå. Problemen kan ignoreras eftersom de inte orsakar stopp i systemet. Även om det rekommenderas att dessa problem ska lösas.

Dess allvarlighetsgrad är 30.

ERROR: Detta meddelande är allvarligt. Felet innehåller information om det stora problem som har uppstått. Problemet kan ha stoppat programmets funktion och behöver omedelbar uppmärksamhet.

Seriositetspunkten är 40.

CRITICAL: Det mest kritiska meddelandet. Detta meddelande sänds ut när problemet har fått systemet att stanna. Det innebär att hela applikationen har stannat på grund av detta problem.

Dess allvarlighetsgrad är 50.

Serthetspunkten bestämmer vilken prioritet som ska ges. Anta att vi ställer in loggnivån på 30. Då kommer loggaren att logga eller lagra informationen när nivån är större än eller lika med 30. Du behöver alltså bara bekräfta vilken loggningsnivå du vill ha. Vi kommer att lära oss mer om dem i det fortsatta avsnittet.

Vi kan enkelt implementera loggning genom att importera modulen. Eftersom det är en inbyggd modul behöver vi inte installera den via pip.

Skriv bara detta i din Python-fil så kan vi använda loggers.

Kod:

import logginglogging.warning("DataFlair Logging Tutorials")

Utgången som genereras av koden är precis nedan. Som du kan se skrivs loggen ut på konsolen, den har loggnivå, logger-namn och meddelande. root är standardlogger-namnet. Vi kommer att använda den här typen av funktioner med våra vyer i Django.

Utforska en komplett handledning om Pythons loggningsmodul

Loggning i Django

Django tillhandahåller loggning genom att använda Pythons loggningsmodul. Loggningsmodulen kan enkelt konfigureras.

När vi vill använda loggning i Django finns det vissa steg att följa. Proceduren kommer att vara följande:

1. Vi kommer att konfigurera vår settings.py för olika loggers, handlers, filter.
2. Vi kommer att inkludera loggerskoden i views eller någon annan modul i Django där det är nödvändigt.

Okej, så låt oss komma igång.

Skapa ett nytt projekt

Vi kommer att skapa ett nytt projekt för loggning. Du kan sedan använda loggningen i befintliga projekt. Så för att skapa ett nytt projekt utför du det här kommandot på kommandoraden:

$ django-admin startproject dataflairlogs

Detta kommer att starta det nya projektet. Nu ska vi konfigurera settings.py för projektet.

Konfigurera inställningar

För att inkludera loggning i Django måste vi konfigurera dess inställningar. Att göra det är ganska enkelt. Med att konfigurera loggningsinställningar menar vi att definiera:

• Loggers
• Handlers
• Filters
• Formatters

Då Django arbetar med olika moduler använder vi därför metoden dictConfig.

Det finns andra råa metoder också, men dictConfig är vad Djangos standardbeteende.

Kopiera bara den här koden i din settings.py

Kod:

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

Förstå koden:

Jag vet att koden är lite stor, men den är väldigt lätt att förstå. Vi får en inbyggd variabel LOGGING från Django. Loggningens standardvärden kommer från detta lexikon. Eftersom vi konfigurerar inställningar med hjälp av en ordbok kallas metoden dictConfig. Det finns några viktiga nycklar inuti ordlistan LOGGING.

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

Låt oss diskutera dem en efter en. Versionsnyckeln anger schemans version. Det är viktigt att den har ett värde. Den är som standard 1.

Nästa nyckel är disable_existing_loggers. Denna nyckel är till för att tala om för Django att inte inaktivera loggare. Som standard använder Django några av sina egna loggare. Dessa loggare är kopplade till Django ORM och andra inre delar av Django. Den här nyckeln är som standard True. Så den kommer att inaktivera dessa loggare.

Det finns olika databasfrågor och funktionsanrop som loggarna loggar. Därför rekommenderas det att du inte True denna nyckel.

Handlers är den tredje nyckeln. Som vi diskuterade hanterar handlers meddelandet och skickar dem till konsolen, filen osv. Själva handlers är en ordbok. Denna dictionary-key-namn kommer att vara namnen på handlers. Det finns olika handlers som tillhandahålls av loggningsmodulen. Vi använder två handlers här:

1. FileHandler: logger-name – filehandler

FileHandler lagrar loggarna i en fil. Som du kan se har vi gett filnamnet dataflair-debug.log.

Nivån definierar fram till vilken nivå loggaren ska lägga in loggar.

Note:

Loggfiler lagras i allmänhet med .log-tillägget. Den här filen kan endast redigeras med behörigheter. Den kan endast läggas till.

2. StreamHandler: logger name – console

Streamhanteraren kommer att strömma loggen till konsolen. Detta är inte en rekommenderad metod. Det finns en gräns för antalet tecken tills kommandoraden visar dig loggar. Eftersom loggar är för stora för att hanteras av kommandoraden behöver vi därför filhanterare.

Det finns fler hanterare som mailhandlers, AdminEmailHandler etc.

AdminEmailHandler är ett bra tillägg till opensource-modulen.

Loggers är de som kommer att logga din server eller programvaruinformation. Loggers är också en ordbokstyp. Den har en liknande arkitektur som handlers. Även om det finns olika attribut och andra egenskaper.

Django tillhandahåller också en uppsättning loggers. Det finns olika loggers som django, django.requests. med flera.

Har du kollat vår senaste Django request & response Tutorial

Nu, för att implementera loggning behöver du bara följa de här stegen:

Startar din server.

$ python manage.py runserver

I samma ögonblick som du trycker på enter kommer det att finnas en serie av loggar och en hel del av det. Detta hände eftersom vi ställde in standardnivån till debug. Alla dessa loggar är faktiskt meddelanden från standardloggarna.

Du kan skapa dina egna loggare i de efterföljande filerna. På så sätt kan du få loggar från specifika filer.

Här är utdata från filen som genereras efter loggning.

Detta är loggarna. Det finns många loggar men endast varningsnivåer eller högre nivåer ska meddelas.

Sammanfattning

Loggning är ganska viktigt. Om den implementeras på rätt sätt kan den spara mycket tid. I allmänhet görs loggning efter att projektet är klart.

Loggningsmodulen är grunderna för loggning med Django eller ett annat pythonprojekt. Det finns även andra lösningar som celery, travis osv. Dessa logghanterare gör det också enkelt att hantera loggar. De kan underlätta arbetet med att söka om händelserna inträffade eller inte och vad som var orsaken.