Django Logging

Toți dezvoltatorii depanează erorile. Rezolvarea acestor erori necesită timp. În cele mai multe cazuri, este de ajutor să știm când și unde a apărut eroarea. Aș spune că mesajele de eroare din Python sunt destul de utile. Dar chiar și aceste mesaje devin inutile atunci când vorbim de proiecte cu mai multe fișiere. Această problemă și multe alte beneficii vin odată cu logarea.

Ca dezvoltatori Django, este important să stăpânim și noi logarea. Tehnologiile backend au diverse instrumente excelente pentru a implementa logarea. Și Django oferă suport pentru diverse cadre și module de logare. Îl vom implementa folosind modulul de bază și unul dintre cele mai populare, logging.

În acest tutorial, vom învăța despre logging. Conținutul va fi:

• Ce este logarea?
• Modul de logare Python
• Logare în Django

Pregătiți să învățați. Să începem.

Ce este Logging?

Logging-ul este o tehnică sau un mediu care ne poate permite să urmărim unele evenimente pe măsură ce software-ul se execută. Este o tehnică importantă pentru dezvoltatori. Îi ajută pe aceștia să urmărească evenimentele. Logging-ul este ca un set suplimentar de ochi pentru ei. Dezvoltatorii nu sunt responsabili doar de crearea de software, ci și de întreținerea acestora. Logging-ul ajută enorm la această parte a întreținerii.

Întocmește fiecare eveniment care apare în orice moment. Asta înseamnă că, în loc de urmăriri lungi, obțineți mult mai mult. De data aceasta când apare o eroare puteți vedea în ce situație se afla sistemul. Această metodă vă va ajuta să rezolvați rapid erorile. Deoarece veți putea spune unde a apărut eroarea.

Cum funcționează? Care este ideea din spatele ei?

Legistrările sunt gestionate de un program separat. Acel program de logare este pur și simplu un program de scriere de fișiere. Se spune că loggerul înregistrează anumite evenimente în format text. Informațiile înregistrate sunt apoi salvate în fișiere. Fișierele pentru aceasta se numesc jurnale. Jurnalele sunt simple fișiere salvate cu extensia log. Ele conțin jurnalele evenimentelor apărute.

Ei bine, aceasta este doar una dintre cele mai utilizate implementări, după cum puteți vedea. Din moment ce noi doar stocăm informațiile, puteți veni cu mai multe moduri de a le trata.

Bine, ne este clar că logarea este importantă. Este dificil? Nu, absolut deloc, amice. Consemnarea nu este deloc dificilă. Oricine știe un pic despre configurație poate folosi acest lucru.

Fiind programator Python, primești și caracteristici suplimentare aici. Avem un întreg modul care ne permite să realizăm exact asta. În ceea ce privește alte limbaje, există multe module, Java are Log4j și JavaScript are propriul loglevel. Toate acestea sunt, de asemenea, instrumente uimitoare. Bine, deci ne vom ocupa aici de Python (limbajul meu preferat).

Modulul de logare în Python

Modul de logare este un modul încorporat în Python. Acesta vine preinstalat cu Python 3. Modulul de logare este utilizat pentru a ține evidența evenimentelor care au loc pe măsură ce programul rulează. Acesta poate fi extins la orice număr de programe și, astfel, pentru software, este ușor de configurat și utilizat.

De ce să folosim modulul de logare?

Ca dezvoltator, ne putem întreba de ce să folosim modulul de logare. Tot ceea ce face logging-ul este să scrie într-un fișier sau să îl tipărească pe consolă. Toate acestea pot fi realizate prin utilizarea instrucțiunilor print. Atunci de ce este nevoie de un modul de logare?. Aceasta este o întrebare valabilă. Răspunsul la aceasta este că logging este un modul care oferă ceea ce nu poate oferi print.

Utilizăm funcția print pentru a scoate ceva pe consolă. Astfel, atunci când apare o funcție, putem obține o declarație de tipărire că funcția a fost executată. Deși această abordare funcționează în cazul aplicațiilor mai mici, este ineficientă.

Funcția print devine parte a programului dvs. și, dacă software-ul nu mai funcționează, nu veți obține rezultatul. De asemenea, dacă se întâmplă ceva și sistemul se repornește, consola este de asemenea liberă. Așadar, ce veți face atunci? Răspunsul la această întrebare este modulul de logare.

Modul de logare este capabil de:

• Execuție multithreading
• Categorizarea mesajelor prin diferite niveluri de logare
• Este mult mai flexibil și configurabil
• Dă o informație mai structurată

Deci, există 4 părți principale ale modulului de logare. Le vom analiza una câte una.

1. Loggerii

