Help me bij het implementeren van logniveaus in mijn Go-toepassing.
description
Door logniveaus te implementeren, kun je de onderhoudbaarheid van je toepassing verbeteren, belangrijke logs filteren tijdens productie en het debuggen verbeteren door de logvolumes te regelen.
prompt
try_prompt
Leg uit hoe je verschillende logniveaus (bijvoorbeeld debug, info, waarschuwing, fout) instelt in mijn Go-toepassing. Beschrijf hoe je loggers configureert om be ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
In Go kun je met de logrus-bibliotheek verschillende logniveaus instellen, zoals Debug, Info, Warning en Error. Hiermee kun je bepalen welke berichten worden weergegeven afhankelijk van het ingestelde niveau. Hieronder volgt een uitleg en voorbeeldcode voor het configureren van logrus om berichten op basis van het logniveau te outputten.
Stap 1: Logrus importeren
```go
import (
"github.com/sirupsen/logrus"
)
```
Stap 2: Logniveau instellen
Je kunt het logniveau instellen via de `SetLevel` methode van een logger. Bijvoorbeeld:
```go
logrus.SetLevel(logrus.InfoLevel)
```
Dit betekent dat alle berichten met niveau Debug niet worden getoond, maar Info, Warning en Error wel.
Stap 3: Logberichten schrijven
Gebruik de functies van logrus om berichten te loggen:
```go
logrus.Debug("Dit is een debug-bericht")
logrus.Info("Dit is een info-bericht")
logrus.Warn("Dit is een waarschuwing")
logrus.Error("Dit is een foutmelding")
```
Stap 4: Voorbeeldcode
```go
package main
import (
"github.com/sirupsen/logrus"
)
func main() {
// Stel het logniveau in op Info
logrus.SetLevel(logrus.InfoLevel)
// Stel een formatter in (optioneel)
logrus.SetFormatter(&logrus.TextFormatter{
FullTimestamp: true,
})
// Voorbeeld logberichten
logrus.Debug("Dit bericht wordt niet getoond bij Info niveau")
logrus.Info("Dit is een informatief bericht")
logrus.Warn("Dit is een waarschuwing")
logrus.Error("Dit is een foutmelding")
}
```
Dit voorbeeld toont dat, indien het niveau op `InfoLevel` staat, Debug-berichten niet worden weergegeven, maar Info, Warning en Error wel. Je kunt het niveau aanpassen naar bijvoorbeeld `DebugLevel`, `WarnLevel`, `ErrorLevel`, afhankelijk van hoeveel detail je wilt loggen.
Kort samengevat:
- Gebruik `logrus.SetLevel()` om het logniveau te configureren.
- Log berichten met de juiste functies (`Debug`, `Info`, `Warn`, `Error`).
- Berichten onder het ingestelde niveau worden niet getoond.
Zo stel je effectief verschillende logniveaus in en filter je logberichten op basis van het niveau in je Go-toepassing met logrus.
provider: deepseek
model: deepseek-chat
Zal ik uitleggen hoe u logniveaus instelt en configureert in Go met behulp van de logrus bibliotheek.
## Logrus Logniveaus
Logrus ondersteunt de volgende logniveaus (van laag naar hoog):
- `Trace` - Zeer gedetailleerde debug informatie
- `Debug` - Debug informatie voor ontwikkelaars
- `Info` - Algemene informatie over applicatiegedrag
- `Warn` - Waarschuwingen over mogelijke problemen
- `Error` - Fouten die de operatie beïnvloeden
- `Fatal` - Fatale fouten die de applicatie doen stoppen
- `Panic` - Kritieke fouten die een panic veroorzaken
## Basisconfiguratie
```go
package main
import (
"github.com/sirupsen/logrus"
"os"
)
func main() {
// Logger initialiseren
log := logrus.New()
// Log niveau instellen
log.SetLevel(logrus.InfoLevel)
// Output formatter instellen
log.SetFormatter(&logrus.TextFormatter{
FullTimestamp: true,
})
// Output naar stdout
log.SetOutput(os.Stdout)
// Voorbeelden van logging op verschillende niveaus
log.Trace("Dit is een trace bericht") // Wordt niet gelogd (niveau te laag)
log.Debug("Dit is een debug bericht") // Wordt niet gelogd (niveau te laag)
log.Info("Applicatie gestart") // Wordt gelogd
log.Warn("Dit is een waarschuwing") // Wordt gelogd
log.Error("Er is een fout opgetreden") // Wordt gelogd
}
```
## Geavanceerde Configuratie
```go
package main
import (
"github.com/sirupsen/logrus"
"os"
)
// Globale logger
var log = logrus.New()
func initLogger() {
// Log niveau instellen via environment variable
switch os.Getenv("LOG_LEVEL") {
case "TRACE":
log.SetLevel(logrus.TraceLevel)
case "DEBUG":
log.SetLevel(logrus.DebugLevel)
case "WARN":
log.SetLevel(logrus.WarnLevel)
case "ERROR":
log.SetLevel(logrus.ErrorLevel)
default:
log.SetLevel(logrus.InfoLevel)
}
// JSON formatter voor gestructureerde logging
log.SetFormatter(&logrus.JSONFormatter{
TimestampFormat: "2006-01-02 15:04:05",
})
// Bestand als output (optioneel)
file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err == nil {
log.SetOutput(file)
} else {
log.Info("Kon logbestand niet openen, gebruik standaard output")
}
}
func main() {
initLogger()
// Logging met extra velden
log.WithFields(logrus.Fields{
"gebruiker": "jan",
"actie": "inloggen",
}).Info("Gebruiker ingelogd")
// Debug logging (alleen zichtbaar bij DEBUG niveau)
log.Debug("Database verbinding geopend")
// Error logging met stack trace
log.WithFields(logrus.Fields{
"bestand": "config.json",
"fout": "bestand niet gevonden",
}).Error("Configuratie fout")
// Voorwaardelijke logging
if log.IsLevelEnabled(logrus.DebugLevel) {
log.Debug("Gedetailleerde debug informatie")
}
}
```
## Logniveau Dynamisch Wijzigen
```go
package main
import (
"github.com/sirupsen/logrus"
"net/http"
)
var log = logrus.New()
func setLogLevelHandler(w http.ResponseWriter, r *http.Request) {
level := r.URL.Query().Get("level")
switch level {
case "debug":
log.SetLevel(logrus.DebugLevel)
log.Info("Log niveau ingesteld op DEBUG")
case "info":
log.SetLevel(logrus.InfoLevel)
log.Info("Log niveau ingesteld op INFO")
case "warn":
log.SetLevel(logrus.WarnLevel)
log.Info("Log niveau ingesteld op WARN")
case "error":
log.SetLevel(logrus.ErrorLevel)
log.Info("Log niveau ingesteld op ERROR")
default:
log.Warn("Ongeldig log niveau: ", level)
}
}
func main() {
// HTTP endpoint om log niveau te wijzigen
http.HandleFunc("/loglevel", setLogLevelHandler)
log.Info("Server gestart op poort 8080")
http.ListenAndServe(":8080", nil)
}
```
## Gebruik in Meerdere Packages
**main.go:**
```go
package main
import (
"github.com/sirupsen/logrus"
"mijnapp/database"
"mijnapp/api"
)
var log = logrus.New()
func main() {
// Logger configureren
log.SetLevel(logrus.DebugLevel)
log.SetFormatter(&logrus.TextFormatter{})
// Logger doorgeven aan andere packages
database.Init(log)
api.Init(log)
log.Info("Applicatie volledig geïnitialiseerd")
}
```
**database/database.go:**
```go
package database
import "github.com/sirupsen/logrus"
var dbLog *logrus.Logger
func Init(logger *logrus.Logger) {
dbLog = logger
dbLog.Info("Database package geïnitialiseerd")
}
func Connect() {
dbLog.Debug("Database verbinding maken...")
// Verbindingslogica hier
dbLog.Info("Database verbinding succesvol")
}
```
## Environment-based Configuratie
```go
package main
import (
"github.com/sirupsen/logrus"
"os"
)
func getLogLevel() logrus.Level {
levelStr := os.Getenv("LOG_LEVEL")
switch levelStr {
case "TRACE":
return logrus.TraceLevel
case "DEBUG":
return logrus.DebugLevel
case "WARN":
return logrus.WarnLevel
case "ERROR":
return logrus.ErrorLevel
case "FATAL":
return logrus.FatalLevel
case "PANIC":
return logrus.PanicLevel
default:
return logrus.InfoLevel
}
}
func main() {
log := logrus.New()
log.SetLevel(getLogLevel())
// Voor development: kleurrijke output
if os.Getenv("ENV") == "development" {
log.SetFormatter(&logrus.TextFormatter{
ForceColors: true,
FullTimestamp: true,
})
} else {
// Voor production: JSON format
log.SetFormatter(&logrus.JSONFormatter{})
}
log.Info("Logger geconfigureerd met niveau: ", log.GetLevel())
}
```
## Belangrijke Tips
1. **Development**: Gebruik `DebugLevel` of `InfoLevel`
2. **Production**: Gebruik `WarnLevel` of `ErrorLevel`
3. **Structured logging**: Gebruik `WithFields()` voor betere doorzoekbaarheid
4. **Performance**: Controleer logniveau voordat dure operaties worden uitgevoerd
5. **Security**: Log geen gevoelige informatie zoals wachtwoorden
Met deze configuratie kunt u eenvoudig het gewenste logniveau instellen en uw applicatie effectief monitoren.