Go Iris Protokolle

Anwendungsdatei Recorder

func main() {
    app := iris.Default()
    // In eine Datei aufzeichnen
    // Automatisch Farben deaktivieren beim Schreiben in eine Datei
    f, _ := os.Create("iris.log")
    app.Logger().SetOutput(f)

    // Wenn Sie Protokolle sowohl in eine Datei als auch in die Konsole schreiben möchten, verwenden Sie den folgenden Code
    // app.Logger().AddOutput(os.Stdout)

    app.Get("/ping", func(ctx iris.Context) {
        ctx.WriteString("pong")
    })

   app.Listen(":8080")
}

Steuern der Protokollausgabe Farbe

Standardmäßig wird die Protokollausgabe auf der Konsole je nach erkanntem TTY farbig dargestellt.

Passen Sie die Level-Titel, Text, Farbe und Stil in regulären Fällen an.

Importieren von golog und pio:

import (
    "github.com/kataras/golog"
    "github.com/kataras/pio"
    // [...]
)

Holen Sie sich ein Level zur Anpassung, wie z.B. DebugLevel:

level := golog.Levels[golog.DebugLevel]

Sie haben die vollständige Kontrolle über den Text, den Titel und den Stil des Levels:

// Level-Name
// Kleinbuchstabennamen werden verwendet,
// um den Zeichenfolgen-Level in den richtigen Level-Typ zu konvertieren.
Name string
// Alternative Namen sind die Namen, mit denen auf diesen bestimmten Protokoll-Level verwiesen werden kann,
// z.B. Name = "warn"
// Alternative Namen = []string{"warning"}, dies ist ein optionales Feld,
// deshalb behalten wir den Namen als einfachen String bei und erstellen dieses neue Feld.
AlternativeNames []string
// Titel ist das Präfix des Protokoll-Levels.
// Es gibt auch `ColorCode` und `Style`.
// `ColorCode` und `Style` sollten zwischen Schreibern konsistent sein.
Title string
// ColorCode ist die Farbe für `Titel`.
ColorCode int
// Stil ist eine oder mehrere Formatierungsoptionen für `Titel`.
Style []pio.RichOption

Beispielcode:

level := golog.Levels[golog.DebugLevel]
level.Name = "debug" // Standard
level.Title = "[DBUG]" // Standard
level.ColorCode = pio.Yellow // Standard

Ändern des Ausgabeformats:

app.Logger().SetFormat("json", "    ")

Registrieren eines benutzerdefinierten Formatters:

app.Logger().RegisterFormatter(new(myFormatter))

Das golog.Formatter-Schnittstellen ist wie folgt:

// Formatter ist dafür verantwortlich, ein Protokoll in einen Writer des Loggers zu schreiben.
type Formatter interface {
    // Der Name des Formatters.
    String() string
    // Setze beliebige Optionen und gib ein geklontes Objekt zurück, falls vorhanden. Siehe `Logger.SetFormat`.
    Options(opts ...interface{}) Formatter
    // Schreibt das "Protokoll" in den "Ziel" Logger.
    Format(dest io.Writer, log *Log) bool
}

Ändern von Ausgabe und Format nach Level:

app.Logger().SetLevelOutput("error", os.Stderr)
app.Logger().SetLevelFormat("json")

Anforderungsprotokollierung

Der oben beschriebene Anwendungslogger wird hauptsächlich zum Protokollieren von Informationen und Fehlern im Zusammenhang mit der Anwendung verwendet. Andererseits wird der unten gezeigte Zugriffslogger hauptsächlich verwendet, um eingehende HTTP-Anfragen und -Antworten zu protokollieren.

package main

import (
    "os"

    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/accesslog"
)

// Lesen Sie das Beispiel und seine Kommentare sorgfältig durch.
func makeAccessLog() *accesslog.AccessLog {
    // Initialisieren eines neuen Zugriffsprotokoll-Middleware.
    ac := accesslog.File("./access.log")
    // Entfernen Sie diese Zeile, um das Protokollieren in der Konsole zu deaktivieren:
    ac.AddOutput(os.Stdout)

    // Standardkonfiguration:
    ac.Delim = '|'
    ac.TimeFormat = "2006-01-02 15:04:05"
    ac.Async = false
    ac.IP = true
    ac.BytesReceivedBody = true
    ac.BytesSentBody = true
    ac.BytesReceived = false
    ac.BytesSent = false
    ac.BodyMinify = true
    ac.RequestBody = true
    ac.ResponseBody = false
    ac.KeepMultiLineError = true
    ac.PanicLog = accesslog.LogHandler

    // Verwenden Sie ein Standardzeilenformat, wenn der Formatter fehlt:
    // Zeit|Verzögerung|Status|Methode|Pfad|IP|Pfad Abfrageparameter|Empfangene Bytes|Gesendete Bytes|Anforderung|Antwort|
    //
    // Setzen Sie einen benutzerdefinierten Formatter:
    ac.SetFormatter(&accesslog.JSON{
        Indent:    "  ",
        HumanTime: true,
    })
    // ac.SetFormatter(&accesslog.CSV{})
    // ac.SetFormatter(&accesslog.Template{Text: "{{.Code}}"})

    return ac
}

func main() {
    ac := makeAccessLog()
    defer ac.Close() // Schließen Sie die Datei.

    app := iris.New()
    // Middleware registrieren (auch HTTP-Fehler mit UseRouter abfangen).
    app.UseRouter(ac.Handler)

    app.Get("/", indexHandler)

    app.Listen(":8080")
}

func indexHandler(ctx iris.Context) {
    ctx.WriteString("OK")
}

Weitere Beispiele finden Sie hier: _examples/logging/request-logger.