Python Json Logging

La registrazione ci consente di tenere traccia degli eventi che si verificano mentre alcuni software funzionano. Quando il software fallisce e non abbiamo record di registrazione, ci sono pochissime possibilità che avremmo capito la radice del problema. Ma con i record di registrazione, possiamo mantenere tutti i guasti. Anche se, quando un sistema deve analizzare i registri che non seguono uno schema o un modulo predefinito, le cose si complicano. Python, quindi, contiene JSON che organizza i dati in modo formattato usando oggetti che aderiscono a uno schema specificato. Python-Json-Logger è il modulo di registrazione Python standard che visualizza gli eventi di registro come oggetto JSON. Il modulo JSON Logger migliora la leggibilità della macchina dei nostri registri e impedisce la creazione dei parser unici per le voci del tipo syslog.

Come usare la registrazione di Python Json?

La libreria "Python_json_logger" è richiesta per i registri nel formato JSON. Possiamo installare questa libreria Python con il comando PIP. Quello che segue è il comando per installarlo. Quando è installato, il prompt visualizza anche il messaggio di conferma con la versione recente della libreria.

PIP Installa Python-Json-Logger

Esempio 1:

L'utilizzo di base del modulo di registrazione è relativamente semplice e può essere utilizzato per accedere agli eventi in file. Qui, forniamo per la prima volta la semplice implementazione della registrazione di Python. Creiamo il registro e lo configurano utilizzando il metodo di baseconfig (). Questo metodo prende il nome del file in cui vengono creati i registri perché il file dato è aperto nella modalità Write "W". Il formato è anche impostato per i registri. Quindi, dichiariamo l'oggetto "logger" in cui con il metodo getLogger (). Restituiamo il logger con il nome assegnato.

Successivamente, il livello del logger viene regolato tramite il metodo setlevel () per fungere da soglia di tracciamento per il debug che si basa sui valori numerici assegnati a ciascun livello. Successivamente, distribuiamo alcuni metodi della classe di logger, incluso il messaggio particolare come parametro. Il metodo Debug () stampa il messaggio di debug. Il metodo Info () genera un messaggio che viene effettuato l'accesso a questo logger con il livello di informazioni. Quindi, il metodo critico () mostra il livello critico del logger dato. I metodi di avvertimento () ed errori () mostrano l'avvertimento per il logger e qualsiasi eccezione sollevata dal logger.

Registrazione di importazione
registrazione.BasicConfig (fileName = "newFile.tronco d'albero",
format = ' %(asctime) s %(messaggio) s', fileMode = 'w')
logger = registrazione.getLogger ()
Logger.setLevel (registrazione.Debug)
Logger.Debug ("Dichiarazione di debug sicura")
Logger.info ("è un'informazione")
Logger.AVVERTENZA ("Genera avvertimento")
Logger.Errore ("Errore si verifica i.E quando dividi per zero ")
Logger.critico ("connessione Internet è lenta")

Il programma crea un file con il nome dato. Quando apriamo il file, contiene le informazioni rispetto a ciascun metodo di logger specificato che è elencato nel seguente:

Esempio 2:

Nel programma di cui sopra, abbiamo la funzionalità di registrazione Python. Ora abbiamo un programma in cui viene utilizzata la libreria di logger JSON Python per archiviare i registri nel formato JSON utilizzando i metodi di registrazione integrati. Qui, iniziamo il codice di registrazione Python JSON inserendo il modulo di registrazione e il modulo JSONLOGGER per la classe Pythonjsonlogger. Successivamente, dichiariamo l'oggetto "formatter" impostato con il metodo JSONFORMATER () per ottenere i risultati in formato JSON. Quindi, definiamo l'oggetto "JSON_HANDLER" per invocare il metodo filehandler () che fornisce il file JSON fornito.

Successivamente, impostiamo il formato per il file JSON utilizzando il metodo setFormatter () in cui l'oggetto formatter viene passato come input. Quindi, otteniamo l'oggetto del logger dal metodo getLogger (). Il "json_handler" viene aggiunto tramite il metodo AddHandler (). Alla fine, il logger.Metodo Errore () che incontra qualsiasi errore dalla registrazione in formato JSON qui.

Registrazione di importazione
da Pythonjsonlogger import jsonlogger
formatter = jsonlogger.JSONFORMATER ()
json_handler = registrazione.Filehandler (fileName = 'newlog.json ')
json_handler.SetFormatter (formatter)
logger = registrazione.getLogger ('my_json')
Logger.AddHandler (JSON_HANDLER)
Logger.Errore ('un errore riscontrato', extra = 'type': 'fatal')

Il seguente registro JSON è creato nel "newlog.File JSON "Quando lo apriamo dal modulo JSONLOGGER di Python:

Esempio 3:

Il formato di registro JSON di base è riportato nell'esempio precedente. Ora dimostriamo l'eccezione e il traceback della formattazione del registro in JSON usando il modulo JSONLOGGER. I traceback forniscono informazioni specifiche sul fallimento del programma, quindi registrarli spesso è prezioso. Possiamo usare la registrazione.Metodo di eccezione che è un modulo di registrazione Python integrato per registrare gli errori e aggiungere i nostri messaggi di errore personalizzati.

