Logi Go Iris

Rejestrator plików aplikacji

func main() {
    app := iris.Default()
    // Nagrywanie do pliku
    // Automatyczne wyłączenie kolorów podczas zapisywania do pliku
    f, _ := os.Create("iris.log")
    app.Logger().SetOutput(f)

    // Jeśli potrzebujesz zapisywać logi zarówno do pliku, jak i konsoli, użyj poniższego kodu
    // app.Logger().AddOutput(os.Stdout)
    
    app.Get("/ping", func(ctx iris.Context) {
        ctx.WriteString("pong")
    })

    app.Listen(":8080")
}

Kontrola wyjścia kolorów logów

Domyślnie wyjście logów na konsoli będzie kolorowane w oparciu o wykryty TTY.

Dostosuj tytuły poziomów, tekst, kolory i styl w zwykłych przypadkach.

Zaimportuj golog i pio:

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

Pobierz poziom do dostosowania, np. DebugLevel:

level := golog.Levels[golog.DebugLevel]

Masz pełną kontrolę nad tekstem, tytułem i stylem poziomu:

// Nazwa poziomu
// Nazwa w małej literze będzie używana
// do konwersji ciągu znaków poziomu do poprawnego typu poziomu
Name string
// AlternativeNames to nazwy, które mogą odnosić się do tego konkretnego poziomu logów
// np. Name = "warn"
// AlternativeNames = []string{"warning"}, to jest opcjonalne pole,
// więc zachowujemy Nazwę jako zwykły ciąg znaków i tworzymy to nowe pole.
AlternativeNames []string
// Tytuł to prefiks poziomu logowania.
// Istnieją również `ColorCode` i `Style`.
// `ColorCode` i `Style` powinny być spójne między writerami.
Title string
// ColorCode to kolor dla `Title`.
ColorCode int
// Styl to jedna lub więcej opcji dla `Title`.
Style []pio.RichOption

Kod przykładowy:

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

Zmień format wyjścia:

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

Zarejestruj niestandardowy formater:

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

Interfejs golog.Formatter jest następujący:

// Formatter jest odpowiedzialny za wydrukowanie logu do writera loggera.
type Formatter interface {
    // Nazwa formatera.
    String() string
    // Ustawiaj wszystkie opcje i zwracaj sklonowany obiekt, jeśli wspólne. Patrz `Logger.SetFormat`.
    Options(opts ...interface{}) Formatter
    // Formatuje "log" do "dest" loggera.
    Format(dest io.Writer, log *Log) bool
}

Zmień wyjście i formatowanie według poziomu:

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

Rejestracja żądań

Powyższy rejestrator aplikacji służy głównie do rejestrowania informacji i błędów związanych z aplikacją. Z kolei poniższy rejestrator dostępu jest głównie używany do rejestrowania przychodzących żądań i odpowiedzi HTTP.

package main

import (
    "os"

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

// Dokładnie przeczytaj przykład i komentarze do niego.
func makeAccessLog() *accesslog.AccessLog {
    // Inicjalizacja nowego pośrednika dostępu do logu.
    ac := accesslog.File("./access.log")
    // Aby wyłączyć logowanie do konsoli, usuń tę linijkę:
    ac.AddOutput(os.Stdout)

    // Konfiguracja domyślna:
    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
    
    // Użyj domyślnego formatu linii, jeśli brakuje formatera:
    // Time|Delay|Status|Method|Path|IP|Path Query Parameters|Received Bytes|Sent Bytes|Request|Response|
    //
    // Ustaw niestandardowy formater:
    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() // Zamknij plik.

    app := iris.New()
    // Zarejestruj pośrednik (użycie UseRouter umożliwia również przechwytywanie błędów HTTP).
    app.UseRouter(ac.Handler)
    
    app.Get("/", indexHandler)
    
    app.Listen(":8080")
}

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

Zobacz więcej przykładów tutaj: _examples/logging/request-logger.