Log di Go Iris

Applicazione File Recorder

func main() {
    app := iris.Default()
    // Registra su un file
    // Disabilita automaticamente i colori durante la scrittura su un file
    f, _ := os.Create("iris.log")
    app.Logger().SetOutput(f)

    // Se è necessario scrivere i log sia su un file che sulla console, utilizzare il codice seguente
    // app.Logger().AddOutput(os.Stdout)
    
    app.Get("/ping", func(ctx iris.Context) {
        ctx.WriteString("pong")
    })

   app.Listen(":8080")
}

Controllo del colore dell'output del Log

Per impostazione predefinita, l'output del log sulla console verrà colorato in base al TTY rilevato.

Personalizza i titoli, il testo, il colore e lo stile dei livelli in casi regolari.

Importa golog e pio:

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

Ottieni un livello da personalizzare, come DebugLevel:

livello := golog.Levels[golog.DebugLevel]

Hai completo controllo sul testo, titolo e stile del livello:

// Nome del livello
// I nomi in minuscolo verranno utilizzati
// per convertire la stringa del livello nel tipo di livello corretto
Nome string
// I nomi alternativi sono i nomi con cui questo livello di log specifico potrebbe essere fatto riferimento
// ad esempio, Nome = "warning"
// AlternativeNames = []string{"warning"}, questo è un campo facoltativo,
// quindi manteniamo il Nome come stringa semplice e creiamo questo nuovo campo.
AlternativeNames []string
// Titolo è il prefisso del livello di log.
// Ci sono anche `ColorCode` e `Style`.
// `ColorCode` e `Style` dovrebbero essere coerenti tra i writer.
Titolo string
// ColorCode è il colore per `Titolo`.
ColorCode int
// Style è una o più opzioni avanzate per `Titolo`.
Style []pio.RichOption

Codice di esempio:

livello := golog.Levels[golog.DebugLevel]
livello.Nome = "debug" // predefinito
livello.Titolo = "[DBUG]" // predefinito
livello.ColorCode = pio.Yellow // predefinito

Cambia il formato dell'output:

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

Registra un formatter personalizzato:

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

L'interfaccia golog.Formatter è la seguente:

// Il Formatter è responsabile della stampa di un log su un writer del logger.
type Formatter interface {
    // Il nome del formatter.
    String() string
    // Imposta eventuali opzioni e restituisce un oggetto clonato, se comune. Vedi `Logger.SetFormat`.
    Options(opts ...interface{}) Formatter
    // Scrive il "log" sul "dest" logger.
    Format(dest io.Writer, log *Log) bool
}

Modifica output e formato per livello:

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

Registrazione delle richieste

Il registro dell'applicazione che abbiamo visto sopra è principalmente utilizzato per registrare informazioni e errori relativi all'applicazione. D'altra parte, il registro degli accessi che vediamo di seguito è principalmente utilizzato per registrare le richieste e le risposte HTTP in arrivo.

package main

import (
    "os"

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

// Leggere attentamente l'esempio e i relativi commenti.
func makeAccessLog() *accesslog.AccessLog {
    // Inizializza un nuovo middleware di registro degli accessi.
    ac := accesslog.File("./access.log")
    // Rimuovere questa riga per disabilitare la registrazione sulla console:
    ac.AddOutput(os.Stdout)

    // Configurazione predefinita:
    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

    // Utilizzare il formato di riga predefinito se il formatter è mancante:
    // Time|Delay|Status|Method|Path|IP|Parametri di query del percorso|Bytes ricevuti|Bytes inviati|Richiesta|Risposta|
    //
    // Imposta un formatter personalizzato:
    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() // Chiudi il file.

    app := iris.New()
    // Registra il middleware (usando UseRouter è possibile intercettare anche gli errori HTTP).
    app.UseRouter(ac.Handler)

    app.Get("/", indexHandler)

    app.Listen(":8080")
}

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

Leggi altri esempi qui: _examples/logging/request-logger.