Natuurlijk! Hier is een gids voor het ontwerpen en implementeren van een logstrategie voor je Go-webapplicatie: 1. Gebruik van logpakketten in Go - Keuze van een logpakket: Voor gestructureerde en flexibele logging is bijvoorbeeld [logrus](https://github.com/sirupsen/logrus), [zap](https://github.com/uber-go/zap) of [zerolog](https://github.com/rs/zerolog) aan te raden. Deze bieden ondersteuning voor logniveaus, formats en integraties. - Installatie voorbeeld (met logrus): ```bash go get github.com/sirupsen/logrus ``` 2. Logberichten structureren - Gestructureerde logs bevatten velden zoals timestamp, logniveau, message, en contextuele gegevens (bijvoorbeeld request-id, gebruiker, URL). - Voorbeeld met logrus: ```go import "github.com/sirupsen/logrus" var log = logrus.New() log.WithFields(logrus.Fields{ "request_id": requestID, "user": userID, "endpoint": "/api/data", }).Info("Data opgevraagd") ``` 3. Logniveaus en -formaten beheren - Niveaus: Debug, Info, Warn, Error, Fatal, Panic. - In een productieomgeving stel je bijvoorbeeld het niveau in op Info of Warn om only belangrijke gebeurtenissen te loggen. - Format: JSON wordt aanbevolen voor gestructureerde logs, vooral bij integratie met logsystemen. ```go log.Formatter = &logrus.JSONFormatter{} log.Level = logrus.InfoLevel ``` 4. Logs output en rotatie - Standaard naar stdout/stderr, maar je kunt ook naar bestanden loggen. - Voor logrotatie gebruik je bijvoorbeeld [lumberjack](https://github.com/natefinch/lumberjack): ```go import "gopkg.in/natefinch/lumberjack.v2" log.Out = &lumberjack.Logger{ Filename: "/var/log/myapp.log", MaxSize: 100, // MB MaxBackups: 3, MaxAge: 28, // dagen } ``` 5. Integratie met externe logsystemen/diensten - Log naar externe systemen zoals Elasticsearch, Graylog, Splunk, of cloudgebaseerde diensten. - Dit doe je vaak via het sturen van logs via HTTP, syslog, of gebruik van specifieke clients. - Voor Elasticsearch kun je bijvoorbeeld Beats gebruiken of direct via logstash: ```go // Voor meer geavanceerde integraties kun je een logstash endpoint configureren log.Formatter = &logrus.JSONFormatter{} log.Out = os.Stdout // of een netwerkverbinding ``` - Alternatief: gebruik een logging agent (zoals Filebeat) die je logbestanden verzendt naar je logmanagementsysteem. 6. Extra tips voor een webserver - Log elke HTTP-request inclusief methode, URL, statuscode, en verwerkingstijd. - Gebruik middleware die automatisch requestgegevens logt. - Bijvoorbeeld met Gin: ```go import "github.com/gin-gonic/gin" router := gin.New() router.Use(gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string { return fmt.Sprintf("%s - [%s] \"%s %s %s\" %d %s\n", param.ClientIP, param.TimeStamp.Format(time.RFC1123), param.Method, param.Path, param.Request.Proto, param.StatusCode, param.Latency) })) ``` 7. Samenvatting - Kies een geschikt logpakket (bijvoorbeeld logrus of zap). - Structuur je logs met velden voor context. - Beheer logniveaus en formatteren (bijvoorbeeld JSON). - Log naar bestanden of externe systemen, met rotatie indien nodig. - Integreer met externe logdiensten voor monitoring en analyse. - Log alle relevante gebeurtenissen en HTTP-verzoeken voor je webserver. Heeft je applicatie specifieke eisen of wil je een voorbeeldcode voor een bepaalde situatie?

Zeker, ik help je graag met het ontwerpen en implementeren van een robuuste logstrategie voor je Go-webserver. Hier is een complete handleiding: ## 1. Keuze van Logpakketten Voor een webserver raad ik aan om **log/slog** (sinds Go 1.21) te gebruiken, eventueel aangevuld met **zerolog** of **zap** voor high-performance scenario's. ```go import ( "log/slog" "os" ) ``` ## 2. Basisopzet en Initialisatie ```go package main import ( "log/slog" "os" "net/http" ) func main() { // Logger initialiseren logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ Level: slog.LevelDebug, })) slog.SetDefault(logger) // HTTP routes instellen http.HandleFunc("/", handleRequest) slog.Info("server gestart", "port", 8080) http.ListenAndServe(":8080", nil) } ``` ## 3. Gestructureerde Logberichten ```go func handleRequest(w http.ResponseWriter, r *http.Request) { // Context met request-ID en andere metadata logger := slog.With( "method", r.Method, "path", r.URL.Path, "ip", r.RemoteAddr, "user_agent", r.UserAgent(), ) start := time.Now() // Verwerk request // ... logger.Info("request verwerkt", "status", http.StatusOK, "duration", time.Since(start).Milliseconds(), "response_size", responseSize, ) } ``` ## 4. Log Levels Beheren ```go type Config struct { LogLevel string `env:"LOG_LEVEL" default:"info"` } func setupLogger(config Config) *slog.Logger { var level slog.Level switch config.LogLevel { case "debug": level = slog.LevelDebug case "info": level = slog.LevelInfo case "warn": level = slog.LevelWarn case "error": level = slog.LevelError default: level = slog.LevelInfo } return slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ Level: level, })) } ``` ## 5. Foutafhandeling met Context ```go func processContent(content string) error { if content == "" { return slog.Error("leeg content ontvangen", "component", "content_processor", "severity", "high") } // Verwerk content err := validateContent(content) if err != nil { slog.Error("content validatie mislukt", "error", err, "content_length", len(content), "component", "validator") return err } return nil } ``` ## 6. Geavanceerde Log Handler ```go type CustomHandler struct { handler slog.Handler } func (h *CustomHandler) Handle(ctx context.Context, r slog.Record) error { // Voeg extra velden toe aan alle logs r.AddAttrs( slog.String("service", "webserver"), slog.String("environment", os.Getenv("ENV")), slog.String("hostname", getHostname()), ) return h.handler.Handle(ctx, r) } func NewCustomHandler(opts *slog.HandlerOptions) *CustomHandler { return &CustomHandler{ handler: slog.NewJSONHandler(os.Stdout, opts), } } ``` ## 7. Integratie met Externe Systemen ### Voor Elasticsearch/Kibana: ```go import ( "github.com/elastic/go-elasticsearch/v8" "github.com/phuslu/log" ) func setupElasticsearchLogger() { esClient, _ := elasticsearch.NewClient(elasticsearch.Config{ Addresses: []string{"http://localhost:9200"}, }) // Gebruik een library die Elasticsearch ondersteunt // Bijvoorbeeld: github.com/phuslu/log } ``` ### Voor Loki (Grafana): ```go import "github.com/grafana/loki-client-go/loki" func setupLokiLogger() { client, _ := loki.New(loki.Config{ URL: "http://localhost:3100/loki/api/v1/push", }) // Custom handler die naar Loki pusht } ``` ## 8. Complete Configuratie Voorbeeld ```go package main import ( "context" "log/slog" "os" "time" "net/http" ) func main() { // Logger configureren logger := slog.New(NewCustomHandler(&slog.HandlerOptions{ Level: getLogLevel(), })) slog.SetDefault(logger) // Middleware voor request logging handler := loggingMiddleware(http.DefaultServeMux) slog.Info("webserver gestart", "port", 8080, "environment", os.Getenv("ENV")) http.ListenAndServe(":8080", handler) } func loggingMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { start := time.Now() // Request verwerken next.ServeHTTP(w, r) // Log request details slog.InfoContext(r.Context(), "request", "method", r.Method, "path", r.URL.Path, "duration", time.Since(start), "status", http.StatusOK, ) }) } ``` ## 9. Best Practices 1. **Gebruik altijd structured logging** 2. **Voeg contextuele informatie toe** (request ID, user ID, etc.) 3. **Stel log levels in via environment variables** 4. **Gebruik verschillende log levels appropriately**: - Debug: Ontwikkeling en troubleshooting - Info: Normale operaties - Warn: Onverwachte maar afhandelbare situaties - Error: Fouten die aandacht vereisen 5. **Implementeer log rotation** voor productie 6. **Voeg tracing IDs toe** voor distributed tracing ## 10. Docker/Productie Setup ```dockerfile # Stel log level in via environment variable ENV LOG_LEVEL=info ENV ENV=production ``` Deze strategie zorgt voor goed gestructureerde, doorzoekbare logs die eenvoudig te integreren zijn met moderne monitoring tools.