Fundamentos de Bibliotecas Esenciales

10 ejemplos para empezar con Bibliotecas Esenciales - 7 básicos y 3 intermedios.

Prerrequisitos

• Instala Go 1.26.x o posterior desde go.dev/dl.
• Crea un módulo: mkdir libdemo && cd libdemo && go mod init example.com/libdemo.
• Añade bibliotecas comunes: go get go.uber.org/zap github.com/stretchr/testify/require github.com/spf13/viper github.com/go-chi/chi/v5.
• Ejecuta los ejemplos con go run . después de guardarlos como main.go (o divide los archivos en el mismo módulo).

Ejemplos Básicos

1. Logger de producción zap

Logs estructurados en JSON con configuración mínima.

package main
 
import (
    "go.uber.org/zap"
)
 
func main() {
    log, _ := zap.NewProduction()
    defer log.Sync()
    log.Info("service ready", zap.String("port", "8080"))
}

• NewProduction configura la salida JSON, el muestreo y los valores predeterminados sensatos.
• defer log.Sync() vacía los búferes al apagar (ignora errores en algunas plataformas).
• Prefiere inyectar *zap.Logger en los constructores en lugar de estado global.

Relacionado: Logging: zap vs zerolog vs slog - cuándo elegir zap sobre slog

2. Manejador JSON de slog (alternativa de la biblioteca estándar)

No se requiere un logger de terceros para campos estructurados.

package main
 
import (
    "log/slog"
    "os"
)
 
func main() {
    h := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo})
    slog.SetDefault(slog.New(h))
    slog.Info("ready", "service", "api")
}

• Go 1.21+ incluye log/slog en la biblioteca estándar.
• Los pares clave-valor siguen al argumento del mensaje.
• Muchos equipos se estandarizan en slog y mantienen zap solo para rutas críticas en latencia.

Relacionado: Logging Estructurado con slog - manejadores y migración

3. Asersión de testify require

Fallos de prueba legibles sin ayudantes personalizados.

package user_test
 
import (
    "testing"
    "github.com/stretchr/testify/require"
)
 
func sum(a, b int) int { return a + b }
 
func TestSum(t *testing.T) {
    require.Equal(t, 5, sum(2, 3))
}

• require detiene la prueba al fallar (úsalo en precondiciones de configuración).
• Guarda esto en user_test.go; testify es solo para pruebas, no para código de producción.
• Combínalo con slices de tests basados en tablas para cobertura.

Relacionado: Pruebas con testify & mockery - suites y mocks

4. viper lee el archivo de configuración

Carga valores predeterminados de YAML con soporte para anulación de variables de entorno.

package main
 
import (
    "fmt"
    "github.com/spf13/viper"
)
 
func main() {
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath(".")
    _ = viper.ReadInConfig()
    viper.SetDefault("port", 8080)
    fmt.Println(viper.GetInt("port"))
}

• SetDefault se aplica cuando la clave falta en todas las fuentes.
• Llama a viper.AutomaticEnv() para que PORT anule las claves port.
• Mantén las estructuras de configuración tipadas; viper es para cargar, no para lógica de negocio.

Relacionado: Configuración con viper & envconfig - precedencia en capas

5. chi router con una ruta

Enrutamiento HTTP compatible con la biblioteca estándar.

package main
 
import (
    "net/http"
    "github.com/go-chi/chi/v5"
)
 
func main() {
    r := chi.NewRouter()
    r.Get("/ping", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("pong"))
    })
    http.ListenAndServe(":8080", r)
}

• chi.NewRouter() devuelve un http.Handler.
• Los manejadores usan firmas estándar de ResponseWriter y Request.
• Añade middleware con r.Use antes de registrar rutas.

Relacionado: chi: Enrutamiento y Middleware Ligeros - grupos de rutas

6. Parámetro de URL de chi

Segmentos de ruta con nombre sin tipos de contexto de framework.

r.Get("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := chi.URLParam(r, "id")
    w.Write([]byte("user " + id))
})

• {id} captura un segmento; valida antes de las búsquedas en la base de datos.
• Cadena vacía significa que el parámetro no se estableció en este patrón de ruta.
• Documenta los nombres de los parámetros en OpenAPI o tablas de rutas.

7. viper enlaza variable de entorno

Mapea DATABASE_URL a un campo de configuración tipado.

viper.SetEnvPrefix("APP")
viper.BindEnv("database_url")
viper.AutomaticEnv()
dsn := viper.GetString("database_url")
_ = dsn

• SetEnvPrefix nombra las claves de entorno (APP_DATABASE_URL).
• Enlaza claves explícitas cuando el mapeo automático es ambiguo.
• Falla rápidamente en main cuando los secretos requeridos están vacíos.

Ejemplos Intermedios

8. Logger azucarado de zap para estilo printf

SugaredLogger sacrifica un poco de rendimiento por ergonomía.

log, _ := zap.NewDevelopment()
defer log.Sync()
sugar := log.Sugar()
sugar.Infof("listening on %s", ":8080")

• Prefiere log.Info("listening", zap.String("addr", addr)) estructurado en rutas de acceso frecuentes.
• La configuración de desarrollo usa codificación de consola para legibilidad local.
• Inyecta *zap.Logger y llama a .Sugar() solo en límites heredados.

9. Esqueleto de suite de testify

Agrupa pruebas relacionadas con ganchos de configuración compartidos.

import (
    "testing"
    "github.com/stretchr/testify/suite"
)
 
type UserSuite struct{ suite.Suite }
 
func (s *UserSuite) TestCreate() {
    s.Equal(1, 1)
}
 
func TestUserSuite(t *testing.T) {
    suite.Run(t, new(UserSuite))
}

• SetupTest / TearDownTest se ejecutan alrededor de cada método de prueba.
• Las suites ayudan a las pruebas de integración HTTP con servidores httptest compartidos.
• No reemplaces las pruebas unitarias basadas en tablas donde las suites añaden ceremonia.

Relacionado: testify, httptest & Dobles de Prueba - dobles y httptest

10. Middleware chi más log de solicitud zap

Compone bibliotecas enfocadas en el borde HTTP.

import (
    "net/http"
    "time"
    "github.com/go-chi/chi/v5/middleware"
    "go.uber.org/zap"
)
 
func requestLog(log *zap.Logger) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            start := time.Now()
            ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
            next.ServeHTTP(ww, r)
            log.Info("request",
                zap.String("method", r.Method),
                zap.String("path", r.URL.Path),
                zap.Int("status", ww.Status()),
                zap.Duration("latency", time.Since(start)),
            )
        })
    }
}

• WrapResponseWriter de chi captura códigos de estado para logs de acceso.
• Mantén el middleware más externo: recuperación, logging, luego autenticación.
• Pasa r.Context() a las llamadas posteriores para cancelación.

Relacionado: Bibliotecas Cliente de Prometheus y OpenTelemetry - métricas junto con logs

Versiones de Stack: Esta página fue escrita para Go 1.26.x (GC por defecto Green Tea, go fix modernizers - verifica el parche en la compilación), chi (última versión - verifica en la compilación), gin (última versión - verifica en la compilación), echo (última versión - verifica en la compilación), google.golang.org/grpc (última versión - verifica en la compilación), sigs.k8s.io/controller-runtime (última versión - verifica en la compilación), kubebuilder (última versión - verifica en la compilación), tinygo (última versión - verifica los objetivos de placa en la compilación), wazero (última versión - verifica en la compilación) y golangci-lint (última versión - verifica el conjunto de linters en la compilación). pbqrthvqrf.vb|ptvb510|202607