Loggerii sunt obiectele cu care se ocupă dezvoltatorii. Ele pot fi înțelese ca o funcție care va fi invocată atunci când sunt apelate. Utilizăm loggerii în fișierele noastre de proiect. Astfel, atunci când funcția este invocată, obținem un raport detaliat. Loggerul poate genera mai multe niveluri de răspunsuri. Îl putem personaliza la maxim.

2. Handlers

Handlerii sunt obiectele care emit informații. Gândiți-vă la ele ca la gestionarii de ziare. Sarcina lor principală este de a transmite informația. Acest lucru poate fi realizat prin scrierea informațiilor într-un fișier jurnal (Comportamentul implicit). Există diverși gestionari furnizați de modulul de logare.

Potem configura cu ușurință mai mulți gestionari pentru același logger. Există, de asemenea, gestionari SMTP care vă vor trimite prin poștă înregistrările de jurnal. Manipulatorii conțin, de obicei, logică de afaceri pentru înregistrarea informațiilor.

3. Formatatori

Formatoarele sunt cele care formatează datele. Vedeți că handlerii nu pot trimite informațiile, deoarece este un tip de date Python. Înainte de a putea fi trimisă cuiva, trebuie să fie convertită.

Legistrele sunt, în mod implicit, în format Log Records. Aceasta este clasa predefinită de cadrul de logare. Acesta oferă diverse metode pe care dezvoltatorii le pot utiliza. Acest format nu poate fi trimis direct printr-o rețea sau scris într-un fișier text. Pentru a-l converti sau formata, avem nevoie de formatatori. Există formatatori diferiți pentru gestionari diferiți.

În mod implicit, formatoarele vor converti înregistrarea jurnalului în String. Acest comportament poate fi schimbat cu ușurință și puteți personaliza acest lucru după cum doriți. Acest format se poate baza pe logica de afaceri pe care o scriem în Handlers.

4. Filtre

Ultima piesă a modulului de logare sunt filtrele. Filtrele, după cum sugerează și numele, filtrează mesajele. Nu toate mesajele pe care le transmitem trebuie să fie stocate sau transportate. Sau pot exista gestionari diferiți pentru diferite mesaje. Toate acestea se pot realiza cu ajutorul filtrelor.

Potem folosi filtre atât cu loggerii, cât și cu gestionarii.

Ok, deci acum avem o idee de bază a modulului de logare. Acesta ne oferă, de asemenea, niveluri de mesaje. Nivelurile de mesaje sunt definite după cum urmează:

DEBUG: Este o informație de sistem veridică atunci când totul merge bine. Vă va spune detalii mai precise despre starea sistemului. Punctul său de severitate este 10.

INFO: Info va produce informații de sistem mai puțin verbose, dar este similar cu debug. În general, spune o imagine de ansamblu a ceea ce execută sistemul. Punctul său de severitate este 20.

WARNING: Acesta conține informații referitoare la probleme de nivel scăzut. Problemele pot fi ignorate deoarece nu cauzează oprirea sistemului. Deși, se recomandă ca aceste probleme să fie rezolvate.

Punctul său de gravitate este 30.

ERROR: Acest mesaj este grav. Eroarea va conține informații despre problema majoră care a apărut. Este posibil ca problema să fi oprit funcționarea programului și necesită atenție imediată.

Punctul său de gravitate este 40.

CRITICAL: Cel mai critic mesaj. Acest mesaj este emis atunci când problema a dus la oprirea sistemului. Aceasta înseamnă că întreaga aplicație s-a oprit din cauza acestei probleme.

Punctul său de gravitate este 50.

Punctul de gravitate determină ce prioritate trebuie acordată. Să presupunem că am setat nivelul de jurnal la 30. Atunci loggerul va înregistra sau va stoca informațiile atunci când nivelul este mai mare sau egal cu 30. Așadar, trebuie doar să confirmați ce nivel de logare doriți. Vom afla mai multe despre acestea în secțiunea următoare.

Potem implementa cu ușurință logarea prin importul modulului. Deoarece este un modul încorporat, nu trebuie să îl instalăm prin pip.

Simplu scrieți acest lucru în fișierul Python și putem folosi loggerii.

Cod:

import logginglogging.warning("DataFlair Logging Tutorials")

Import logging output generat de cod este chiar mai jos. După cum puteți vedea, jurnalul este tipărit pe consolă, are log-level, logger-name și message. root este logger-name implicit. Vom folosi aceste tipuri de funcții cu vizualizările noastre în Django.

Explorați un tutorial complet despre modulul de logare Python

Logare în Django

Django oferă logare prin utilizarea modulului de logare din Python. Modulul de logare poate fi configurat cu ușurință.

Când dorim să folosim logarea în Django există anumiți pași care trebuie urmați. Procedura va fi următoarea:

1. Ne vom configura fișierul nostru settings.py pentru diverși loggers, handlers, filtre.
2. Vom include codul loggerilor în vizualizări sau în orice alt modul din Django acolo unde este necesar.

Bine, deci să începem.

