Comment utiliser les journaux personnalisés dans Go ?

La journalisation est un aspect très important dans Go. Lors du développement d'une application, vous devez enregistrer le comportement de l'application en un seul endroit afin de pouvoir enquêter et dépanner si nécessaire. Le package de journalisation de la bibliothèque standard fournit certaines fonctions de journalisation de base, mais dans les applications réelles, des outils de journalisation plus complexes et avancés peuvent être nécessaires. C'est là que la journalisation personnalisée entre en jeu.

Dans cet article, nous apprendrons comment utiliser les journaux personnalisés dans Go.

1. Créer un enregistreur personnalisé

Bien que le package de journaux de la bibliothèque standard puisse déjà répondre aux besoins de base en matière de journalisation, veuillez noter que le package de journaux a ses limites. Vous souhaiterez peut-être des contrôles de niveau inférieur et plus personnalisés. Par conséquent, nous utiliserons le package tiers « zap » pour créer un enregistreur personnalisé.

Pour utiliser zap, vous devez d'abord l'installer, ce qui peut être fait avec la commande suivante :

go get -u go.uber.org/zap

Une fois l'installation terminée, vous pouvez créer un enregistreur de base :

package main

import "go.uber.org/zap"

func main() {
    logger, err := zap.NewProduction()
    if err != nil {
        panic(err)
    }

    logger.Info("Hello, world!")
}

Dans l'exemple de code ci-dessus, nous avons utilisé NewProduction () Fonction pour créer un enregistreur de niveau production.

Bien sûr, cela ne suffit pas pour répondre aux besoins, nous devons définir notre propre enregistreur. Vous pouvez créer un enregistreur générique en utilisant zap.NewDevelopment() ou zap.NewProduction(), mais pour les applications complexes, vous devrez peut-être créer un enregistreur personnalisé.

Dans l'exemple de code ci-dessous, nous définissons un enregistreur personnalisé nommé "myLogger" :

package main

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

func main() {
    cfg := zap.Config{
        Encoding:         "console",
        Level:            zap.NewAtomicLevelAt(zapcore.DebugLevel),
        OutputPaths:      []string{"stdout"},
        ErrorOutputPaths: []string{"stderr"},
        EncoderConfig: zapcore.EncoderConfig{
            TimeKey:        "timestamp",
            MessageKey:     "message",
            CallerKey:      "caller",
            EncodeTime:     zapcore.ISO8601TimeEncoder,
            EncodeDuration: zapcore.StringDurationEncoder,
            EncodeCaller:   zapcore.ShortCallerEncoder,
        },
    }

    logger, err := cfg.Build()
    if err != nil {
        panic(err)
    }

    logger.Debug("Debug message")
    logger.Info("Info message")
    logger.Warn("Warn message")
    logger.Error("Error message")
}

Dans l'exemple ci-dessus, nous définissons d'abord une structure de configuration nommée "cfg". La structure de configuration contient tous les paramètres requis par l'enregistreur, tels que le format de sortie, le niveau de journalisation, l'emplacement de sortie, etc.

Ensuite, nous utilisons la fonction cfg.Build() pour créer le logger. Cela nous donnera un enregistreur avec des paramètres personnalisés que nous pourrons utiliser pour imprimer les messages du journal. Dans l'exemple ci-dessus, nous avons imprimé différents niveaux de messages de journal.

2. Ajouter des informations contextuelles

Une fonctionnalité importante des enregistreurs personnalisés est la possibilité d'ajouter des informations contextuelles. En ajoutant des informations contextuelles, vous pouvez mieux comprendre ce qui s'est passé et localiser rapidement le problème.

Dans l'exemple ci-dessous, nous utilisons la fonction logger.With() pour ajouter un champ contextuel appelé "user_id" :

package main

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

func main() {
    cfg := zap.Config{
        Encoding:         "console",
        Level:            zap.NewAtomicLevelAt(zapcore.DebugLevel),
        OutputPaths:      []string{"stdout"},
        ErrorOutputPaths: []string{"stderr"},
        EncoderConfig: zapcore.EncoderConfig{
            TimeKey:        "timestamp",
            MessageKey:     "message",
            CallerKey:      "caller",
            EncodeTime:     zapcore.ISO8601TimeEncoder,
            EncodeDuration: zapcore.StringDurationEncoder,
            EncodeCaller:   zapcore.ShortCallerEncoder,
        },
    }

    logger, err := cfg.Build()
    if err != nil {
        panic(err)
    }

    userId := "user123"
    logger = logger.With(zap.String("user_id", userId))

    logger.Info("Info message")
}

Dans l'exemple ci-dessus, nous créons un nouvel enregistrement à l'aide du périphérique de fonction logger.With(). Il contiendra un champ contextuel appelé "user_id" avec la valeur "user123".

Cela est très utile dans les applications du monde réel, car vous pouvez facilement comprendre quels utilisateurs utilisent le système et résoudre les problèmes liés aux utilisateurs.

3. Connectez-vous au fichier

Par défaut, les enregistreurs personnalisés enregistrent les messages sur la sortie standard. Cependant, dans les applications réelles, vous devez enregistrer les messages de journal dans des fichiers pour faciliter la gestion et le déploiement des journaux.

zap logger fournit plusieurs types de sortie tels que fichier, stdout et stderr. En fonction de votre application, vous pouvez choisir le type de sortie.

Dans l'exemple ci-dessous, nous nous connectons à un fichier :

package main

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

func main() {
    cfg := zap.Config{
        Encoding:         "console",
        Level:            zap.NewAtomicLevelAt(zapcore.DebugLevel),
        OutputPaths:      []string{"myapp.log"},
        ErrorOutputPaths: []string{"myapp.log"},
        EncoderConfig: zapcore.EncoderConfig{
            TimeKey:        "timestamp",
            MessageKey:     "message",
            CallerKey:      "caller",
            EncodeTime:     zapcore.ISO8601TimeEncoder,
            EncodeDuration: zapcore.StringDurationEncoder,
            EncodeCaller:   zapcore.ShortCallerEncoder,
        },
    }

    logger, err := cfg.Build()
    if err != nil {
        panic(err)
    }

    logger.Info("Testing log file...")
}

Dans l'exemple ci-dessus, nous fournissons le chemin du fichier dans les champs OutputPaths et ErrorOutputPaths, ce qui obligera l'enregistreur à écrire des messages de journal dans myapp.log dans le fichier. .

Pour résumer, les enregistreurs personnalisés offrent plus de flexibilité et de capacités de personnalisation afin que vous puissiez répondre aux besoins des applications réelles. Avec les enregistreurs personnalisés, vous pouvez facilement enregistrer toute information spécifique et faciliter le traitement et l'analyse des données du journal en cas de besoin.

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!