Comment utiliser le contexte pour implémenter le contrôle de filtrage des journaux de requêtes dans Go

Comment utiliser le contexte pour implémenter le contrôle du filtrage des journaux de requêtes dans Go

Introduction :
Dans une grande application Web, les journaux sont très importants. Ils peuvent nous aider à comprendre l'état d'exécution de l'application et sont également utilisés pour le dépannage et la surveillance. base importante. Cependant, pour certaines applications volumineuses, la quantité de journaux peut être très importante. Si un journal est enregistré pour chaque requête, le fichier journal sera très volumineux et il sera difficile de localiser directement les informations que nous souhaitons afficher. Par conséquent, cet article présentera comment utiliser le package de contexte de Go pour implémenter le contrôle de filtrage des journaux de requêtes afin de réduire la redondance des journaux et d'améliorer la lisibilité des journaux.

1. Qu'est-ce que le contexte ? Avant de commencer, comprenons d'abord le package de contexte en langage Go. Context est une bibliothèque standard fournie par le langage Go, qui est utilisée pour transférer des données liées aux requêtes. Elle est principalement utilisée pour le transfert de contexte entre les requêtes Goroutine. Dans une requête, le contexte peut être utilisé pour transmettre des informations liées à la requête, telles que l'authentification de l'utilisateur, l'ID demandé, etc. En langage Go, l'utilisation du contexte peut éviter d'avoir à transmettre le contexte dans la pile d'appels de fonction.

2. Utilisez le contexte pour implémenter le filtrage des journaux de demandes

Dans une application Web, les demandes passeront par plusieurs fonctions de middleware et de traitement, et chaque middleware et fonction de traitement peut enregistrer des journaux liés aux demandes. Afin d'implémenter le contrôle de filtrage, nous pouvons ajouter un bit d'indicateur à la requête et utiliser ce bit d'indicateur pour déterminer si la journalisation doit être enregistrée. Voici un exemple simple :

package main

import (
    "fmt"
    "log"
    "net/http"
    "context"
)

type key int

const (
    loggerKey key = iota
)

func main() {
    http.HandleFunc("/", withLogging(handleRequest))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func withLogging(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        logger := log.New(w, "", log.LstdFlags)
        ctx := context.WithValue(r.Context(), loggerKey, logger)
        next(w, r.WithContext(ctx))
    }
}

func handleRequest(w http.ResponseWriter, r *http.Request) {
    logger := r.Context().Value(loggerKey).(*log.Logger)
    logger.Printf("Received request from %s", r.RemoteAddr)
    fmt.Fprintf(w, "Hello, World!
")
}

Dans l'exemple ci-dessus, nous avons utilisé la fonction WithValue en contexte pour enregistrer l'enregistreur d'objet de sortie de journal en tant que valeur dans le contexte de la requête. Dans le middleware withLogging, nous créons un objet logger et le définissons selon le contexte de la requête. Dans la fonction de traitement handleRequest, nous obtenons l'objet logger à partir du contexte de requête via la méthode Value du contexte et utilisons cet objet pour enregistrer les journaux.

3. Implémenter le filtrage des journaux

Afin d'implémenter le filtrage des journaux, nous pouvons obtenir l'URL ou d'autres informations dans la demande dans le middleware withLogging et utiliser ces informations pour déterminer si les journaux doivent être enregistrés. Ce qui suit est un exemple simple où nous enregistrons uniquement les journaux de requêtes pour accéder à un chemin spécifique :

func withLogging(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        logger := log.New(w, "", log.LstdFlags)
        
        // 检查请求是否需要记录日志
        if shouldLog(r) {
            ctx := context.WithValue(r.Context(), loggerKey, logger)
            next(w, r.WithContext(ctx))
        } else {
            next(w, r)
        }
    }
}

func shouldLog(r *http.Request) bool {
    if r.URL.Path == "/logs" {
        return true
    }
    return false
}

Dans l'exemple ci-dessus, nous avons défini une fonction ShouldLog pour déterminer si la requête doit être enregistrée. Si l'URL demandée est /logs, renvoyez true, indiquant que la journalisation est requise ; sinon, renvoyez false, indiquant que la journalisation n'est pas requise ; Dans le middleware withLogging, nous vérifions d'abord si la requête doit être enregistrée, et si c'est le cas, continuons le traitement. Sinon, nous appelons directement la fonction suivante.

4. Résumé

Cet article explique comment utiliser le package de contexte de Go pour implémenter le contrôle de filtrage des journaux de requêtes. En ajoutant un bit d'indicateur à chaque requête et en évaluant la valeur du bit d'indicateur dans le middleware pour décider d'enregistrer ou non le journal, la redondance du journal peut être efficacement réduite et la lisibilité du journal peut être améliorée. J'espère que cet article pourra vous aider à implémenter le contrôle de filtrage des journaux dans Go.

Références :

https://golang.org/pkg/context/
https://blog.golang.org/context
https://www.alexedwards.net/blog/working-with-go-via - requêtes-contexte

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!