Registrazione di Django

Tutti gli sviluppatori fanno il debug degli errori. La risoluzione di questi errori richiede tempo. Aiuta nella maggior parte dei casi sapere quando e dove si è verificato l’errore. Direi che i messaggi di errore di Python sono abbastanza utili. Ma anche questi messaggi diventano inutili quando si parla di progetti con più file. Questo problema e molti altri vantaggi vengono con il logging.

Come sviluppatori Django, è importante che anche noi padroneggiamo il logging. Le tecnologie di backend hanno vari ottimi strumenti per implementare il logging. Anche Django fornisce supporto per vari framework e moduli di log. Noi lo implementeremo usando il modulo di base e uno dei più popolari, il modulo di logging.

In questo tutorial, impareremo a conoscere il logging. I contenuti saranno:

• Che cos’è il logging?
• Modulo di log in Python
• Logging in Django

Pronto per imparare.

Che cos’è il Logging?

Il logging è una tecnica o un mezzo che ci permette di tracciare alcuni eventi durante l’esecuzione del software. È una tecnica importante per gli sviluppatori. Li aiuta a tracciare gli eventi. La registrazione è come un paio di occhi in più per loro. Gli sviluppatori non sono solo responsabili della creazione di software ma anche della loro manutenzione. La registrazione aiuta immensamente quella parte della manutenzione.

Tiene traccia di ogni evento che si verifica in ogni momento. Questo significa che invece dei lunghi traceback si ottiene molto di più. Questa volta quando si verifica un errore si può vedere in quale situazione si trovava il sistema. Questo metodo vi aiuterà a risolvere gli errori rapidamente. Poiché sarete in grado di dire dove si è verificato l’errore.

Come funziona? Qual è l’idea dietro?

La registrazione è gestita da un programma separato. Questo programma di registrazione è semplicemente uno scrittore di file. Si dice che il logger registri certi eventi in formato testo. Le informazioni registrate vengono poi salvate in file. I file per questo sono chiamati log. I log sono semplici file salvati con estensione log. Contengono i log degli eventi accaduti.

Bene, questa è solo una delle implementazioni più usate, come potete vedere. Dato che stiamo solo immagazzinando le informazioni, puoi trovare altri modi per gestirle.

Ok, ci è chiaro che il logging è importante. È difficile? No, assolutamente no, amico. La registrazione non è affatto difficile. Chiunque conosca un po’ la configurazione può usarlo.

Essendo un programmatore Python, qui hai anche delle caratteristiche extra. Abbiamo un intero modulo che ci permette di fare proprio questo. Per quanto riguarda gli altri linguaggi, ci sono molti moduli, Java ha Log4j e JavaScript ha il suo loglevel. Anche tutti questi sono strumenti incredibili. Ok, qui ci occuperemo di Python (il mio linguaggio preferito).

Modulo di log in Python

Il modulo di log è un modulo integrato in Python. Viene preinstallato con Python 3. Il modulo di registrazione è usato per tenere traccia degli eventi che si verificano durante l’esecuzione del programma. Questo può essere esteso a qualsiasi numero di programmi e quindi per il software, è facile da impostare e utilizzare.

Perché usare il modulo di registrazione?

Come sviluppatore, possiamo chiedere perché usare il modulo di registrazione. Tutto ciò che fa il logging è scrivere su un file o stamparlo sulla console. Tutto ciò può essere ottenuto utilizzando le istruzioni di stampa. Allora che bisogno c’è di un modulo di log? Questa è una domanda valida. La risposta è che il logging è un modulo che dà ciò che print non può fare.

Utilizziamo la funzione print per emettere qualcosa sulla console. Così, quando si verifica una funzione, possiamo ottenere una dichiarazione di stampa che la funzione è stata eseguita. Mentre questo approccio funziona con le applicazioni più piccole, è inefficiente.

La funzione print diventa parte del vostro programma e se il software smette di funzionare, non avrete il risultato. Inoltre, se succede qualcosa e il sistema si riavvia, anche la console viene cancellata. Quindi, cosa farete allora? La risposta è il modulo di logging.

Il modulo di logging è capace di:

• Esecuzione multithreading
• Categorizzazione dei messaggi attraverso diversi livelli di log
• È molto più flessibile e configurabile
• Dà un’informazione più strutturata

Così, ci sono 4 parti principali del modulo di logging. Le guarderemo una per una.

1. I logger

