Novedades de Go para tests y depuración: t.Chdir seguro y volcado de pánicos con SetCrashOutputArtículo · digest del 10 de noviembre
Escritorio de ingeniero con libreta de depuración, teclado mecánico y pantalla de terminal
Artículo4 secciones≈ 8 min

Novedades de Go para tests y depuración: t.Chdir seguro y volcado de pánicos con SetCrashOutput

En los lanzamientos de la biblioteca estándar de Go, la atención suele irse a las grandes novedades del lenguaje, mientras que funciones pequeñas en los paquetes testing y runtime/debug pasan de largo sin mirarse. Revisé los análisis recientes del canal «Библиотека Go-разработчика» (segunda nota) y consulté la documentación de Go 1.24 y Go 1.23 (en la práctica ambos mecanismos están verificados también en la rama actual Go 1.27.3). Dos herramientas compactas —t.Chdir y debug.SetCrashOutput— resuelven de serie viejos dolores de cabeza en pruebas y operación de backend.

Analicémoslas sobre un mismo escenario completo. Desarrollamos un microservicio que al arrancar lee un archivo local config.yaml por ruta relativa desde la carpeta actual y luego lanza goroutines en segundo plano. Tenemos dos tareas: probar con seguridad la lectura de configuración en una carpeta temporal sin riesgo de romper los tests vecinos en CI y garantizar que la pila de llamadas quede guardada en un archivo de log aparte en disco si una goroutine en producción cae de pronto con un pánico no capturado (panic).

El directorio de trabajo global: por qué cambiar de carpeta a mano en los tests rompe el build

En el sistema operativo, el directorio de trabajo actual (cwd, current working directory) no pertenece a una función ni a una goroutine aislada, sino a todo el proceso completo. Es como una única regla compartida sobre el banco del taller: si un técnico mueve el «cero» para medir su pieza, el sistema de coordenadas se desplaza para todos los demás en la sala.

Cuando la función LoadLocalConfig() de nuestro servicio abre "config.yaml" sin ruta absoluta desde la raíz del disco, calcula la ubicación justo desde esa «regla» común del proceso go test. Antes, para probar la lectura de configuración en una carpeta temporal había que guardar a mano el directorio original con orig, err := os.Getwd(), llamar a os.Chdir(tmpDir) y colgar un defer os.Chdir(orig).

Con ese esquema manual se tropezaba con frecuencia. Bastaba una salida temprana del test antes de registrar el defer, o olvidar restaurar la ruta en una función auxiliar, para que todo el proceso go test quedara atrapado dentro de la carpeta temporal. El primer test pasa, el directorio temporal se borra, y el siguiente test del paquete intenta abrir sus fixtures por ruta relativa y falla con file not found. En local, ejecutados uno por uno, todo funciona; en CI, la corrida completa arde en rojo.

Reversión automática con t.Chdir y prohibición del paralelismo

Desde Go 1.24 el paquete testing asume esa limpieza. Los tipos *testing.T, *testing.B, *testing.F y la interfaz testing.TB incorporan el método Chdir(dir string). Cambia el directorio mediante os.Chdir, en sistemas Unix actualiza la variable de entorno PWD mientras dura el test y registra automáticamente el retorno a la carpeta original con t.Cleanup.

Probemos la carga de configuración de nuestro microservicio en un subtest anidado t.Run, creando un directorio temporal con config.yaml:

package config

import (
    "os"
    "testing"
)

func TestLoadLocalConfig(t *testing.T) {
    t.Run("relative_config", func(t *testing.T) {
        t.Chdir(t.TempDir())

        if err := os.WriteFile("config.yaml", []byte("port: 8080\n"), 0600); err != nil {
            t.Fatalf("no se pudo escribir el config: %v", err)
        }

        cfg, err := LoadLocalConfig()
        if err != nil || cfg.Port != 8080 {
            t.Fatalf("se esperaba puerto 8080, obtenido: %+v, err: %v", cfg, err)
        }
    })
    // Al salir de t.Run el directorio de trabajo original ya está restaurado
}

