Slog: Simplificando el Registro Estructurado en Aplicaciones Go

Introducción

¡Hola a todos! Hoy vamos a explorar una nueva forma de registro: Slog. El registro proporciona información sobre el comportamiento del software y ayuda en la identificación y solución de problemas. El paquete de registro estándar de Go ofrece funcionalidades básicas de registro, como el registro de mensajes con marcas de tiempo. Sin embargo, a medida que las aplicaciones crecen en complejidad, las limitaciones del paquete de registro predeterminado se hacen evidentes, lo que lleva a los desarrolladores a buscar un registro más sofisticado.

Una de las principales limitaciones del paquete de registro predeterminado es su falta de organización. Slog aborda esto ofreciendo soporte de primera clase para el registro estructurado, lo que facilita la producción de registros legibles para humanos y máquinas. Slog ofrece niveles de registro fuera de la caja, mayor flexibilidad y extensibilidad, permitiendo a los desarrolladores personalizar el comportamiento de registro para adaptarse a las necesidades de su aplicación. Esto incluye soporte para niveles de registro personalizados, múltiples destinos de salida y registro específico del contexto.

Slog está diseñado teniendo en cuenta el rendimiento, proporcionando una solución de registro más rápida y eficiente que el paquete de registro predeterminado. Esto es particularmente beneficioso en aplicaciones de alto rendimiento donde el registro puede tener un impacto significativo en el rendimiento.

Cómo Funciona Slog

Comencemos con un registro simple utilizando el nivel de registro “info”. Aquí se imprimen la marca de tiempo, el nivel de registro y el mensaje.

package main

import (
    "github.com/slog"
)

func main() {
    slog.Info("Hello, World!")
}

En la terminal, se imprime:

2024-03-30T10:00:00Z INFO Hello, World!

Ahora veamos cómo funcionan diferentes niveles de registro. Probaremos los niveles de error y advertencia.

package main

import "github.com/slog"

func main() {
    slog.Error("An error occurred")
    slog.Warning("This is a warning")
}

En la terminal, se imprime:

2024-03-30T10:00:00Z ERROR An error occurred
2024-03-30T10:00:00Z WARNING This is a warning

Personalización del Registro

Slog permite la impresión de variables desde el código. El primer argumento es el mensaje y después de eso pasamos pares clave-valor. Por ejemplo, si queremos imprimir la versión de Go, la clave sería “versión” y obtendríamos el valor del tiempo de ejecución utilizando el método runtime.Version.

Aún así, los registros no se ven organizados y legibles para las máquinas. Slog proporciona dos manejadores: “text” y “JSON”, que formatean bien los registros.

Manejadores de Slog

Para usar el manejador “text”, creamos un nuevo registrador con el método New de Slog. El primer argumento es un manejador de Slog, y crearemos un nuevo manejador de texto. Requerirá un escritor de entrada/salida, usaremos os.Stderr por ahora. Ahora tenemos un nuevo registrador. Reemplacemos slog con logger.

package main

import (
    "os"
    "github.com/slog"
)

func main() {
    logger := slog.New(slog.NewTextHandler(os.Stderr))

    logger.Info("Hello, World!")
}

1621872998015 INFO Hello, World!

El tiempo se imprime en milisegundos y se muestran diferentes niveles de registro. El mensaje tiene una clave “mensaje” y se imprimen otros valores clave aquí.

Niveles de Registro Personalizados

Por defecto, el nivel de depuración está apagado. Necesitamos cambiar el nivel de registro.

package main

import (
    "os"
    "github.com/slog"
)

func main() {
    logger := slog.New(slog.NewTextHandler(os.Stderr))

    logger.SetLevel(slog.DebugLevel)

    logger.Debug("This is a debug message")
}

Ahora la impresión de depuración aparece en la consola.

1621872998015 DEBUG This is a debug message

Manejador JSON

Reemplace la función New del manejador de texto con New del manejador JSON.

package main

import (
    "os"
    "github.com/slog"
)

func main() {
    logger := slog.New(slog.NewJSONHandler(os.Stderr))

    logger.Info("Hello, World!")
}

La salida está formateada como JSON.

{"time":"2024-03-30T10:00:00Z","level":"INFO","message":"Hello, World!"}

Organización Adicional del Registro

Podemos crear un grupo de registros, similar a JSON anidado.

package main

import (
    "os"
    "runtime"
    "github.com/slog"
)

func main() {
    logger := slog.New(slog.NewTextHandler(os.Stderr))

    logger.Group("OS Info", func(group slog.Group) {
        group.String("OS", runtime.GOOS)
        group.Int("CPUs", runtime.NumCPU())
        group.String("Arch", runtime.GOARCH)
    })

    logger.Info("Hello, World!")
}

La información del sistema operativo aparece como JSON anidado.

2024-03-30T10:00:00Z INFO Hello, World!
{
  "OS Info": {
    "OS": "linux",
    "CPUs": 4,
    "Arch": "amd64"
  }
}

Atributos del Registro

Podemos agregar atributos al registrador con el método WithAttributes en el manejador. Esto requiere una lista de atributos de Slog. Por ejemplo, agregaremos una cadena Slog con la clave “versión de la aplicación” y pondremos una versión aleatoria como valor. Ahora la versión de la aplicación se agrega a la impresión.

package main

import (
    "os"
    "github.com/slog"
)

func main() {
    logger := slog.New(slog.NewTextHandler(os.Stderr).WithAttributes(
        slog.String("App Version", "1.0.0"),
    ))

    logger.Info("Hello, World!")
}

En la terminal, se imprime:

2024-03-30T10:00:00Z INFO Hello, World! {"App Version":"1.0.0"}

Conclusión

En conclusión, exploramos Slog, una biblioteca que ofrece una nueva forma de registro estructurado en aplicaciones Go. A diferencia del paquete de registro estándar, Slog proporciona una organización mejorada, niveles de registro personalizados, múltiples manejadores de salida y una sintaxis más flexible para registrar mensajes. Además, Slog está diseñado para ser eficiente en cuanto a rendimiento, lo que lo hace ideal para aplicaciones de alto rendimiento donde el registro puede tener un impacto significativo en el rendimiento general del sistema.

Al adoptar Slog en nuestras aplicaciones, podemos mejorar la claridad de los registros, facilitar la resolución de problemas y obtener una comprensión más profunda del comportamiento del software. El registro estructurado con Slog no solo es una tarea funcional, sino un arte que nos permite comunicarnos de manera más efectiva con nuestras aplicaciones y obtener información valiosa para mejorar su calidad y rendimiento.

En resumen, Slog no solo es una herramienta de registro, sino una herramienta poderosa que nos ayuda a comprender mejor nuestras creaciones digitales y a tomar decisiones informadas para mejorarlas continuamente.