I logger sono gli oggetti con cui gli sviluppatori hanno a che fare. Possono essere intesi come una funzione che viene invocata quando viene chiamata. Noi usiamo i logger nei nostri file di progetto. Così, quando la funzione viene invocata, otteniamo un rapporto dettagliato. Il logger può generare più livelli di risposte. Possiamo personalizzarlo al massimo.

2. Gestori

I gestori sono gli oggetti che emettono le informazioni. Pensate a loro come gestori di giornali. Il loro compito principale è quello di trasmettere le informazioni. Questo può essere ottenuto scrivendo le informazioni in un file di log (il comportamento predefinito). Ci sono vari gestori forniti dal modulo di logging.

Possiamo facilmente impostare più gestori per lo stesso logger. Ci sono anche gestori SMTP che inviano i record di log per posta. I gestori di solito contengono la logica di business per le informazioni di log.

3. Formattatori

I formattatori sono quelli che formattano i dati. Vedete, i gestori non possono inviare le informazioni perché è un tipo di dati Python. Prima che possano essere inviati a qualcuno, devono essere convertiti.

I log sono di default nel formato Log Records. Questa è la classe predefinita dal framework dei log. Fornisce vari metodi agli sviluppatori da utilizzare. Quel formato non può essere inviato direttamente su una rete o scritto in un file di testo. Per convertirlo o formattarlo, abbiamo bisogno di formattatori. Ci sono diversi formattatori per diversi gestori.

Per impostazione predefinita, i formattatori convertiranno il Log Record in stringa. Questo comportamento può essere facilmente cambiato e si può personalizzare come si vuole. Questo formato può essere basato sulla logica di business che scriviamo in Handlers.

4. Filters

L’ultimo pezzo del modulo di log è filters. I filtri, come suggerisce il nome, filtrano i messaggi. Non tutti i messaggi che passiamo devono essere memorizzati o trasportati. Oppure ci possono essere diversi gestori per diversi messaggi. Tutto questo è possibile con l’aiuto dei filtri.

Possiamo usare i filtri sia con i logger che con i gestori.

Ok, ora abbiamo un’idea di base del modulo di registrazione. Ci fornisce anche i livelli di messaggio. I livelli di messaggio sono definiti come:

DEBUG: sono informazioni di sistema verbose quando tutto funziona bene. Vi dirà dettagli più precisi sullo stato del sistema. Il suo punto di gravità è 10.

INFO: L’info produrrà informazioni di sistema meno verbose ma è simile al debug. Generalmente fornisce una panoramica di ciò che il sistema sta eseguendo. Il suo punto di gravità è 20.

WARNING: Questo contiene informazioni riguardanti problemi di basso livello. I problemi possono essere ignorati in quanto non causano l’arresto del sistema. Tuttavia, si raccomanda che questi problemi siano risolti.

Il suo punto di gravità è 30.

ERROR: Questo messaggio è grave. L’errore conterrà informazioni sul problema grave che si è verificato. Il problema può aver fermato il funzionamento del programma e necessita di attenzione immediata.

Il suo punto di gravità è 40.

CRITICAL: Il messaggio più critico. Questo messaggio viene emesso quando il problema ha causato l’arresto del sistema. Ciò significa che l’intera applicazione si è fermata a causa di questo problema.

Il suo punto di gravità è 50.

Il punto di gravità determina quale priorità deve essere data. Supponiamo di impostare il livello di log a 30. Allora il logger registrerà o memorizzerà le informazioni quando il livello è maggiore o uguale a 30. Quindi, avete solo bisogno di confermare quale livello di log volete. Ne sapremo di più nella sezione successiva.

Possiamo facilmente implementare il logging importando il modulo. Dal momento che è un modulo integrato, non abbiamo bisogno di installarlo tramite pip.

Basta scrivere questo nel tuo file Python e possiamo usare logger.

Codice:

import logginglogging.warning("DataFlair Logging Tutorials")

L’output generato dal codice è proprio qui sotto. Come potete vedere, il log viene stampato sulla console, ha log-level, logger-name e message. root è il logger-name predefinito. Useremo questo tipo di funzioni con le nostre viste in Django.

Esplora un tutorial completo sul modulo di log di Python

Il log in Django

Django fornisce il log usando il modulo di log di Python. Il modulo di log può essere facilmente configurato.

Quando vogliamo usare il log in Django ci sono alcuni passi da seguire. La procedura sarà la seguente:

1. Configureremo il nostro settings.py per i vari logger, gestori, filtri.
2. Includeremo il codice dei logger nelle viste o in qualsiasi altro modulo di Django dove necessario.