La combinación t.Chdir(t.TempDir()) crea una carpeta temporal aislada y traslada allí de inmediato la ejecución del subtest. La llamada os.WriteFile guarda "config.yaml" en la carpeta actual y LoadLocalConfig() lee el puerto 8080 sin rutas absolutas fijadas en código. Como t.Cleanup está atado al alcance de t.Run, la vuelta a la carpeta original ocurre justo al salir del subtest y las pruebas vecinas siguen trabajando en el directorio propio del paquete.

También hay que tener presentes los límites del método. La reversión automática se dispara al terminar el test, pero no aísla el directorio global del proceso entre goroutines paralelas. Por eso t.Chdir es estrictamente incompatible con t.Parallel(): si el modo paralelo se declara en el propio test o en alguno de sus tests padre, llamar a t.Chdir detendrá la ejecución al instante con un pánico. Para pruebas secuenciales y corpus de regresión en fuzz testing en Go (testing.F también soporta Chdir), el método encaja perfecto; para tests paralelos hay que pasar al código una ruta explícita o un fs.FS.

Caja negra de emergencia: cómo debug.SetCrashOutput salva los volcados de pánico

Cuando el microservicio sube al servidor, surge la segunda pregunta: ¿qué ocurre si de noche una goroutine en segundo plano cae con un pánico no manejado? Los loggers normales no sirven aquí: cuando el proceso se desploma, sus búferes en memoria no alcanzan a vaciarse a disco y el runtime de Go imprime la traza final únicamente en la salida de error estándar (stderr). Si en el contenedor o en systemd no está configurada la recolección de stderr, tras el reinicio no quedará ni rastro del pánico.

La función debug.SetCrashOutput(f *os.File, opts CrashOptions) error, introducida en Go 1.23, actúa como una caja negra de vuelo. Conecta un archivo adicional donde el runtime duplicará la salida de emergencia ante un pánico no capturado, manteniendo intacta la escritura en stderr.

Por debajo, el runtime hace una copia de sistema del descriptor de archivo (llamada dup). Es como entregarle un duplicado de la llave de la caja de emergencia al despachador del runtime y guardar tu propia llave enseguida en la caja fuerte: tras llamar a SetCrashOutput, el *os.File original puede cerrarse de inmediato con Close(). La aplicación no mantiene un archivo abierto innecesario, mientras la copia interna del descriptor en el runtime esperará al fallo y escribirá el volcado directo a través del kernel del sistema operativo.

Armado del perímetro de protección en el servicio y detalles de configuración

Conectemos el registro de volcados de emergencia al inicializar nuestro microservicio, antes de lanzar goroutines en segundo plano:

package main

import (
    "os"
    "runtime/debug"
)

func setupCrashRecorder() error {
    crashFile, err := os.OpenFile(
        "/var/log/service_crash.log",
        os.O_CREATE|os.O_WRONLY|os.O_APPEND,
        0640,
    )
    if err != nil {
        return err
    }
    defer crashFile.Close()

    return debug.SetCrashOutput(crashFile, debug.CrashOptions{})
}

Aquí os.OpenFile abre /var/log/service_crash.log en modo append con permisos 0640, y defer crashFile.Close() cierra el descriptor de la aplicación justo después de que debug.SetCrashOutput guarde su duplicado dentro del runtime. Si ocurre un pánico en cualquier goroutine, exactamente el mismo marcador y la traza aparecerán tanto en stderr como en /var/log/service_crash.log, tras lo cual el proceso terminará con error.

Al operar SetCrashOutput, ten presentes dos reglas. Primero, solo existe un destino adicional por proceso: una segunda llamada sobrescribirá el archivo anterior (y llamarla con nil y debug.CrashOptions{} desactiva el registro). Segundo, la función no intercepta el pánico como recover(), no reemplaza al logger habitual ni rota archivos, así que un logrotate externo debe vigilar el tamaño del crash log. Combinado con la propagación de causas de cancelación mediante context.WithCancelCause y la detección de fugas de goroutines con el perfil goroutineleak, este circuito brinda visibilidad completa del runtime.

Antes del próximo despliegue, hazte una pregunta breve: si ahora mismo tu test de archivos falla a mitad de camino y tu demonio en producción sufre un pánico nocturno en una goroutine en segundo plano, ¿quedará limpia la carpeta de tests y se guardará la traza del fallo en disco? Si tienes dudas, cambia los os.Chdir manuales por t.Chdir y añade debug.SetCrashOutput al arranque del servicio.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 4