Remarque rapide : si vous avez consulté mon article précédent sur l'authentification JWT et remarqué des problèmes de rendu, ceux-ci ont maintenant été corrigés ! Assurez-vous de lui donner un autre regard, car ces exemples s'appuient sur ce didacticiel. :)

Très bien les amis, nous avons notre API Go en cours d'exécution, nous avons ajouté l'authentification JWT et nous l'avons même connectée à une base de données PostgreSQL. Mais nous n’avons pas encore fini ! Cette semaine, nous allons aller plus loin et rendre notre API plus intelligente et plus conviviale pour les développeurs en ajoutant un middleware personnalisé pour la la journalisation et gestion des erreurs.

Qu’est-ce que le middleware déjà ? ?

Le middleware est comme un videur dans votre club préféré : il intercepte les requêtes avant qu'elles n'atteignent les points de terminaison de votre API. Vous pouvez disposer d'un middleware qui vérifie l'authentification (comme nous l'avons fait avec JWT), enregistre les informations ou gère les erreurs en cas de problème.

Aujourd'hui, nous allons créer un middleware qui :

• Journaux : chaque demande entrante, afin que nous sachions qui frappe à la porte de notre API.
• Gère les erreurs : avec élégance, afin que vos utilisateurs ne voient pas ces horribles 500 erreurs.

Plongeons-y !

Étape 1 : Créer un middleware de journalisation ?

La journalisation est votre meilleur ami lorsqu'il s'agit de déboguer et de comprendre ce qui se passe dans votre API. Nous allons créer un middleware qui enregistre chaque demande reçue : méthode, URL et temps nécessaire.

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

Pour ceux qui souhaitent approfondir leur connaissance du middleware de journalisation, je recommande de consulter le fantastique guide de Matt Silverlock sur l'écriture d'un middleware de journalisation dans Go. Il explique comment structurer un middleware réutilisable pour divers cas d'utilisation comme l'authentification, le traçage et, bien sûr, la journalisation !

Étape 2 : Erreur de gestion du middleware ?

Parlons des erreurs. Des erreurs se produisent, n'est-ce pas ? Mais plutôt que de les laisser provoquer un crash ou envoyer un vague message d’erreur, traitons-les avec élégance.

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

Étape 3 : Intégrer le middleware dans votre API ?

Maintenant que nous avons créé notre middleware de journalisation et de gestion des erreurs, connectons-les à notre API. Nous les appliquerons globalement afin que chaque demande soit enregistrée et que les erreurs soient détectées.

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

Étape 4 : Le tester ?

Pour vous assurer que tout fonctionne, démarrez votre API :

go run main.go

Maintenant, essayez d'atteindre l'un de vos points de terminaison (comme /books) et vérifiez votre terminal. Vous devriez voir des journaux comme :

Started GET /books
Completed in 1.2ms

Et s'il y a une erreur, vous verrez :

Error occurred: some error details

Mais votre utilisateur ne verra qu'un message clair "500 Internal Server Error". ?

Pourquoi est-ce important ?

1. Logging vous aide à détecter les bugs et à surveiller le comportement de votre API. Si quelque chose ne va pas, vous saurez exactement quel point de terminaison a été atteint et combien de temps la requête a pris.

2. Gestion des erreurs empêche votre API de planter lorsque quelque chose d'inattendu se produit. Au lieu de cela, il récupère correctement et envoie un message d'erreur propre au client.

Quelle est la prochaine étape ?

La prochaine fois, nous passerons au niveau supérieur et ancrerons notre API Go ! Cela rendra votre application portable et prête à être déployée sur n’importe quelle machine ou service cloud. Préparez-vous à la magie des conteneurs ! ?