Logs Go Iris

Enregistreur de fichiers d'application

func main() {
    app := iris.Default()
    // Enregistrer dans un fichier
    // Désactiver automatiquement les couleurs lors de l'écriture dans un fichier
    f, _ := os.Create("iris.log")
    app.Logger().SetOutput(f)

    // Si vous devez écrire des journaux à la fois dans un fichier et dans la console, utilisez le code suivant
    // app.Logger().AddOutput(os.Stdout)
    
    app.Get("/ping", func(ctx iris.Context) {
        ctx.WriteString("pong")
    })

   app.Listen(":8080")
}

Contrôler la couleur de sortie du journal

Par défaut, la sortie du journal sur la console sera colorée en fonction du TTY détecté.

Personnalisez les titres de niveau, le texte, la couleur et le style dans les cas normaux.

Importez golog et pio :

import (
    "github.com/kataras/golog"
    "github.com/kataras/pio"
    // [...]
)

Obtenez un niveau à personnaliser, tel que DebugLevel :

level := golog.Levels[golog.DebugLevel]

Vous avez un contrôle complet sur le texte, le titre et le style du niveau :

// Nom du niveau
// Les noms en minuscules seront utilisés
// pour convertir la chaîne de niveau en le type de niveau correct
Nom string
// Les noms alternatifs sont les noms avec lesquels ce niveau de journal spécifique pourrait être référencé
// tel que Name = "warn"
// AlternativeNames = []string{"warning"}, ce champ est facultatif,
// nous gardons donc le Nom en tant que simple chaîne et créons ce nouveau champ.
AlternativeNames []string
// Le titre est le préfixe du niveau de journal.
// Il y a aussi `ColorCode` et `Style`.
// `ColorCode` et `Style` devraient être cohérents entre les écrivains.
Titre string
// ColorCode est la couleur pour `Title`.
ColorCode int
// Le style est une ou plusieurs options riches pour `Title`.
Style []pio.RichOption

Exemple de code :

level := golog.Levels[golog.DebugLevel]
level.Nom = "debug" // par défaut
level.Titre = "[DBUG]" // par défaut
level.ColorCode = pio.Yellow // par défaut

Changer le format de sortie :

app.Logger().SetFormat("json", "    ")

Enregistrer un formateur personnalisé :

app.Logger().RegisterFormatter(new(myFormatter))

L'interface de golog.Formatter est comme suit :

// Le formateur est responsable d'imprimer un journal dans un écrivain du journal.
type Formatter interface {
    // Le nom du formateur.
    String() string
    // Définir des options et retourner un objet cloné, si commun. Voir `Logger.SetFormat`.
    Options(opts ...interface{}) Formatter
    // Écrit le "log" dans le "dest" du journal.
    Format(dest io.Writer, log *Log) bool
}

Changer la sortie et le format par niveau :

app.Logger().SetLevelOutput("error", os.Stderr)
app.Logger().SetLevelFormat("json")

Enregistrement des demandes

Le journal de l'application que nous avons vu ci-dessus est principalement utilisé pour enregistrer les informations et les erreurs liées à l'application. En revanche, le journal d'accès que nous voyons ci-dessous est principalement utilisé pour enregistrer les requêtes et les réponses HTTP entrantes.

package main

import (
    "os"

    "github.com/kataras/iris/v12"
    "github.com/kataras/iris/v12/middleware/accesslog"
)

// Lisez attentivement l'exemple et ses commentaires.
func makeAccessLog() *accesslog.AccessLog {
    // Initialise un nouveau middleware de journal d'accès.
    ac := accesslog.File("./access.log")
    // Supprimez cette ligne pour désactiver l'enregistrement dans la console :
    ac.AddOutput(os.Stdout)

    // Configuration par défaut :
    ac.Delim = '|'
    ac.TimeFormat = "2006-01-02 15:04:05"
    ac.Async = false
    ac.IP = true
    ac.BytesReceivedBody = true
    ac.BytesSentBody = true
    ac.BytesReceived = false
    ac.BytesSent = false
    ac.BodyMinify = true
    ac.RequestBody = true
    ac.ResponseBody = false
    ac.KeepMultiLineError = true
    ac.PanicLog = accesslog.LogHandler
    
    // Utilisez le format de ligne par défaut si le formateur est manquant :
    // Temps|Delai|Statut|Méthode|Chemin|IP|Paramètres de requête du chemin|Octets reçus|Octets envoyés|Requête|Réponse|
    //
    // Définir un formateur personnalisé :
    ac.SetFormatter(&accesslog.JSON{
        Indent:    "  ",
        HumanTime: true,
    })
    // ac.SetFormatter(&accesslog.CSV{})
    // ac.SetFormatter(&accesslog.Template{Text: "{{.Code}}"})
    
    return ac
}

func main() {
    ac := makeAccessLog()
    defer ac.Close() // Fermer le fichier.

    app := iris.New()
    // Enregistrer le middleware (l'utilisation de UseRouter peut également intercepter les erreurs HTTP).
    app.UseRouter(ac.Handler)
    
    app.Get("/", indexHandler)
    
    app.Listen(":8080")
}

func indexHandler(ctx iris.Context) {
    ctx.WriteString("OK")
}

Pour plus d'exemples, consultez _examples/logging/request-logger.