Ajout d'un middleware de journalisation et de gestion des erreurs à votre API Go

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, notre API Go est 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 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, pour que vos utilisateurs ne voient pas ces vilaines 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 leurs connaissances sur les middlewares 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'accéder à 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 à traquer 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.

La

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 gracieusement 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 ! ?

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!