Django naplózás

Minden fejlesztő hibakeresése. Ezeknek a hibáknak a megoldása időt vesz igénybe. A legtöbb esetben segít, ha tudjuk, hogy mikor és hol történt a hiba. Azt mondanám, hogy a Python hibaüzenetei elég hasznosak. De még ezek az üzenetek is használhatatlanná válnak, ha több fájlból álló projektekről van szó. Ez a probléma és sok más előnye is van a naplózásnak.

Django fejlesztőként fontos, hogy a naplózást is elsajátítsuk. A backend technológiák különböző nagyszerű eszközökkel rendelkeznek a naplózás megvalósításához. A Django is támogatja a különböző naplózási keretrendszereket és modulokat. Mi az alap és az egyik legnépszerűbb, logging modul segítségével fogjuk megvalósítani.

Ebben a bemutatóban a naplózást fogjuk megismerni. A tartalom a következő lesz:

• Mi az a naplózás?
• Python naplózó modul
• Naplózás a Djangóban

Készen áll a tanulásra. Kezdjük el.

Mi az a naplózás?

A naplózás egy olyan technika vagy médium, amely lehetővé teszi számunkra bizonyos események nyomon követését a szoftver végrehajtása során. Ez egy fontos technika a fejlesztők számára. Segít nekik az események nyomon követésében. A naplózás olyan számukra, mint egy extra szempár. A fejlesztők nemcsak a szoftverek elkészítéséért, hanem azok karbantartásáért is felelősek. A naplózás óriási segítséget nyújt a karbantartásnak ebben a részében.

Minden mindenkor bekövetkező eseményt nyomon követ. Ez azt jelenti, hogy a hosszú visszakövetések helyett sokkal többet kapunk. Ilyenkor, ha hiba lép fel, láthatod, hogy milyen állapotban volt a rendszer. Ez a módszer segít a hibák gyors elhárításában. Mivel meg tudja majd mondani, hogy hol történt a hiba.

Hogyan működik? Mi a lényege?

A naplózást egy külön program kezeli. Ez a naplózó program egyszerűen egy fájlíró. A logger állítólag bizonyos eseményeket rögzít szöveges formátumban. A rögzített információkat aztán fájlba menti. Az erre szolgáló fájlokat naplóknak nevezzük. A naplók egyszerű, log kiterjesztéssel mentett fájlok. Ezek tartalmazzák a bekövetkezett események naplóit.

Nos, ez csak az egyik leggyakrabban használt megvalósítás, mint láthatjuk. Mivel mi csak tároljuk az információkat, többféleképpen is ki lehet találni a kezelésükre.

Oké, világossá vált számunkra, hogy a naplózás fontos. Nehéz a dolog? Nem abszolút nem haver. A naplózás egyáltalán nem nehéz. Bárki, aki egy kicsit is ért a beállításokhoz, tudja használni.

Mivel Python programozó vagy, itt extra funkciókat is kapsz. Van egy egész modulunk, amivel pont ezt tudjuk megvalósítani. Ami a többi nyelvet illeti, sok modul van, a Java-nak ott van a Log4j, a JavaScriptnek pedig a saját logszintje. Mindezek is csodálatos eszközök. Oké, akkor itt most a Pythonnal (a kedvenc nyelvemmel) fogunk foglalkozni.

Logging modul Pythonban

A logging modul egy beépített Python modul. A Python 3-ban előre telepítve van. A naplózó modult arra használják, hogy nyomon kövessék a program futása közben bekövetkező eseményeket. Ez tetszőleges számú programra kiterjeszthető, és így a szoftverek számára könnyen beállítható és használható.

Miért használjuk a naplózó modult?

Elkészítőként feltehetjük a kérdést, hogy miért használjuk a naplózó modult. A naplózás csak annyit tesz, hogy ír egy fájlba vagy kiírja a konzolra. Mindezt elérhetjük a print utasítások használatával. Akkor mi szükség van a naplózási modulra?. Ez egy jogos kérdés. A válasz erre az, hogy a logging egy olyan modul, amely megadja azt, amit a print nem tud.

