Django Logování

Všichni vývojáři ladí chyby. Řešení těchto chyb vyžaduje čas. Ve většině případů pomáhá zjistit, kdy a kde k chybě došlo. Řekl bych, že chybová hlášení Pythonu jsou docela užitečná. Ale i tato hlášení se stávají nepoužitelnými, pokud mluvíme o projektech s více soubory. Tento problém a mnoho dalších výhod přináší logování.

Jako vývojáři Djanga je důležité, abychom zvládli i logování. Backendové technologie mají různé skvělé nástroje pro implementaci logování. I Django poskytuje podporu pro různé logovací frameworky a moduly. My jej budeme implementovat pomocí základního a jednoho z populárních, modulu logování.

V tomto tutoriálu se seznámíme s logováním. Obsahem bude:

• Co je to logování
• Modul logování v Pythonu
• Logování v Djangu

Připraveni k učení. Začněme.

Co je to logování?

Logování je technika nebo médium, které nám může umožnit sledovat některé události při provádění softwaru. Je to důležitá technika pro vývojáře. Pomáhá jim sledovat události. Logování je pro ně jako další sada očí. Vývojáři nejsou zodpovědní pouze za tvorbu softwaru, ale také za jeho údržbu. Logování s touto částí údržby nesmírně pomáhá.

Sleduje každou událost, která se kdykoli vyskytne. To znamená, že namísto dlouhého sledování získáte mnohem více. Tentokrát při výskytu chyby vidíte, v jakém stavu se systém nacházel. Tato metoda vám pomůže chyby rychle vyřešit. Protože budete moci zjistit, kde k chybě došlo.

Jak to funguje? V čem spočívá její podstata?

Zaznamenávání chyb je řešeno samostatným programem. Tento logovací program je jednoduše zapisovač souborů. Říká se, že logger zaznamenává určité události v textovém formátu. Zaznamenané informace se pak ukládají do souborů. Soubory pro tento účel se nazývají logy. Protokoly jsou jednoduché soubory uložené s příponou log. Obsahují záznamy o nastalých událostech.

No, jak vidíte, je to jen jedna z nejpoužívanějších implementací. Protože jde jen o ukládání informací, můžete vymyslet další způsoby, jak s nimi pracovat.

Dobře, je nám jasné, že protokolování je důležité. Je to obtížné? Ne, absolutně ne, kamaráde. Logování není vůbec obtížné. Každý, kdo se trochu vyzná v nastavení, to zvládne.

Jelikož jsi programátor v Pythonu, získáš zde i další funkce. Máme celý modul, který nám umožňuje dosáhnout právě tohoto. Co se týče ostatních jazyků, existuje mnoho modulů, Java má Log4j a JavaScript má svůj vlastní loglevel. To všechno jsou také úžasné nástroje. Dobrá, takže se zde budeme zabývat Pythonem (mým oblíbeným jazykem).

Modul logování v Pythonu

Modul logování je vestavěný modul Pythonu. Dodává se předinstalovaný s jazykem Python 3. Modul protokolování slouží k zaznamenávání událostí, které nastanou při běhu programu. Ten lze rozšířit na libovolný počet programů, a proto se pro software snadno nastavuje a používá.

Proč používat modul protokolování?

Jako vývojáři se můžeme ptát, proč používat modul protokolování. Jediné, co logování dělá, je zápis do souboru nebo výpis na konzoli. Toho všeho lze dosáhnout pomocí příkazů print. K čemu je tedy modul logování potřeba? To je správná otázka. Odpovědí na ni je, že logování je modul, který poskytuje to, co print neumí.

Používáme funkci print, abychom něco vypsali na konzoli. Když tedy nastane nějaká funkce, můžeme získat výpis print, že se funkce provedla. Tento přístup sice funguje u menších aplikací, ale je neefektivní.

Funkce print se stává součástí programu, a pokud program přestane pracovat, výsledek se nedozvíte. Navíc pokud k něčemu dojde a systém se restartuje, konzola je také prázdná. Co tedy budete dělat? Odpovědí na to je modul logování.

Modul logování umí:

• Vícevláknové provádění
• Kategorizace zpráv pomocí různých úrovní logování
• Je mnohem flexibilnější a konfigurovatelnější
• Dává strukturovanější informace

Takže existují 4 hlavní části modulu logování. Podíváme se na ně postupně.

1. Loggery

Loggery jsou objekty, se kterými vývojáři pracují. Lze je chápat jako funkce, které budou vyvolány při jejich volání. Loggery používáme v projektových souborech. Při vyvolání funkce tak získáme podrobnou zprávu. Logger může generovat více úrovní odpovědí. Můžeme si jej plně přizpůsobit.

