Sammlung von Golang-Fehlerprotokollen

Die Fehlerbehandlung ist besonders wichtig bei der Entwicklung einer Golang-Anwendung. Die Erfassung von Fehlerprotokollen ist ein sehr wichtiger Link, da sie uns dabei helfen kann, Probleme im Programm rechtzeitig zu finden und unsere Schritte zur Fehlerbehebung zu beschleunigen. Im Folgenden stellen wir vor, wie Fehlerprotokolle in Golang erfasst werden.

1. Verwenden Sie die Protokollbibliothek, um Fehlerprotokolle aufzuzeichnen.

Die integrierte Protokollbibliothek von Golang bietet eine einfache und leistungsstarke Protokollierungsfunktion, die die meisten Druckanforderungen erfüllen kann. Über die Protokollbibliothek können wir Informationen an die Konsole, in Dateien oder an andere Orte ausgeben. Gleichzeitig unterstützt die Protokollbibliothek auch die Aufzeichnung von Protokollen unterschiedlicher Ebenen.

Die Protokollbibliothek ist sehr einfach zu verwenden. Importieren Sie einfach die Protokollbibliothek und rufen Sie die Funktion Println() oder Fatal() im Code auf. Zum Beispiel:

import "log"

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

Verwenden Sie die Funktion Println(), um Informationen an die Konsole und die Standardausgabe auszugeben. Verwenden Sie die Funktion Fatal(), um Fehlerinformationen auszugeben und das Programm zu beenden.

2. Verwenden Sie eine Protokollbibliothek eines Drittanbieters

Zusätzlich zur Verwendung der integrierten Protokollbibliothek von Golang können wir auch einige erweiterte Protokollbibliotheken von Drittanbietern verwenden. Diese Bibliotheken wie Logrus, Zap oder Zerolog usw. können benutzerdefinierte Protokolle flexibler implementieren und auch die Protokollierungsanforderungen verschiedener Projekte besser erfüllen.

1. Logrus verwenden

Logrus ist eine strukturierte Protokollierungsbibliothek, die eine effiziente Protokollierung erreichen kann und mehrere Protokollformate unterstützt. Mit Logrus können Sie problemlos das JSON-Format exportieren und Protokolle an Remote-Systeme oder andere Logger von Drittanbietern senden und gleichzeitig Protokollebenen und -formate anpassen. Logrus ist außerdem sehr benutzerfreundlich. Sie müssen lediglich das Logrus-Paket importieren und ein Protokollobjekt instanziieren. Zum Beispiel:

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. Verwenden Sie zap

zap ist eine schnelle, strukturierte Protokollierungsbibliothek, die auf hohe Leistung ausgelegt ist und flexibel in einer Produktionsumgebung eingesetzt werden kann. In zap wird die Protokollierung als Aufgabe behandelt, die die Protokollierung in einer bestimmten Ausgabequelle (z. B. einer Datei oder MongoDB) umfasst. Protokollebene und -format können ebenfalls angepasst werden. Mit Zap können Anwendungsaktivitäten effektiv aufgezeichnet werden, und Sie können Probleme leicht finden und lokalisieren, wenn Sie sie beheben müssen. Zum Beispiel:

package main

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

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

3. Verwenden Sie ein verteiltes Ablaufverfolgungssystem.

In großen verteilten Systemen entspricht die Verwendung einer Protokollbibliothek zum Aufzeichnen von Fehlerprotokollen möglicherweise nicht unseren Anforderungen. Da die Anzahl der Fehlerprotokolle sehr groß ist und eine manuelle Überprüfung erforderlich ist, ist dies oft sehr umständlich und zeitaufwändig. In diesem Fall können wir die Verwendung verteilter Verfolgungssysteme wie Jaeger, Zipkin und SkyWalking in Betracht ziehen. Diese Systeme können uns besser dabei helfen, die Anforderungsrichtung und Fehlerinformationen verteilter Systeme zu verfolgen.

Der Vorteil der Verwendung dieser Systeme besteht darin, dass sie uns dabei helfen können, Anfragen in verteilten Systemen zu verfolgen und aufzuzeichnen und eine transparente Analyse der Anfragen zu ermöglichen. Wenn Probleme auftreten, können uns diese Systeme helfen, Fehler rechtzeitig zu erkennen und Fehler zu beheben.

Bei Verwendung eines verteilten Tracking-Systems müssen wir der Anwendung den entsprechenden Tracking-Code hinzufügen. Wenn wir beispielsweise Jaeger verwenden, müssen wir dem Programm den folgenden Code hinzufügen:

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)
}

Im obigen Code verwenden wir das verteilte Tracing-System von Jaeger, um die Golang-Anwendung zu verfolgen. In der Konfiguration setzen wir den Sampler auf 1, bestätigen die Protokollberichterstattung, die vom lokalen Agenten verwendete Adresse lautet „127.0.0.1:6831“ und die Pufferaktualisierungszeit beträgt 1 Sekunde. Danach haben wir einen globalen Tracker definiert und ihn als globalen Tracker für Opentracing festgelegt.

4. Zusammenfassung

Im Golang-Entwicklungsprozess ist die Erfassung von Fehlerprotokollen ein unverzichtbarer Bestandteil. Die Standardbibliothek von Golang bietet eine einfache und leistungsstarke Protokollierungsbibliothek, während Protokollierungsbibliotheken von Drittanbietern flexiblere Anpassungsfunktionen bieten. Insbesondere in großen verteilten Systemen kann uns die Verwendung verteilter Ablaufverfolgungssysteme dabei helfen, Fehlerprotokolle besser zu erfassen und zu beheben. Bei der Verwendung einer Protokollbibliothek müssen wir eine geeignete Protokollbibliothek basierend auf spezifischen Projektanforderungen und Anwendungsszenarien auswählen und darauf achten, wichtige Protokollinformationen zu sammeln, damit wir Probleme besser lokalisieren und lösen können.

Das obige ist der detaillierte Inhalt vonSammlung von Golang-Fehlerprotokollen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!