A print függvényt arra használjuk, hogy valamit kiadjunk a konzolra. Tehát, amikor egy függvény bekövetkezik, kapunk egy nyomtatási utasítást, hogy a függvény végrehajtódott. Ez a megközelítés kisebb alkalmazásoknál működik ugyan, de nem hatékony.

A print függvény a program részévé válik, és ha a szoftver leáll, nem kapjuk meg az eredményt. Továbbá, ha bármi történik, és a rendszer újraindul, a konzol is törlődik. Szóval, akkor mit fogsz csinálni? A válasz erre a naplózó modul.

A naplózó modul képes:

• Multiszálú végrehajtás
• Az üzenetek kategorizálása különböző naplózási szinteken keresztül
• Sokkal rugalmasabb és konfigurálhatóbb
• Szerkezettebb információt ad

A naplózó modulnak tehát 4 fő része van. Egyenként nézzük meg őket.

1. Naplózók

A naplózók azok az objektumok, amelyekkel a fejlesztők foglalkoznak. Úgy értelmezhetjük őket, mint egy függvényt, amely meghívásukkor meghívásra kerül. A loggereket a projektfájljainkban használjuk. Így a függvény meghívásakor részletes jelentést kapunk. A logger több szintű választ generálhat. Teljes mértékben testre szabhatjuk.

2. Kezelők

A kezelők azok az objektumok, amelyek információt bocsátanak ki. Gondoljunk rájuk úgy, mint újságkezelőkre. Fő feladatuk az információ továbbítása. Ezt úgy érhetjük el, hogy az információt egy naplófájlba írjuk (Az alapértelmezett viselkedés). A naplózási modul különböző kezelőket biztosít.

Egyszerűen beállíthatunk több kezelőt ugyanahhoz a naplózóhoz. Vannak SMTP kezelők is, amelyek postázzák a naplóbejegyzéseket. A kezelők általában üzleti logikát tartalmaznak a naplózási információkhoz.

3. Formázók

A formázók azok, amelyek az adatokat formázzák. Látod, a kezelők nem tudják elküldeni az információt, mivel ez egy Python adattípus. Mielőtt bárkinek elküldhetnénk, konvertálni kell.

A naplók alapértelmezés szerint Naplórekordok formátumban vannak. Ez a naplózási keretrendszer által előre definiált osztály. Különböző módszereket ad a fejlesztőknek a használatra. Ezt a formátumot nem lehet közvetlenül hálózaton keresztül elküldeni vagy szöveges fájlba írni. Ennek átalakításához vagy formázásához formázókra van szükségünk. Különböző formázók vannak a különböző kezelőkhöz.

A formázók alapértelmezés szerint a naplófeljegyzést karakterlánccá alakítják. Ez a viselkedés könnyen megváltoztatható, és tetszés szerint testre szabható. Ez a formátum alapulhat az üzleti logikán, amit a Handlers-ben írunk.

4. Szűrők

A naplózási modul utolsó darabja a szűrők. A szűrők, ahogy a neve is mutatja, az üzeneteket szűrik. Nem minden általunk átadott üzenetet kell tárolni vagy továbbítani. Vagy lehetnek különböző kezelők a különböző üzenetekhez. Mindezt a szűrők segítségével érhetjük el.

A szűrőket loggerekkel és kezelőkkel egyaránt használhatjuk.

Oké, most már van egy alapképünk a naplózó modulról. Ez biztosítja számunkra az üzenetszinteket is. Az üzenetszintek a következőképpen vannak definiálva:

DEBUG: Ez bőbeszédű rendszerinformáció, amikor minden rendben fut. Pontosabb részleteket közöl a rendszer állapotáról. Súlyossági pontja 10.

