collection de journaux d'erreurs Golang

La gestion des erreurs est particulièrement importante lors du développement d'une application Golang. La collecte des journaux d'erreurs est un lien très important, car elle peut nous aider à détecter les problèmes dans le programme à temps et elle peut également accélérer nos étapes de résolution des erreurs. Ci-dessous, nous expliquerons comment collecter les journaux d'erreurs dans Golang.

1. Utilisez la bibliothèque de journaux pour enregistrer les journaux d'erreurs

La bibliothèque de journaux intégrée de Golang fournit une fonction de journalisation simple et puissante qui peut répondre à la plupart des besoins d'impression. Grâce à la bibliothèque de journaux, nous pouvons afficher des informations vers la console, un fichier ou d'autres endroits. Dans le même temps, la bibliothèque de journaux prend également en charge l'enregistrement de journaux de différents niveaux.

L'utilisation de la bibliothèque de logs est très simple. Il vous suffit d'importer la bibliothèque de journaux et d'appeler la fonction Println() ou Fatal() dans le code. Par exemple :

import "log"

log.Println("This is a log message")
log.Fatalf("This is a fatal error message")

Utilisez la fonction Println() pour afficher des informations sur la console et la sortie standard. Utilisez la fonction Fatal() pour afficher les informations d'erreur et terminer le programme.

2. Utiliser des bibliothèques de journaux tierces

En plus d'utiliser la bibliothèque de journaux intégrée de Golang, nous pouvons également utiliser certaines bibliothèques de journaux tierces avancées. Telles que logrus, zap ou zerolog, etc., ces bibliothèques peuvent implémenter une journalisation personnalisée de manière plus flexible et peuvent également mieux répondre aux exigences de journalisation des différents projets.

1. Utilisez logrus

logrus est une bibliothèque de journalisation structurée qui peut réaliser une journalisation efficace et prend en charge plusieurs formats de journaux. En utilisant logrus, vous pouvez facilement exporter le format JSON et envoyer des journaux à des systèmes distants ou à d'autres enregistreurs tiers, tout en personnalisant les niveaux et les formats de journaux. Logrus est également très pratique à utiliser. Il vous suffit d'importer le package logrus et d'instancier un objet journal. Par exemple :

import (
  "github.com/sirupsen/logrus"
)

log := logrus.New()
log.SetFormatter(&logrus.JSONFormatter{})
log.SetLevel(logrus.DebugLevel)
log.WithFields(logrus.Fields{
  "animal": "walrus",
}).Info("A walrus appears")

2. Utilisez zap

zap est une bibliothèque de journalisation rapide et structurée conçue pour atteindre des performances élevées et qui peut être utilisée de manière flexible dans les environnements de production déployés. Dans zap, la journalisation est traitée comme une tâche, qui inclut la journalisation vers une source de sortie spécifiée (telle qu'un fichier ou MongoDB), et le niveau et le format de journalisation peuvent également être personnalisés. L'utilisation de zap peut enregistrer efficacement les activités des applications et vous pouvez facilement rechercher et localiser les problèmes lorsque vous devez les résoudre. Par exemple :

package main

import (
    "go.uber.org/zap"
)

func main() {
    logger, _ := zap.NewProduction()
    defer logger.Sync()
    logger.Info("logrus-start")
}

3. Utiliser un système de suivi distribué

Dans les grands systèmes distribués, l'utilisation d'une bibliothèque de journaux pour enregistrer les journaux d'erreurs peut ne pas répondre à nos besoins. Étant donné que le nombre de journaux d’erreurs est énorme et qu’un contrôle manuel est nécessaire, cette opération s’avère souvent très fastidieuse et prend beaucoup de temps. Dans ce cas, nous pouvons envisager d’utiliser des systèmes de traçage distribués tels que Jaeger, Zipkin et SkyWalking. Ces systèmes peuvent mieux nous aider à suivre la direction des requêtes et les informations sur les erreurs des systèmes distribués.

L'avantage de l'utilisation de ces systèmes est qu'ils peuvent nous aider à suivre et enregistrer les demandes dans les systèmes distribués et permettre une analyse transparente des demandes. Lorsque des problèmes surviennent, ces systèmes peuvent nous aider à détecter les défauts à temps et à les résoudre.

Lorsque nous utilisons un système de suivi distribué, nous devons ajouter le code de suivi correspondant à l'application. Par exemple, lorsque nous utilisons Jaeger, nous devons ajouter le code suivant au programme :

package main

import (
    "net/http"

    "github.com/opentracing/opentracing-go"
    "github.com/uber/jaeger-client-go"
    "github.com/uber/jaeger-client-go/config"
)

func main() {
    cfg := &config.Configuration{
        Sampler: &config.SamplerConfig{
            Type:  "const",
            Param: 1,
        },
        Reporter: &config.ReporterConfig{
            LogSpans:            true,
            LocalAgentHostPort:  "127.0.0.1:6831",
            BufferFlushInterval: 1 * time.Second,
        },
    }
    tracer, closer, err := cfg.New(
        "my-golang-app",
        config.Logger(jaeger.StdLogger),
    )
    if err != nil {
        log.Fatalf("Failed to create tracer: %v", err)
    }
    defer closer.Close()
    opentracing.SetGlobalTracer(tracer)
    r := http.NewServeMux()
    r.HandleFunc("/", handler)
    http.ListenAndServe(":8080", r)
}

Dans le code ci-dessus, nous utilisons le système de traçage distribué Jaeger pour suivre les applications Golang. Dans la configuration, nous définissons l'échantillonneur sur 1, confirmons le rapport du journal, l'adresse utilisée par l'agent local est "127.0.0.1:6831" et le temps de rafraîchissement du tampon est de 1 seconde. Après cela, nous avons défini un tracker global et l'avons défini comme tracker global pour opentracing.

4. Résumé

Dans le processus de développement de Golang, la collecte des journaux d'erreurs est un élément indispensable. La bibliothèque standard de Golang fournit une bibliothèque de journalisation simple et puissante, tandis que les bibliothèques de journalisation tierces offrent des fonctions de personnalisation plus flexibles. En particulier dans les grands systèmes distribués, l'utilisation de systèmes de traçage distribués peut nous aider à mieux collecter et dépanner les journaux d'erreurs. Lorsque nous utilisons une bibliothèque de journaux, nous devons choisir une bibliothèque de journaux appropriée en fonction des exigences spécifiques du projet et des scénarios d'application, et prêter attention à la collecte des informations clés du journal afin que nous puissions mieux localiser et résoudre les problèmes.

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!