Inoltre, registrazione.Il metodo Except () ha un errore di gravità predefinita. Innanzitutto, utilizziamo l'istruzione di importazione del caricamento del modulo di registrazione e del modulo JSONLOGGER per i registri JSON. Dopo questo, creiamo l'istanza del registro utilizzando il metodo getLogger () per accedere al logger. L'eccezione del registro e il traceback vengono gestiti e generati nel "BadcalCulationDemo.File JSON ".

Successivamente, forniamo il metodo JSONFORMATTER () nell'oggetto "Formatter" per formattare i registri nella struttura JSON e impostare il formattatore fornito con il setFormatter. Quindi, aggiungiamo il gestore "LogHandlerjson" creato al metodo AddHandler (). Il blocco Try-Except viene impiegato per catturare i registri dal seguente traceback. Qui, abbiamo un'istruzione di prova in cui l'intero è diviso per il valore della stringa che è una pratica di calcolo negativa. L'istruzione TRANT cattura questa eccezione del registro nella registrazione.Eccezione () che stampa il messaggio fornito insieme a un rapporto di Traceback nel formato JSON al BadcalCulationDemo.file json.

Registrazione di importazione
da Pythonjsonlogger import jsonlogger
MyLogger = registrazione.getLogger ()
LogHandlerjson = registrazione.Filehandler ("BadCalCulationDemo.json ")
formatter = jsonlogger.JSONFORMATER ()
LogHandlerjson.SetFormatter (formatter)
Mylogger.AddHandler (LogHandlerjson)
Tentativo:
1 / "Milk"
tranne:
registrazione.Eccezione ("Il tuo calcolo è stato cattivo")

Quando viene eseguito lo script, viene visualizzato un oggetto JSON Stringefied in BadcalCulationDemo.Il contenuto di JSON File. Quella che segue è l'immagine del BadMathdemo.File JSON che visualizza il messaggio di errore con le informazioni di Traceback:

Esempio 4:

Gli attributi con i personaggi specifici per JSON potrebbero causare corrompere l'oggetto JSON. Possiamo personalizzare il sistema di registrazione univoco utilizzando la classe Formatter e consentire al modulo JSON di sfuggire in modo appropriato a tutti gli attributi. Qui, forniamo la registrazione JSON personalizzata che fornisce gli attributi aggiuntivi per gli eventi dei registri. Inseriamo i moduli JSON, Logging e Sys per creare gli eventi di registro del nostro sistema. Quindi, stabiliamo la classe "JSONFORMATER" che prende la registrazione input e il formatter come parametri. Dopo questo, creiamo gli attributi "Self" e "Records" per questa classe.

Quindi, generiamo l'oggetto "extra" in cui viene chiamato il metodo getattr () per accedere alla registrazione.Attributi Logrecord nel formato JSON. Il record JSON viene utilizzato per ottenere il tempo, il nome di livello, il nome del file, il numero di riga e il messaggio fornito per il registro del sistema.

Inoltre, estraiamo anche ulteriori dettagli sui registri di sistema. Quindi, usiamo il JSON.Metodo dump () in cui l'oggetto Python “JSON_RECORD” viene passato per la conversione nell'oggetto JSON. Gli attributi JSON di Python sono configurati dalla definizione del metodo JSONConfig (). La tecnica IF-ELSE viene utilizzata per creare il gestore personalizzato che fornisce i registri nel file specificato o nella forma del flusso di output sulla console. Il logger di root è configurato con il gestore personalizzato. Quindi, invochiamo il metodo JSONConfig () e il metodo di registrazione che forniscono il livello dei messaggi di registro sotto forma di JSON.

Importa JSON, registrazione, sys
Classe JsonFormatter (registrazione.Formatter):
DEF FORMAT (self, record):
extra = getattr (record, "__dict__", )
json_record =
"Tempo": extra.get ("definito"),
"Livello": getattr (record, "levelname", nessuno),
"File": getattr (record ", file file", nessuno),
"Line": getattr (record, "Lineno", nessuno),
"Msg": getattr (record, "msg", nessuno),
"aggiuntivo_detail": extra.get ("aggiuntivo_detail"),

Restituisce JSON.dumps (json_record)
DEF JSONConfig (nome file = nessuno):
Se nome file:
gestore = registrazione.Filehandler (nome file)
altro:
gestore = registrazione.StreamHandler (sys.stdout)
gestore.setFormatter (jsonFormatter ())
registrazione.getLogger ().AddHandler (gestore)
jsonconfig ()
registrazione.getLogger ().setLevel (registrazione.Debug)
registrazione.Debug ("Esempio di Python")
registrazione.AVVERTENZA ("Logging json", extra = "aggiuntivo_detail": 999)

Lo script di registrazione di Python JSON genera l'output dei seguenti dizionari JSON:

Conclusione

Il modo migliore per organizzare i registri e centralizzare la loro visualizzazione è con la registrazione di Python Json e un programma di gestione dei registri. Per formattare e ottenere i dettagli più pertinenti, dovremmo anche esaminare le procedure di registrazione di Python. È importante essere informati delle nostre restrizioni di registro Python JSON perché potrebbero impedirci di dare un contributo significativo. L'evento di registrazione sotto forma di oggetti JSON è molto meglio del semplice testo. Utilizzando un linguaggio di query basato su JSON, è semplice aggiungere i record ai database utilizzando il formato JSON.