2. Handlery

Handlery jsou objekty, které vysílají informace. Představte si je jako obsluhy novin. Jejich hlavním úkolem je vysílat informace. Toho lze dosáhnout zápisem informace do souboru protokolu (Výchozí chování). Existují různé handlery poskytované modulem logování.

Můžeme snadno nastavit více handlerů pro stejný logger. Existují také obsluhy SMTP, které vám záznamy z protokolu zašlou poštou. Obsluhy obvykle obsahují obchodní logiku pro zaznamenávání informací.

3. Formátovače

Formátovače jsou ty, které formátují data. Vidíte, že zpracovatelé nemohou odesílat informace, protože se jedná o datový typ Pythonu. Než je lze někomu odeslat, je třeba je převést.

Záznamy jsou ve výchozím nastavení ve formátu Záznamy protokolu. To je třída předdefinovaná logovacím frameworkem. Vývojářům poskytuje různé metody, které mohou používat. Tento formát nelze přímo odeslat po síti ani zapsat do textového souboru. K jeho převodu nebo formátování potřebujeme formátovače. Pro různé obslužné programy existují různé formátovače.

Ve výchozím nastavení formátovače převedou záznam protokolu na řetězec. Toto chování lze snadno změnit a můžete si jej přizpůsobit podle svých představ. Tento formát může vycházet z obchodní logiky, kterou napíšeme v obslužných modulech.

4. Filtry

Poslední částí modulu protokolování jsou filtry. Filtry, jak název napovídá, filtrují zprávy. Ne každá zpráva, kterou předáme, musí být uložena nebo transportována. Nebo mohou existovat různé obsluhy pro různé zprávy. Toho všeho lze dosáhnout pomocí filtrů.

Filtry můžeme používat jak s loggery, tak s handlery.

Dobře, takže nyní jsme získali základní představu o modulu logování. Ten nám také poskytuje úrovně zpráv. Úrovně zpráv jsou definovány takto:

DEBUG: Jedná se o slovní systémové informace, když vše běží v pořádku. Sdělí vám přesnější údaje o stavu systému. Její bod závažnosti je 10.

INFO: Info poskytne méně slovních systémových informací, ale je podobné jako debug. Obecně sděluje přehled toho, co systém provádí. Jeho bod závažnosti je 20.

WARNING: Obsahuje informace týkající se problémů na nízké úrovni. Tyto problémy lze ignorovat, protože nezpůsobují zastavení systému. Přesto se doporučuje tyto problémy vyřešit.

Její bod závažnosti je 30.

ERROR: Tato zpráva je závažná. Chyba bude obsahovat informace o závažném problému, který se vyskytl. Problém mohl zastavit činnost programu a vyžaduje okamžitou pozornost.

Její bod závažnosti je 40.

CRITICAL: Nejkritičtější zpráva. Tato zpráva je vydána, když problém způsobil zastavení systému. To znamená, že se kvůli tomuto problému zastavila celá aplikace.

Její bod závažnosti je 50.

Bod závažnosti určuje, jakou prioritu má mít. Předpokládejme, že jsme nastavili úroveň protokolu na 30. Pak logger bude logovat nebo ukládat informace, pokud je úroveň větší nebo rovna 30. Stačí tedy potvrdit, jakou úroveň protokolování chcete. Více se o nich dozvíme v další části.

Logování můžeme snadno implementovat importem modulu. Protože se jedná o vestavěný modul, nemusíme ho instalovat přes pip.

Stačí zapsat do souboru Pythonu tento příkaz a můžeme používat loggery.

Kód:

import logginglogging.warning("DataFlair Logging Tutorials")

Výstup vygenerovaný kódem je hned níže. Jak vidíte, log se vypisuje na konzoli, má log-level, logger-name a message. root je výchozí logger-name. Tyto druhy funkcí budeme používat s našimi pohledy v Djangu.

Prozkoumejte kompletní výukový program o modulu logování Pythonu

Logování v Djangu

Django poskytuje logování pomocí modulu logování Pythonu. Modul logování lze snadno nakonfigurovat.

Když chceme používat logování v Django, je třeba dodržet určité kroky. Postup bude následující:

1. Naše nastavení.py nakonfigurujeme pro různé loggery, handlery, filtry.
2. Kód loggerů zahrneme do pohledů nebo jiného modulu Djanga, kde to bude potřeba.

Tak, začneme.

Vytvoříme nový projekt

