Package Golang Logrus

Dans cette leçon sur le package Logrus à Golang, nous étudierons divers exemples sur l'efficacité de l'exploitation de l'exploitation. Nous allons commencer maintenant.

Commençant par aller

Voici la structure du répertoire que j'ai fait pour mon programme Hello World:

Voici le programme que nous avons créé:

package principal
Importer "FMT"
func main ()
fmt.Printf ("bonjour, monde.\ n ")

Nous pouvons exécuter le programme ci-dessus avec la commande suivante:

va courir bonjour.aller

Une fois que nous exécuterons cette commande, voici la sortie que vous verrez:

Maintenant ça a l'air bien. Passons à notre programme principal.

Package Logrus à Golang

Pour commencer à utiliser le package Logrus dans le programme Go, nous devons obtenir il. Exécutez la commande suivante:

va prendre -t github.com / sirupsen / logrus

Lorsque nous commençons à utiliser ce package dans Intellij, nous voyons cette erreur que nous pouvons résoudre en un seul clic:

Une fois que vous aurez obtenu le colis, nous pouvons commencer à l'utiliser. Commençons par un programme simple.

Journalisation de base avec Logrus

Nous commencerons avec un exemple de journalisation du niveau d'informations très basique. La journalisation peut être effectuée avec des messages de chaîne et des méta-données sous forme de paires de valeurs clés qui apparaissent comme la même.

package principal
importer (
Journal "github.com / sirupsen / logrus "
)
func main ()
enregistrer.Avec champs (journal.Des champs
"Site Web": "Linuxhint.com ",
"génial": 100,
"Aide": 200,
).Info ("Golang Pro")

Lorsque nous exécutons ce programme, nous pouvons voir la sortie suivante:

Maintenant c'est à la fois utile et coloré!

Divers niveaux de journalisation

Maintenant, nous allons essayer un autre exemple qui montrera l'utilisation de divers niveaux de journalisation disponibles dans Logrus et en général. Ils sont:

• Info
• Avertissement
• Fatal
• Déboguer
• Panique

Essayons de construire un programme et voyons comment ces niveaux de journal diffèrent lorsqu'ils apparaissent dans notre programme:

package principal
importer (
Journal "github.com / sirupsen / logrus "
)
func main ()
enregistrer.Avec champs (journal.Des champs
"Site Web": "Linuxhint.com ",
"génial": 100,
).Info ("Golang Pro Info Message")
enregistrer.Avec champs (journal.Des champs
"Site Web": "Linuxhint.com ",
"génial": 100,
).Warn ("Golang Pro Warn Message")
enregistrer.Avec champs (journal.Des champs
"Site Web": "Linuxhint.com ",
"génial": 100,
).Fatal ("Golang Pro Fatal Message")
enregistrer.Avec champs (journal.Des champs
"Site Web": "Linuxhint.com ",
"génial": 100,
).Panique ("Golang Pro Panic Message")
enregistrer.Avec champs (journal.Des champs
"Site Web": "Linuxhint.com ",
"génial": 100,
).Debug ("Golang Pro Debug Message")

Lorsque nous exécutons ce programme, nous verrons la sortie suivante:

Remarqué quelque chose? Les instructions du journal après l'instruction fatale n'apparaissent même pas dans notre sortie. En effet, dès qu'une erreur mortelle est reçue, l'exécution du programme s'arrête à Golang.

Modifions l'ordre de ces instructions et vérifions si certaines modifications de sortie sont également observées:

Cette fois, même le niveau de journal de panique a réagi de la même manière, mais la sortie était très différente et détaillée.

Avec le niveau de journal de panique, vous vous assurez que suffisamment d'informations sur la machine hôte également imprimées dans la sortie dans la console afin que le travail soit déborfable.

Moyen plus simple de créer des journaux

Dans les appels ci-dessus, les journaux étaient assez détaillés et avec des métadonnées également. Il existe un moyen plus facile de enregistrer vos messages. Essayons ceci maintenant:

package principal
importer (
Journal "github.com / sirupsen / logrus "
)
func main ()
enregistrer.Débogage ("Débogage des données ici.")
enregistrer.Info ("messages pour les informations communes")
enregistrer.Avertir ("vous devriez regarder cet avertissement!")
enregistrer.Erreur ("quelque chose a échoué mais le programme continuera.")
// appelle OS.Sortie (1) après journalisation
enregistrer.Fatal ("Je pars.")
// appelle panic () après journalisation
enregistrer.Panique ("Je ne serai pas imprimé :(")

Voici la sortie du programme:

Le comportement pour l'exploitation forestière était le même mais cette fois, ils étaient faciles à faire en une seule ligne.

Conclusion

Dans cet article, nous avons étudié des exemples simples mais utiles sur la façon dont nous pouvons enregistrer des messages importants avec une gravité et une verbosité différentes dans nos applications en utilisant le package Logrus avec Golang.