Nota rápida: Se você leu meu post anterior sobre autenticação JWT e notou alguns problemas de renderização, eles já foram corrigidos! Certifique-se de dar uma olhada novamente, porque esses exemplos são baseados nesse tutorial. :)

Tudo bem, pessoal, temos nossa API Go em execução, adicionamos autenticação JWT e até a conectamos a um banco de dados PostgreSQL. Mas ainda não terminamos! Esta semana, vamos elevar as coisas e tornar nossa API mais inteligente e mais amigável ao desenvolvedor adicionando middleware personalizado para logging e tratamento de erros.

O que é middleware de novo? ?

O middleware é como um segurança em seu clube favorito: ele intercepta solicitações antes que elas cheguem aos endpoints da API. Você pode ter um middleware que verifica a autenticação (como fizemos com o JWT), registra informações ou trata de erros quando algo dá errado.

Hoje, vamos construir um middleware que:

• Logs: Cada solicitação recebida, para sabermos quem está batendo na porta da nossa API.
• Lida com erros: graciosamente, para que seus usuários não vejam aqueles feios erros 500.

Vamos mergulhar nisso!

Etapa 1: Criando um middleware de log?

Logging é seu melhor amigo quando se trata de depurar e entender o que está acontecendo em sua API. Vamos criar um middleware que registre cada solicitação recebida - método, URL e tempo gasto.

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 aqueles que estão interessados ​​em se aprofundar no middleware de registro, recomendo verificar o fantástico guia de Matt Silverlock sobre como escrever middleware de registro em Go. Ele explica como estruturar middleware reutilizável para vários casos de uso, como autenticação, rastreamento e, claro, registro!

Etapa 2: Tratamento de erros de middleware?

Vamos falar sobre erros. Erros acontecem, certo? Mas, em vez de deixá-los causar uma falha ou enviar uma mensagem de erro vaga, vamos lidar com eles com elegância.

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)
    })
}

Etapa 3: Integrando Middleware em sua API?

Agora que construímos nosso middleware de registro e tratamento de erros, vamos conectá-los à nossa API. Iremos aplicá-los globalmente para que cada solicitação seja registrada e os erros sejam detectados.

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))
}

Etapa 4: Testando?

Para ter certeza de que tudo está funcionando, inicie sua API:

go run main.go

Agora, tente acessar qualquer um dos seus endpoints (como /books) e verifique seu terminal. Você deverá ver registros como:

Started GET /books
Completed in 1.2ms

E se houver um erro, você verá:

Error occurred: some error details

Mas seu usuário verá apenas uma mensagem limpa "500 Internal Server Error". ?

Por que isso é importante?

1. Logging ajuda a rastrear bugs e monitorar o comportamento de sua API. Se algo der errado, você saberá exatamente qual endpoint foi atingido e quanto tempo a solicitação demorou.

2. Error Handling evita que sua API trave quando algo inesperado acontece. Em vez disso, ele se recupera normalmente e envia uma mensagem de erro limpa ao cliente.

O que vem a seguir?

Da próxima vez, levaremos as coisas para o próximo nível e dockerize nossa Go API! Isso tornará seu aplicativo portátil e pronto para implantação em qualquer máquina ou serviço de nuvem. Prepare-se para um pouco de magia de contêiner! ?