Pacchetto Golang Logrus

In questa lezione sul pacchetto Logrus a Golang, studieremo vari esempi su come la registrazione efficace può essere eseguita in Go e vedere quanto sono importanti i registri nel linguaggio di programmazione Go. Inizieremo ora.

A partire da Go

Ecco la struttura della directory che ho realizzato per il mio programma Hello World:

Ecco il programma che abbiamo creato:

Pacchetto principale
Importa "FMT"
func main ()
fmt.Printf ("Ciao, mondo.\N")

Possiamo eseguire il programma sopra con il comando seguente:

Vai a correre ciao.andare

Una volta eseguito questo comando, ecco l'output che vedrai:

Ora sembra buono. Passiamo alla nostra agenda principale.

Pacchetto Logrus in Golang

Per iniziare a utilizzare il pacchetto Logrus nel programma GO, dobbiamo Ottenere Esso. Esegui il seguente comando:

vai a prendere -t github.com/sirupsen/logrus

Quando iniziamo a utilizzare questo pacchetto in Intellij, vediamo questo errore che possiamo risolvere in un clic:

Una volta ottenuto il pacchetto, possiamo iniziare a usarlo. Cominciamo con un semplice programma.

Registrazione di base con Logrus

Inizieremo con un esempio di registrazione del livello di informazioni molto basilare. La registrazione può essere eseguita con messaggi di stringa e metadati sotto forma di coppie di valore chiave che appaiono come lo stesso.

Pacchetto principale
importazione (
registro "github.com/sirupsen/logrus "
)
func main ()
tronco d'albero.Withfields (registro.Campi
"Sito web": "Linuxhint.com ",
"Fantastico": 100,
"Aiuto": 200,
).Info ("Golang Pro")

Quando eseguiamo questo programma, possiamo vedere il seguente output:

Questo è sia utile che colorato!

Vari livelli di registrazione

Ora proveremo un altro esempio che mostrerà l'uso di vari livelli di registrazione disponibili in Logrus e in generale. Sono:

• Informazioni
• Avvertimento
• Fatale
• Debug
• Panico

Proviamo a costruire un programma e vediamo in che modo questi livelli di registro differiscono quando appaiono nel nostro programma:

Pacchetto principale
importazione (
registro "github.com/sirupsen/logrus "
)
func main ()
tronco d'albero.Withfields (registro.Campi
"Sito web": "Linuxhint.com ",
"Fantastico": 100,
).Info ("Messaggio di informazioni di Golang pro")
tronco d'albero.Withfields (registro.Campi
"Sito web": "Linuxhint.com ",
"Fantastico": 100,
).Warn ("Messaggio di Golang Pro Warn")
tronco d'albero.Withfields (registro.Campi
"Sito web": "Linuxhint.com ",
"Fantastico": 100,
).Fatal ("Golang Pro Fatal Message")
tronco d'albero.Withfields (registro.Campi
"Sito web": "Linuxhint.com ",
"Fantastico": 100,
).Panico ("Messaggio di panico Golang pro")
tronco d'albero.Withfields (registro.Campi
"Sito web": "Linuxhint.com ",
"Fantastico": 100,
).Debug ("Messaggio di debug Golang pro")

Quando eseguiamo questo programma, vedremo il seguente output:

Notato qualcosa? Le dichiarazioni di registro dopo l'istruzione fatale non compaiono nemmeno nel nostro output. Questo perché non appena viene ricevuto un errore fatale, l'esecuzione del programma si ferma a Golang.

Modifichiamo l'ordine di queste dichiarazioni e controllia se si osservano anche alcune modifiche nell'output:

Questa volta, anche il livello di log di panico ha reagito allo stesso modo, ma l'output era molto diverso e dettagliato.

Con il livello di registro di panico, ti assicuri che anche informazioni sufficienti sulla macchina host stamparono nell'output nella console in modo che il lavoro sia debuggable.

Modo più semplice per fare tronchi

Nelle chiamate sopra, i registri erano piuttosto dettagliati e anche con metadati. C'è un modo più semplice per registrare i tuoi messaggi. Proviamo questo ora:

Pacchetto principale
importazione (
registro "github.com/sirupsen/logrus "
)
func main ()
tronco d'albero.Debug ("Debuging Data qui.")
tronco d'albero.Info ("Messaggi per informazioni comuni")
tronco d'albero.Warn ("Dovresti guardare questo avvertimento!")
tronco d'albero.Errore ("qualcosa non è riuscito ma il programma continuerà.")
// chiama il sistema operativo.Esci (1) dopo la registrazione
tronco d'albero.Fatale ("Sto partendo.")
// chiama panico () dopo aver registrato
tronco d'albero.Panico ("Non sarò stampato :(")

Ecco l'output per il programma:

Il comportamento per la registrazione era lo stesso, ma questa volta erano facili da fare in una sola linea.

Conclusione

In questo post, abbiamo studiato esempi semplici ma utili su come possiamo registrare messaggi importanti con diversa gravità e verbosità nelle nostre applicazioni utilizzando il pacchetto Logrus con Golang.