Registros do Go Iris

Gravador de Arquivo de Aplicativo

func main() {
    app := iris.Default()
    // Gravar em um arquivo
    // Desativar automaticamente as cores ao gravar em um arquivo
    f, _ := os.Create("iris.log")
    app.Logger().SetOutput(f)

    // Se precisar gravar logs tanto em um arquivo quanto no console, use o seguinte código
    // app.Logger().AddOutput(os.Stdout)
    
    app.Get("/ping", func(ctx iris.Context) {
        ctx.WriteString("pong")
    })

   app.Listen(":8080")
}

Controlar a Saída Colorida do Log

Por padrão, a saída de log no console será colorida com base no TTY detectado.

Personalize títulos de níveis, texto, cor e estilo em casos regulares.

Importe golog e pio:

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

Obtenha um nível para personalizar, como DebugLevel:

level := golog.Levels[golog.DebugLevel]

Você tem controle completo sobre o texto, título e estilo do nível:

// Nome do nível
// Nomes em minúsculas serão usados
// para converter a string do nível para o tipo de nível correto
Name string
// AlternativeNames são os nomes com os quais este nível específico pode ser referenciado
// como Name = "warn"
// AlternativeNames = []string{"warning"}, este é um campo opcional,
// então manteremos o Name como uma string simples e criaremos este novo campo.
AlternativeNames []string
// Title é o prefixo do nível de log.
// Também existem `ColorCode` e `Style`.
// `ColorCode` e `Style` devem ser consistentes entre escritores.
Title string
// ColorCode é a cor para `Title`.
ColorCode int
// Style são uma ou mais opções ricas para `Title`.
Style []pio.RichOption

Código de exemplo:

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

Alterar o formato de saída:

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

Registrar um formatador personalizado:

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

A interface Formatter do golog é a seguinte:

// O Formatter é responsável por imprimir um log em um escritor do logger.
type Formatter interface {
    // O nome do formatador.
    String() string
    // Definir quaisquer opções e retornar um objeto clonado, se comum. Consulte `Logger.SetFormat`.
    Options(opts ...interface{}) Formatter
    // Escreve o "log" no logger "destino".
    Format(dest io.Writer, log *Log) bool
}

Alterar saída e formato por nível:

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

Registro de Solicitações

O registro de aplicativo que vimos acima é usado principalmente para registrar informações e erros relacionados à aplicação. Por outro lado, o registro de acesso que vemos abaixo é principalmente utilizado para registrar solicitações e respostas HTTP recebidas.

package main

import (
    "os"

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

// Leia o exemplo e seus comentários com atenção.
func makeAccessLog() *accesslog.AccessLog {
    // Inicializa um novo middleware de registro de acesso.
    ac := accesslog.File("./access.log")
    // Remova esta linha para desativar o registro no console:
    ac.AddOutput(os.Stdout)

    // Configuração padrão:
    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
    
    // Utilize o formato de linha padrão se o formatador estiver ausente:
    // Time|Delay|Status|Method|Path|IP|Path Query Parameters|Received Bytes|Sent Bytes|Request|Response|
    //
    // Defina um formatador personalizado:
    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() // Feche o arquivo.

    app := iris.New()
    // Registra o middleware (usar UseRouter também pode capturar erros HTTP).
    app.UseRouter(ac.Handler)
    
    app.Get("/", indexHandler)
    
    app.Listen(":8080")
}

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

Leia mais exemplos aqui: _examples/logging/request-logger.