Ok, quindi cominciamo.

Creiamo un nuovo progetto

Creiamo un nuovo progetto per la registrazione. Potrai poi usare la registrazione nei progetti esistenti. Quindi, per creare un nuovo progetto, esegui questo comando nella linea di comando:

$ django-admin startproject dataflairlogs

Questo avvierà il nuovo progetto. Ora, configureremo settings.py del progetto.

Configurazione delle impostazioni

Per includere il logging in Django, dobbiamo configurare le sue impostazioni. Farlo è abbastanza facile. Per configurare le impostazioni di log, intendiamo definire:

• Loggers
• Handlers
• Filters
• Formatters

Siccome Django lavora con diversi moduli, usiamo il metodo dictConfig.

Ci sono anche altri metodi grezzi, ma dictConfig è il comportamento predefinito di Django.

Basta copiare questo codice nel tuo settings.py

Codice:

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

Capire il codice:

Lo so che il codice è un po’ grande ma è molto facile da capire. Abbiamo una variabile integrata LOGGING da Django. I valori di default del logging provengono da questo dizionario. Dato che stiamo configurando le impostazioni utilizzando un dizionario, si chiama il metodo dictConfig. Ci sono alcune chiavi importanti all’interno del dizionario LOGGING.

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

Discutiamole una per una. La chiave version dice la versione dello schema. È importante che abbia un valore. Di default è 1.

La prossima chiave è disable_existing_loggers. Questa chiave serve a dire a Django di non disabilitare i logger. Per impostazione predefinita, Django utilizza alcuni dei propri logger. Questi logger sono collegati con Django ORM e altre parti interne di Django. Questa chiave è di default True. Quindi, disabiliterà quei logger.

Ci sono varie query di database e chiamate di funzioni che i logger registrano. Perciò, si raccomanda di non fare True questa chiave.

Handlers è la terza chiave. Come abbiamo discusso, i gestori gestiscono il messaggio e lo passano a console, file, ecc. I gestori stessi sono un dizionario. I nomi delle chiavi del dizionario saranno i nomi dei gestori. Ci sono vari gestori forniti dal modulo di registrazione. Qui stiamo usando due gestori.

1. FileHandler: logger-name – filehandler

Il FileHandler memorizzerà i log in un file. Come puoi vedere, abbiamo dato il nome del file come dataflair-debug.log.

Il livello definisce, fino a quale livello il logger deve impegnare i log.

Nota:

I file di log sono generalmente memorizzati con estensione .log. Questo file può essere modificato solo con i permessi. Può essere solo aggiunto.

2. StreamHandler: nome del logger – console

Il gestore del flusso trasmetterà il log su console. Questo non è un metodo raccomandato. C’è un limite di caratteri fino a quando la linea di comando mostra i log. Poiché i log sono troppo grandi per essere gestiti dalla linea di comando, abbiamo bisogno di gestori di file.

Ci sono altri gestori come mailhandler, AdminEmailHandler ecc.

L’AdminEmailHandler è una grande aggiunta al modulo opensource.

I logger sono quelli che registrano le informazioni sul tuo server o software. I logger sono anche un tipo di dizionario. Ha un’architettura simile a quella dei gestori. Anche se ci sono diversi attributi e altre proprietà.

Django fornisce anche un insieme di logger. Ci sono vari logger come django, django.requests. e altri.

Hai controllato il nostro ultimo Django request & response Tutorial

Ora, per implementare il logging, devi solo seguire questi passi:

Avvia il tuo server.

$ python manage.py runserver

Nel momento in cui premi enter ci sarà una serie di log e molti di questi. Questo è successo perché abbiamo impostato il livello di default a debug. Tutti questi log sono in realtà messaggi dai logger di default.

Puoi creare i tuoi logger personalizzati nei file consecutivi. In questo modo puoi ottenere i log da file specifici.

Ecco l’output del file che viene generato dopo la registrazione.

Questi sono i log. Ci sono molti log, ma solo i livelli di avvertimento o superiori saranno notificati.

Sommario

Il log è piuttosto importante. Se è implementato correttamente, allora può farvi risparmiare un sacco di tempo. Generalmente, la registrazione viene fatta dopo che il progetto è stato completato.

Il modulo di registrazione è la base della registrazione con Django o un altro progetto python. Ci sono anche altre soluzioni come, celery, travis ecc. Questi gestori di log rendono anche facile la gestione dei log. Possono facilitare il compito di cercare se gli eventi si sono verificati o meno e qual è stata la causa.