Golang est un langage de programmation efficace et supérieur aux autres langages à bien des égards. La journalisation est une tâche critique lorsqu'il s'agit d'enregistrer le comportement de votre application. Dans Golang, la journalisation est cruciale pour le débogage et le test des applications.

Cet article présentera la méthode de connexion dans Golang. Nous discuterons des enregistreurs de la bibliothèque standard ainsi que des bibliothèques tierces.

Utilisez la bibliothèque standard pour vous connecter

La bibliothèque standard de Golang possède un package appelé "log", qui fournit un moyen simple de se connecter. Ce package fournit trois niveaux de journalisation : Informations, Avertissement et Erreur.

Vous devez d'abord importer l'enregistreur :

import "log"

1. Enregistrer les informations

Enregistrer les informations en appelant la fonction "log.Println()". Il enregistre un message dans la sortie d'erreur standard.

log.Println("Record this info")

Ce code affichera des informations similaires aux suivantes :

2019/11/22 20:04:14 Record this info

2. Enregistrer les avertissements

Enregistrer les avertissements en appelant la fonction "log.Println()". Il enregistre un avertissement sur l'erreur standard et ajoute "WARN" au message.

log.Println("WARN: Warning message here")

Ce code affichera des informations similaires aux suivantes :

2019/11/22 20:05:20 WARN: Warning message here

3. Logging Errors

Enregistre les erreurs en appelant la fonction "log.Println()". Il enregistre une erreur dans l'erreur standard et ajoute "ERREUR" au message.

log.Panicln("ERROR: error message here")

Ce code affichera des informations similaires aux suivantes :

2019/11/22 20:06:28 ERROR: error message here
panic: ERROR: error message here

goroutine 1 [running]:
log.Panicln(0xc42000e170, 0x1, 0x1)
        /usr/local/go/src/log/log.go:341 +0xc4
main.main()
        /root/go/src/main.go:10 +0x55
exit status 2

Le code ci-dessus provoquera la panique du programme. Lorsqu'une erreur se produit, le programme se termine immédiatement après avoir enregistré l'erreur et génère des informations détaillées sur l'erreur.

Utilisation de bibliothèques tierces pour la journalisation

La fonctionnalité de journalisation fournie par la bibliothèque standard a ses limites. Vous pouvez utiliser des bibliothèques tierces pour étendre les capacités de journalisation. Étant donné que les bibliothèques de journalisation tierces offrent des fonctionnalités riches, elles sont plus pratiques pour le débogage et les tests d'applications.

Ici, nous prenons comme exemple la bibliothèque de classes "go-logging". Il peut enregistrer plusieurs niveaux de journalisation (Info, Avertissement, Erreur et Débogage).

Première installation de "go-logging":

go get github.com/op/go-logging

Importer la bibliothèque:

import (
     "github.com/op/go-logging"
     "os"
)

1. Initialiser l'enregistreur

Utilisez la fonction "logging.MustGetLogger()" pour initialiser l'enregistreur. Vous pouvez éventuellement spécifier un nom comme paramètre pour l'identifier entre plusieurs enregistreurs.

var log = logging.MustGetLogger("example")

2. Définir le niveau de journalisation

Après avoir initialisé l'enregistreur, vous pouvez utiliser la fonction "log.SetLevel()" pour définir le niveau de journalisation. Cette fonction accepte un paramètre de type logging.Level (incluant Debug, Info, Warning et Error).

logging.SetLevel(logging.DEBUG, "example")

3. Créez un enregistreur de fichiers

Créez un enregistreur de fichiers en utilisant la fonction "os.Create()":

logFile, err := os.Create("app.log")
if err != nil {
     log.Error("Cannot create log file", err)
}
defer logFile.Close()

4. Créez un formateur

Créez un formateur pour formater les entrées du fichier journal :

formatter := logging.MustStringFormatter(
"%{time:2006/01/02 15:04:05.000} %{shortfile} %{level:.6s} %{message}")

5. Configuration de l'enregistreur de fichiers

Créez un enregistreur de fichiers via la fonction "logging.NewBackendFormatter()":

backend := logging.NewBackendFormatter(
 logging.NewLogBackend(logFile, "", 0),
 formatter)

6. Ajoutez l'enregistreur de fichiers au logger

Vous devez ajouter l'enregistreur de fichiers avant de l'ajouter. l'enregistreur de fichiers est intégré dans un backend :

logging.SetBackend(backend)

Ou ajoutez plusieurs enregistreurs :

logging.SetBackend(logging.MultiLogger(
     logging.MultiWriter(os.Stdout, logFile),
     logging.MultiWriter(os.Stderr, logFile),
))

7. Journalisation

Maintenant, vous pouvez utiliser le niveau transmis par l'enregistreur pour "enregistrer" les informations du journal :

log.Infof("This is a info message with %d", 123)
log.Warningf("This is a warning message with %s", "param")
log.Errorf("This is a error message with %v", err)

Le code ci-dessus log est formaté au fur et à mesure de sa journalisation, puis écrit dans le fichier journal.

Résumé :

La bibliothèque standard de Golang fournit une méthode de journalisation simple. Cependant, l'utilisation d'une bibliothèque tierce vous donne un meilleur contrôle sur le comportement et le format de l'enregistreur. En utilisant la bibliothèque « logging », vous pouvez enregistrer plusieurs niveaux de journalisation et les écrire dans un fichier.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!