Registros de Go Iris

func main() {
    app := iris.Default()
    // Grabar en un archivo
    // Deshabilitar automáticamente los colores al escribir en un archivo
    f, _ := os.Create("iris.log")
    app.Logger().SetOutput(f)

    // Si necesita escribir logs tanto en un archivo como en la consola, use el siguiente código
    // app.Logger().AddOutput(os.Stdout)
    
    app.Get("/ping", func(ctx iris.Context) {
        ctx.WriteString("pong")
    })

   app.Listen(":8080")
}

Controlar el color de salida del registro

Por defecto, la salida del registro en la consola se coloreará en función del TTY detectado.

Personalice los títulos de nivel, el texto, el color y el estilo en casos regulares.

Importe golog y pio:

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

Obtenga un nivel para personalizar, como DebugLevel:

level := golog.Levels[golog.DebugLevel]

Tiene control total sobre el texto, el título y el estilo del nivel:

// Nombre del nivel
// Los nombres en minúsculas se utilizarán
// para convertir la cadena de nivel al tipo de nivel correcto
Nombre string
// Los AlternativeNames son los nombres con los que se podría hacer referencia a este nivel de registro específico
// como Nombre = "warn"
// AlternativeNames = []string{"warning"}, este es un campo opcional,
// así que mantenemos el nombre como una cadena simple y creamos este nuevo campo.
AlternativeNames []string
// Title es el prefijo del nivel de registro.
// También hay un `ColorCode` y `Style`.
// `ColorCode` y `Style` deben ser consistentes entre escritores.
Título string
// ColorCode es el color para `Title`.
ColorCode int
// Style es una o más opciones ricas para `Title`.
Style []pio.RichOption

Código de ejemplo:

level := golog.Levels[golog.DebugLevel]
level.Nombre = "debug" // predeterminado
level.Título = "[DBUG]" // predeterminado
level.ColorCode = pio.Yellow // predeterminado

Cambiar el formato de salida:

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

Registrar un formateador personalizado:

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

La interfaz de formateador golog es la siguiente:

// El formateador es responsable de imprimir un registro en un escritor del registro.
type Formateador interface {
    // El nombre del formateador.
    String() string
    // Establezca cualquier opción y devuelva un objeto clonado, si es común. Consulte `Logger.SetFormat`.
    Options(opts ...interface{}) Formateador
    // Escribe el "log" en el "destino" del registro.
    Formato(dest io.Writer, log *Log) bool
}

Cambiar la salida y el formato por nivel:

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

Registro de solicitudes

El registro de la aplicación que vimos anteriormente se usa principalmente para registrar información y errores relacionados con la aplicación. Por otro lado, el registro de acceso que vemos a continuación se utiliza principalmente para registrar las solicitudes y respuestas HTTP entrantes.

paquete principal

import (
    "os"

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

// Lea cuidadosamente el ejemplo y sus comentarios.
func makeAccessLog() *accesslog.AccessLog {
    // Inicializar un nuevo middleware de registro de acceso.
    ac := accesslog.File("./access.log")
    // Elimine esta línea para deshabilitar el registro en la consola:
    ac.AddOutput(os.Stdout)

    // Configuración predeterminada:
    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
    
    // Usar formato de línea predeterminado si falta el formateador:
    // Tiempo|Retraso|Estado|Método|Ruta|IP|Parámetros de consulta de ruta|Bytes recibidos|Bytes enviados|Solicitud|Respuesta|
    //
    // Establecer un formateador 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() // Cerrar el archivo.

    app := iris.New()
    // Registrar middleware (usar UseRouter también puede capturar errores HTTP).
    app.UseRouter(ac.Handler)
    
    app.Get("/", indexHandler)
    
    app.Listen(":8080")
}

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

Consulte más ejemplos aquí: _examples/logging/request-logger.