Nota rápida: si revisaste mi publicación anterior sobre la autenticación JWT y notaste algunos problemas de renderizado, ¡ya se han solucionado! Asegúrate de darle otra mirada porque estos ejemplos se basan en ese tutorial. :)

Muy bien amigos, tenemos nuestra API Go en ejecución, agregamos autenticación JWT e incluso la conectamos a una base de datos PostgreSQL. ¡Pero aún no hemos terminado! Esta semana, vamos a llevar las cosas a un nivel superior y hacer que nuestra API sea más inteligente y más amigable para los desarrolladores agregando middleware personalizado para registro y manejo de errores.

¿Qué es el middleware? ?

El middleware es como un portero en su club favorito: intercepta las solicitudes antes de que lleguen a los puntos finales de su API. Puede tener middleware que verifique la autenticación (como hicimos con JWT), registre información o maneje errores cuando algo salga mal.

Hoy vamos a crear middleware que:

• Registros: Cada solicitud entrante, para que sepamos quién está llamando a la puerta de nuestra API.
• Maneja errores: con gracia, para que tus usuarios no vean esos feos errores 500.

¡Vamos a sumergirnos en ello!

Paso 1: ¿Crear un middleware de registro?

El registro es tu mejor amigo cuando se trata de depurar y comprender lo que sucede en tu API. Vamos a crear un middleware que registre cada solicitud que llegue: método, URL y tiempo necesario.

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // Log the method and the requested URL
        log.Printf("Started %s %s", r.Method, r.URL.Path)

        // Call the next handler in the chain
        next.ServeHTTP(w, r)

        // Log how long it took
        log.Printf("Completed in %v", time.Since(start))
    })
}

Para aquellos que estén interesados ​​en profundizar en el middleware de registro, recomiendo consultar la fantástica guía de Matt Silverlock sobre cómo escribir middleware de registro en Go. Explica cómo estructurar el middleware reutilizable para diversos casos de uso, como autenticación, rastreo y, por supuesto, registro.

Paso 2: ¿Error al manejar el middleware?

Hablemos de errores. Los errores ocurren, ¿verdad? Pero en lugar de permitir que provoquen un bloqueo o envíen un mensaje de error vago, manejémoslos con elegancia.

func errorHandlingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // Log the error and send a user-friendly message
                log.Printf("Error occurred: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

Paso 3: ¿Integrar middleware en su API?

Ahora que hemos creado nuestro middleware de registro y manejo de errores, conectémoslos a nuestra API. Los aplicaremos globalmente para que cada solicitud se registre y se detecten errores.

func main() {
    db = connectDB()
    defer db.Close()

    r := mux.NewRouter()

    // Apply middleware globally
    r.Use(loggingMiddleware)
    r.Use(errorHandlingMiddleware)

    r.HandleFunc("/login", login).Methods("POST")
    r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")
    r.Handle("/books", authenticate(http.HandlerFunc(createBook))).Methods("POST")

    fmt.Println("Server started on port :8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

Paso 4: ¿Probarlo?

Para asegurarte de que todo esté funcionando, inicia tu API:

go run main.go

Ahora, intenta acceder a cualquiera de tus puntos finales (como /books) y verifica tu terminal. Deberías ver registros como:

Started GET /books
Completed in 1.2ms

Y si hay un error, verás:

Error occurred: some error details

Pero su usuario solo verá un mensaje claro "Error interno del servidor 500". ?

¿Por qué es esto importante?

1. El registro lo ayuda a rastrear errores y monitorear el comportamiento de su API. Si algo sale mal, sabrá exactamente qué punto final se alcanzó y cuánto tiempo tardó la solicitud.

2. Manejo de errores evita que su API falle cuando sucede algo inesperado. En cambio, se recupera correctamente y envía un mensaje de error limpio al cliente.

¿Qué sigue?

La próxima vez, llevaremos las cosas al siguiente nivel y acoplaremos nuestra Go API. Esto hará que su aplicación sea portátil y esté lista para implementarse en cualquier máquina o servicio en la nube. ¡Prepárate para la magia de los contenedores! ?