INFO: Az info kevésbé verbózus rendszerinformációkat ad, de hasonló a debughoz. Általában áttekintést ad arról, hogy mit hajt végre a rendszer. A súlyossági pontja 20.

FIGYELMEZTETÉS: Alacsony szintű problémákra vonatkozó információkat tartalmaz. A problémák figyelmen kívül hagyhatók, mivel nem okozzák a rendszer leállását. Bár ajánlott ezeket a problémákat megoldani.

Súlyossági pontja 30.

ERROR: Ez az üzenet súlyos. A hiba információt tartalmaz a felmerült súlyos problémáról. A probléma leállíthatta a program működését, és azonnali figyelmet igényel.

Súlyossági pontja 40.

CRITICAL: A legkritikusabb üzenet. Ez az üzenet akkor jelenik meg, ha a probléma a rendszer leállását okozta. Ez azt jelenti, hogy az egész alkalmazás leállt a probléma miatt.

Súlyossági pontja 50.

A súlyossági pont határozza meg, hogy milyen prioritást kell adni. Tegyük fel, hogy a naplózási szintet 30-ra állítjuk be. Ekkor a naplózó akkor fogja naplózni vagy tárolni az információt, ha a szint nagyobb vagy egyenlő a 30-nál. Tehát csak meg kell erősítenie, hogy milyen szintű naplózást szeretne. Ezekről többet fogunk megtudni a további részben.

A modul importálásával könnyen megvalósíthatjuk a naplózást. Mivel ez egy beépített modul, nem kell telepítenünk a pip segítségével.

Egyszerűen írjuk be ezt a Python fájlunkba, és már használhatjuk is a loggereket.

Kód:

import logginglogging.warning("DataFlair Logging Tutorials")

A kód által generált kimenet az alábbiakban látható. Mint látható, a napló kiíródik a konzolra, van log-level, logger-name és message. root az alapértelmezett logger-name. Ilyen típusú függvényeket fogunk használni a Django nézeteinkkel.

Tekintse meg a Python naplózó moduljának teljes bemutatóját

Naplózás a Djangóban

A Django a Python naplózó moduljának használatával biztosítja a naplózást. A naplózási modul könnyen konfigurálható.

Ha naplózást akarunk használni a Djangóban, bizonyos lépéseket kell követnünk. Az eljárás a következő lesz:

1. Konfiguráljuk a settings.py fájlunkat a különböző loggerek, kezelők, szűrők számára.
2. Ahol szükséges, a loggerek kódját beépítjük a nézetekbe vagy a Django bármely más moduljába.

Oké, akkor kezdjük el.

Új projekt létrehozása

Létrehozunk egy új projektet a naplózáshoz. Ezután a naplózást a meglévő projektekben is használhatjuk. Tehát egy új projekt létrehozásához hajtsuk végre ezt a parancsot a parancssorban:

$ django-admin startproject dataflairlogs

Ez elindítja az új projektet. Most a projekt settings.py állományát fogjuk konfigurálni.

A beállítások konfigurálása

A Django naplózás beépítéséhez konfigurálnunk kell annak beállításait. Ennek elvégzése elég egyszerű. A naplózási beállítások konfigurálásán a következőket értjük:

• Loggers
• Handlers
• Filters
• Formatters

Mivel a Django különböző modulokkal dolgozik ezért a dictConfig módszert használjuk.

Léteznek más nyers módszerek is, de a dictConfig az, ami a Django alapértelmezett viselkedése.

Egyszerűen másold be ezt a kódot a settings.py-ba

Kód:

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

A kód megértése:

Tudom, hogy a kód kicsit nagy, de nagyon könnyen áttekinthető. Kapunk egy beépített LOGGING változót a Django-tól. A naplózás alapértelmezett értékei ebből a szótárból származnak. Mivel a beállításokat egy szótár segítségével konfiguráljuk, ezért a dictConfig metódust hívjuk. A LOGGING szótáron belül van néhány fontos kulcs.

