Protokollebenen in Go

Sheeraz Gul 20 Juni 2023

Go Go Logging

Protokollebenen in Go
Loglevel in Go mit zerolog
Loglevel in Go mit Logrus

Dieses Tutorial zeigt, wie Sie Protokollebenen in Golang erstellen und verwenden.

Protokollebenen in Go

Golang bietet ein Paket für die Protokollierung namens log an, bei dem es sich um ein einfaches Protokollierungspaket handelt. Dieses Paket bietet keine abgestufte Protokollierung; Wenn wir eine abgestufte Protokollierung wünschen, müssen wir manuell Präfixe wie debug, info und warn hinzufügen.

Sogar das Golang-Paket log verfügt nicht über die Leveled-Log-Funktionalität, bietet aber dennoch die grundlegenden Tools zur manuellen Implementierung von Log-Levels. Versuchen wir ein einfaches Beispiel für das Golang-Paket log:

package main

import "log"

func main() {
    log.Println("Hello, This is delftstack.com!")
}

Der obige Code protokolliert den angegebenen Inhalt und druckt ihn. Siehe die Ausgabe:

2009/11/10 23:00:00 Hello, This is delftstack.com!

Aber was ist mit Protokollebenen? Wie oben erwähnt, können wir benutzerdefinierte Protokollebenen und einen benutzerdefinierten Logger erstellen.

Wir können die Methode log.New() verwenden, die die folgenden drei Parameter benötigt, um einen neuen Logger zu erstellen:

out - out wird verwendet, um die Schnittstelle io.writer zu implementieren, um die Protokolldaten zu schreiben.
Präfix - Ein Präfix ist eine Zeichenfolge, die am Anfang jeder Zeile hinzugefügt wird.
flag - Das flag wird verwendet, um festzulegen, welche Eigenschaften vom Logger verwendet werden.

Jetzt werden normalerweise sieben Protokollebenen verwendet:

Protokollebene	Beschreibung
`Trace`	Niedrigstes Level
`Debug`	Zweites Level
`Info`	Drittes Level
`Warn`	Vierte Ebene
`Error`	Fünfte Ebene
`Fatal`	Sechste Ebene
`Panic`	Höchstes Level

Versuchen wir ein Beispiel, um benutzerdefinierte Protokollierungsebenen basierend auf den Ebenen Info, Warnung, Debug und Fehler zu erstellen:

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "os"
)

var (
    Warning_Level *log.Logger
    Info_Level    *log.Logger
    Debug_Level   *log.Logger
    Error_Level   *log.Logger
)