Vytvoříme nový projekt pro logování. Protokolování pak můžete používat ve stávajících projektech. Chcete-li tedy vytvořit nový projekt, spusťte v příkazovém řádku tento příkaz:

$ django-admin startproject dataflairlogs

Tím se spustí nový projekt. Nyní budeme konfigurovat soubor settings.py projektu.

Konfigurace nastavení

Pro zahrnutí logování do Djanga musíme nakonfigurovat jeho nastavení. Udělat to je poměrně snadné. Konfigurací nastavení logování máme na mysli definování:

• Loggerů
• Handlerů
• Filtrů
• Formatterů

Protože Django pracuje s různými moduly, použijeme proto metodu dictConfig.

Existují i jiné surové metody, ale dictConfig je to, co Django používá jako výchozí chování.

Tento kód stačí zkopírovat do souboru settings.py

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

Pochopení kódu:

Vím, že kód je trochu rozsáhlý, ale je velmi snadno pochopitelný. Od Djanga dostáváme vestavěnou proměnnou LOGGING. Výchozí hodnoty logování pocházejí z tohoto slovníku. Protože konfigurujeme nastavení pomocí slovníku, nazývá se metoda dictConfig. Uvnitř slovníku LOGGING je několik důležitých klíčů:

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

Probereme je postupně. Klíč verze udává verzi schématu. Je důležité, aby měl hodnotu. Ve výchozím nastavení je to 1.

Dalším klíčem je disable_existing_loggers. Tento klíč slouží k tomu, aby Django nezakázalo loggery. Ve výchozím nastavení používá Django některé své vlastní loggery. Tyto loggery jsou propojeny s Django ORM a dalšími vnitřními částmi Djanga. Tento klíč je ve výchozím nastavení True. Tyto loggery tedy zakáže.

Existují různé dotazy do databáze a volání funkcí, které loggery zaznamenávají. Proto se doporučuje, abyste tento klíč neměli True.

Třetím klíčem jsou handlery. Jak jsme si řekli, handlery zpracovávají zprávy a předávají je do konzoly, souboru atd. Samotné handlery jsou slovníkem. Tento slovník-jména klíčů budou názvy handlerů. Existují různé handlery poskytované modulem logování. My zde používáme dva handlery.

1. FileHandler: logger-name – filehandler

FileHandler bude ukládat protokoly do souboru. Jak vidíte, název souboru jsme zadali jako dataflair-debug.log.

Úroveň určuje, do jaké úrovně bude logger odevzdávat logy.

Poznámka:

Soubory s logy se obecně ukládají s příponou .log. Tento soubor lze upravovat pouze s oprávněním. Lze jej pouze připojit.

2. StreamHandler: název loggeru – console

Obsluha streamu bude streamovat log na konzoli. Tato metoda není doporučená. Existuje omezení počtu znaků, dokud se v příkazovém řádku nezobrazí logy. Protože logy jsou příliš velké na zpracování příkazovým řádkem, proto potřebujeme file-handlery.

Existují další handlery jako mailhandler, AdminEmailHandler atd.

AdminEmailHandler je skvělým doplňkem opensource modulu.

Loggery jsou ty, které budou zaznamenávat informace o serveru nebo softwaru. Loggery jsou také typem slovníku. Má podobnou architekturu jako handlery. I když se liší atributy a dalšími vlastnostmi.

Django také poskytuje sadu loggerů. Existují různé loggery jako django, django.requests. a další.

Zkoušeli jste náš poslední návod Django request & response Tutorial

Nyní k implementaci logování stačí provést tyto kroky:

Spustit server.

$ python manage.py runserver

V okamžiku, kdy stisknete enter, objeví se řada logů a spousta toho. Stalo se tak proto, že jsme nastavili výchozí úroveň na ladění. Všechny tyto logy jsou vlastně zprávy z výchozích loggerů.

V následných souborech si můžete vytvořit vlastní loggery. Tímto způsobem můžete získat logy z konkrétních souborů.

Tady je výstup souboru, který se generuje po logování.

Tady jsou logy. Logů je hodně, ale upozorňuje se pouze na varování nebo vyšší úrovně.

Souhrn

Logování je docela důležité. Pokud je implementováno správně, pak vám může ušetřit spoustu času. Obecně se logování provádí až po dokončení projektu.

Modul logování je základem logování s Django nebo jiným projektem v Pythonu. Existují i další řešení, například celery, travis atd. Tyto obsluhy logů také usnadňují zpracování logů. Mohou usnadnit vyhledávání, zda události nastaly, nebo ne, a co bylo jejich příčinou.