1. verzió
2. disable_existing_loggers
3. handlers
4. loggers

Egyenként tárgyaljuk őket. A verzió kulcs megadja a séma verzióját. Fontos, hogy legyen értéke. Alapértelmezés szerint 1.

A következő kulcs a disable_existing_loggers. Ez a kulcs arra szolgál, hogy megmondja a Djangónak, hogy ne tiltsa le a loggereket. Alapértelmezés szerint a Django néhány saját loggert használ. Ezek a loggerek a Django ORM-hez és a Django más belső részeihez kapcsolódnak. Ez a kulcs alapértelmezés szerint True. Tehát letiltja ezeket a loggereket.

Vannak különböző adatbázis-lekérdezések és függvényhívások, amelyeket a loggerek naplóznak. Ezért ajánlott, hogy ne True ez a kulcs.

Handlers a 3. kulcs. Ahogy megbeszéltük, a kezelők kezelik az üzeneteket, és továbbítják azokat a konzolra, fájlba stb. Maga a handlers egy szótár. Ez a szótár-kulcs neve lesz a kezelők neve. A naplózási modul különböző kezelőket biztosít. Mi itt két kezelőt használunk.

1. FileHandler: logger-név – filehandler

A FileHandler egy fájlban fogja tárolni a naplókat. Mint látható, a fájlnevet dataflair-debug.log néven adtuk meg.

A szint határozza meg, hogy a logger milyen szintig rögzítse a naplókat.

Megjegyzés:

A naplófájlokat általában .log kiterjesztéssel tároljuk. Ezt a fájlt csak jogosultságokkal lehet szerkeszteni. Csak függeszteni lehet.

2. StreamHandler: logger neve – console

A stream handler a naplót a konzolon fogja streamelni. Ez nem ajánlott módszer. Van egy karakterhatár, amíg a parancssorban megjelenik a napló. Mivel a naplók túl nagyok ahhoz, hogy parancssorral kezeljük, ezért szükségünk van fájlkezelőkre.

Még több kezelő van, mint a mailhandler, AdminEmailHandler stb.

A AdminEmailHandler egy nagyszerű kiegészítője az opensource modulnak.

A loggerek azok, amelyek a szerver vagy a szoftver adatait naplózzák. A loggerek szintén szótár típusúak. Hasonló felépítésű, mint a kezelők. Bár vannak különböző attribútumok és egyéb tulajdonságok.

A Django is biztosít egy sor loggert. Vannak különböző loggerek, mint a django, django.requests. és így tovább.

Megnézted a legutóbbi Django request & response Tutorial

Most, a naplózás megvalósításához csak a következő lépéseket kell követned:

Elindítod a szervered.

$ python manage.py runserver

Amint lenyomod az enter-t, egy sor napló lesz, méghozzá rengeteg. Ez azért történt, mert az alapértelmezett szintet debug-ra állítottuk. Ezek a naplók valójában az alapértelmezett loggerek üzenetei.

Az egymást követő fájlokban létrehozhatod az egyéni loggereket. Így konkrét fájlok naplóit kaphatod meg.

Itt van a fájl kimenete, amely a naplózás után keletkezik.

Ezek a naplók. Rengeteg napló van, de csak a figyelmeztető vagy a feletti szintekről kell értesíteni.

Összefoglaló

A naplózás elég fontos. Ha helyesen van megvalósítva, akkor sok időt takaríthat meg. Általában a naplózás a projekt befejezése után történik.

A naplózó modul a Django vagy egy másik python projekt naplózásának alapjai. Vannak más megoldások is, mint például, celery, travis stb. Ezek a naplókezelők is megkönnyítik a naplók kezelését. Megkönnyíthetik a keresést, hogy az események bekövetkeztek-e vagy sem, és mi volt az oka.