func init() {
    file, err := os.OpenFile("Demo_logs.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666)
    if err != nil {
        log.Fatal(err)
    }

    Info_Level = log.New(file, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
    Warning_Level = log.New(file, "WARNING: ", log.Ldate|log.Ltime|log.Lshortfile)
    Debug_Level = log.New(file, "Debug: ", log.Ldate|log.Ltime|log.Lshortfile)
    Error_Level = log.New(file, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile)
}

func main() {
    Info_Level.Println("Loading the application.")
    Info_Level.Println("Loading taking time.")
    Warning_Level.Println("There is warning.")
    Debug_Level.Println("Here is debugging information.")
    Error_Level.Println("An Error Occured.")

    // read the log file
    data, err := ioutil.ReadFile("Demo_logs.txt")

    if err != nil {
        log.Panicf("failed reading data from file: %s", err)
    }
    fmt.Printf("\nThe file data is : %s", data)
}

Der obige Code erstellt benutzerdefinierte Protokollebenen mit dem Paket log von Golang und schreibt die Protokollinformationen in eine Datei. Siehe die Ausgabe:

The file data is : INFO: 2009/11/10 23:00:00 prog.go:32: Loading the application.
INFO: 2009/11/10 23:00:00 prog.go:33: Loading taking time.
WARNING: 2009/11/10 23:00:00 prog.go:34: There is warning.
Debug: 2009/11/10 23:00:00 prog.go:35: Here is debugging information.
ERROR: 2009/11/10 23:00:00 prog.go:36: An Error Occured.

Program exited.

Fatal- und Panic-Stufen können auch die Beendigung eines Programms oder einer Anwendung verursachen, weshalb es unmöglich ist, diese Protokollierungsstufen mit einem eingebauten log-Paket zu erstellen. Aber außer dem Paket log bieten einige Protokollpakete von Drittanbietern sieben integrierte Protokollebenen. Lassen Sie uns sie erkunden.

Loglevel in Go mit `zerolog`

zerolog ist eine Drittanbieter-Bibliothek für Golang, die für die strukturierte JSON-Protokollierung verwendet wird. Das zerolog stellt einen globalen Logger zur Verfügung, der zusammen mit dem Unterpaket log für einfaches Logging verwendet werden kann.

Neben dem einfachen Logging bietet zerolog auch eingebaute Loglevels. Es gibt sieben Protokollebenen in zerolog, darunter Info, Warnung, Debug, Error und Trace.

Das zerolog-Paket wird auf GitHub bereitgestellt und kann in Golang mit dem folgenden Befehl heruntergeladen werden:

go get -u github.com/rs/zerolog/log

Die Nutzung der Loglevel ist mit zerolog sehr einfach. Siehe das Beispiel unten:

package main

import (
    "github.com/rs/zerolog"
    "github.com/rs/zerolog/log"
)

func main() {
    zerolog.SetGlobalLevel(zerolog.InfoLevel)

    log.Trace().Msg("Tracing..")
    log.Info().Msg("The file is loading.")
    log.Debug().Msg("Here is some useful debugging information.")
    log.Warn().Msg("There is a warning!")
    log.Error().Msg("An Error Occured.")
    log.Fatal().Msg("An Fatal Error Occured.")
    log.Panic().Msg("This is a panic situation.")

}

Der obige Code protokolliert die Informationen basierend auf den Protokollebenen. Siehe die Ausgabe:

{"level":"info","time":"2009-11-10T23:00:00Z","message":"The file is loading."}
{"level":"warn","time":"2009-11-10T23:00:00Z","message":"There is a warning!"}
{"level":"error","time":"2009-11-10T23:00:00Z","message":"An Error Occured."}
{"level":"fatal","time":"2009-11-10T23:00:00Z","message":"An Fatal Error Occured."}

Program exited.

Loglevel in Go mit `Logrus`

Logrus ist ein weiteres Paket eines Drittanbieters für Golang, das die Protokollierung in JSON bereitstellt. Das Paket Logrus wird auf GitHub bereitgestellt und kann mit dem folgenden Befehl in cmd heruntergeladen werden:

go get "github.com/Sirupsen/logrus"

Logrus stellt die sieben Protokollebenen bereit, darunter Trace, Debug, Info, Warn, Error, Fatal und Panic, sortiert nach Schweregrad. Die Verwendung dieser Protokollebenen ähnelt auch dem zerolog, wo wir das Unterpaket log verwenden müssen.

Probieren wir ein Beispiel mit Log-Levels aus dem Logrus:

package main

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

func main() {
    log.SetFormatter(&log.JSONFormatter{})
    log.SetLevel(log.DebugLevel)
    log.SetLevel(log.TraceLevel)
    //log.SetLevel(log.PanicLevel)

    log.Trace("Tracing the log info, Lowest level")
    log.Debug("Debugging information. Level two")
    log.Info("Log Info. Level three")
    log.Warn("This is warning. Level Four")
    log.Error("An error occured. Level Five")
    // Calls os.Exit(1) after logging
    log.Fatal("Application terminated. Level Six")
    // Calls panic() after logging
    log.Panic("Panic Situation. Highest Level.")

}

Der obige Code protokolliert die Informationen basierend auf Levels mit dem Logrus-Paket. Wir müssen die Ebenen so einstellen, dass einige der Protokollebenen angezeigt werden.

Siehe die Ausgabe:

{"level":"trace","msg":"Tracing the log info, Lowest level","time":"2009-11-10T23:00:00Z"}
{"level":"debug","msg":"Debugging information. Level two","time":"2009-11-10T23:00:00Z"}
{"level":"info","msg":"Log Info. Level three","time":"2009-11-10T23:00:00Z"}
{"level":"warning","msg":"This is warning. Level Four","time":"2009-11-10T23:00:00Z"}
{"level":"error","msg":"An error occured. Level Five","time":"2009-11-10T23:00:00Z"}
{"level":"fatal","msg":"Application terminated. Level Six","time":"2009-11-10T23:00:00Z"}

Program exited.

Autor: Sheeraz Gul

Sheeraz is a Doctorate fellow in Computer Science at Northwestern Polytechnical University, Xian, China. He has 7 years of Software Development experience in AI, Web, Database, and Desktop technologies. He writes tutorials in Java, PHP, Python, GoLang, R, etc., to help beginners learn the field of Computer Science.

LinkedIn Facebook

Protokollebenen in Go

Loglevel in Go mit zerolog

Loglevel in Go mit Logrus

Loglevel in Go mit `zerolog`

Loglevel in Go mit `Logrus`