Crearea unui nou proiect

Vom crea un nou proiect pentru logging. Puteți folosi apoi logarea în proiectele existente. Deci, pentru a crea un nou proiect, executați această comandă în linia de comandă:

$ django-admin startproject dataflairlogs

Aceasta va porni noul proiect. Acum, vom configura settings.py al proiectului.

Configurarea setărilor

Pentru a include logarea în Django, trebuie să configurăm setările acestuia. A face acest lucru este destul de ușor. Prin configurarea setărilor de logare, ne referim la definirea:

• Loggers
• Handlers
• Filters
• Formatters

Din moment ce Django lucrează cu diferite module, prin urmare, folosim metoda dictConfig.

Există și alte metode brute, dar dictConfig este ceea ce reprezintă comportamentul implicit al lui Django.

Copiați pur și simplu acest cod în fișierul dvs. settings.py

Cod:

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

Înțelegeți codul:

Știu că codul este un pic cam mare, dar este foarte ușor de înțeles. Primim o variabilă încorporată LOGGING de la Django. Valorile implicite ale logării provin din acest dicționar. Deoarece configurăm setările folosind un dicționar, se numește metoda dictConfig. Există câteva chei importante în interiorul dicționarului LOGGING.

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

Să le discutăm una câte una. Cheia version spune versiunea schemei. Este important ca aceasta să aibă valoare. În mod implicit, este 1.

Următoarea cheie este disable_existing_loggers. Această cheie are rolul de a-i spune lui Django să nu dezactiveze loggerii. În mod implicit, Django utilizează unii dintre loggerii proprii. Aceste loggere sunt conectate cu Django ORM și cu alte părți interne ale Django. Această cheie este în mod implicit True (Adevărat). Deci, aceasta va dezactiva acele loggere.

Există diverse interogări ale bazei de date și apeluri de funcții pe care loggerii le înregistrează. Prin urmare, este recomandat să nu dați True acestei chei.

Handlers este a 3-a cheie. După cum am discutat, handlerii gestionează mesajele și le transmit către consolă, fișier etc. Handlers în sine este un dicționar. Acele nume de chei din dicționar vor fi numele gestionarilor. Există diverși gestionari furnizați de modulul de logare. Noi folosim aici doi gestionari.

1. FileHandler: logger-name – filehandler

FileHandler va stoca jurnalele într-un fișier. După cum puteți vedea, am dat numele fișierului ca dataflair-debug.log.

Nivelul definește, până la ce nivel loggerul trebuie să comită jurnalele.

Nota:

Filele jurnal sunt în general stocate cu extensia .log. Acest fișier poate fi editat numai cu permisiuni. El poate fi doar adăugat.

2. StreamHandler: nume logger – console

Managerul de flux va transmite jurnalul pe consolă. Aceasta nu este o metodă recomandată. Există o limită de caractere până când linia de comandă vă arată jurnalele. Deoarece jurnalele sunt prea mari pentru a fi gestionate prin linia de comandă, prin urmare, avem nevoie de gestionari de fișiere.

Există mai mulți gestionari, cum ar fi mailhandler, AdminEmailHandler etc.

AdminEmailHandler este o mare adiție la modulul opensource.

Loggerii sunt cei care vor înregistra informațiile serverului sau ale software-ului dumneavoastră. Loggerii sunt, de asemenea, un tip de dicționar. Are o arhitectură similară cu cea a handlerilor. Deși, există atribute diferite și alte proprietăți.

Django oferă, de asemenea, un set de loggere. Există diferiți loggeri cum ar fi django, django.requests. și multe altele.

Ai verificat cel mai recent tutorial Django request & response

Acum, pentru a implementa logging-ul, trebuie doar să urmați acești pași:

Porniți serverul.

$ python manage.py runserver

În momentul în care apăsați enter vor apărea o serie de loguri și multe altele. Acest lucru s-a întâmplat pentru că am setat nivelul implicit la debug. Toate aceste jurnale sunt de fapt mesaje de la loggerii impliciți.

Vă puteți crea loggeri personalizați în fișierele consecutive. În acest fel puteți obține jurnalele din fișiere specifice.

Iată ieșirea fișierului care este generat după logare.

Acestea sunt jurnalele. Există o mulțime de jurnale, dar numai nivelurile de avertizare sau cele de mai sus vor fi notificate.

Rezumat

Loggingul este destul de important. Dacă este implementată corect, atunci vă poate economisi mult timp. În general, logarea se face după ce proiectul este finalizat.

Modul Logging reprezintă elementele de bază ale logării cu Django sau un alt proiect python. Există și alte soluții, cum ar fi, celery, travis etc. Aceste gestionari de jurnal facilitează, de asemenea, gestionarea jurnalelor. Ele pot ușura sarcina de a căuta dacă evenimentele au avut loc sau nu și care a fost cauza.