Het integreren van logging- en monitoringtools in je Go-toepassing is essentieel om prestaties, fouten en gebruiksstatistieken effectief te volgen en te beheren. Hier volgt een overzicht van hoe je dit kunt aanpakken, inclusief populaire bibliotheken en best practices. 1. Logging integreren Populaire bibliotheken: - logrus: Een uitgebreide en flexibele loggingbibliotheek met ondersteuning voor verschillende loglevels en formatteringsopties. - zap: Een snelle, gestructureerde loggingbibliotheek ontwikkeld door Uber, geschikt voor productieomgevingen. Structuur van logberichten: - Gebruik gestructureerde logs (bijvoorbeeld JSON) voor gemakkelijk doorzoeken. - Voeg belangrijke context toe zoals request-ID, gebruikers-ID, endpoint, en timestamp. - Log niet alleen fouten, maar ook belangrijke gebeurtenissen en prestaties. Voorbeeld met logrus: ```go import ( "github.com/sirupsen/logrus" ) var log = logrus.New() func init() { log.Formatter = &logrus.JSONFormatter{} log.Level = logrus.InfoLevel } func handleRequest(w http.ResponseWriter, r *http.Request) { start := time.Now() requestID := generateRequestID() log.WithFields(logrus.Fields{ "request_id": requestID, "endpoint": r.URL.Path, "method": r.Method, }).Info("Nieuwe request ontvangen") // verwerking... duration := time.Since(start) log.WithFields(logrus.Fields{ "request_id": requestID, "duration": duration.String(), "status": "success", }).Info("Request voltooid") } ``` 2. Monitoring tools Populaire tools: - Prometheus: Voor het verzamelen van metriekgegevens via een HTTP endpoint, met grafieken en dashboards via Grafana. - DataDog, New Relic: Voor uitgebreide APM (Application Performance Monitoring) en infrastructuurmonitoring. Integratie: - Prometheus client library voor Go: `prometheus/client_golang` - Definieer metriek zoals request-tellingen, foutstatistieken, latenties. Voorbeeld met Prometheus: ```go import ( "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" ) var ( requestCount = prometheus.NewCounterVec( prometheus.CounterOpts{ Name: "http_requests_total", Help: "Totaal aantal HTTP verzoeken", }, []string{"endpoint", "status"}, ) requestLatency = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Name: "http_request_duration_seconds", Help: "HTTP request latency in seconden", Buckets: prometheus.ExponentialBuckets(0.001, 2, 15), }, []string{"endpoint"}, ) ) func init() { prometheus.MustRegister(requestCount, requestLatency) } func handleRequest(w http.ResponseWriter, r *http.Request) { timer := prometheus.NewTimer(requestLatency.WithLabelValues(r.URL.Path)) defer timer.ObserveDuration() // Verwerking van request... requestCount.WithLabelValues(r.URL.Path, "200").Inc() } ``` - Voeg een endpoint toe voor de metrics: ```go http.Handle("/metrics", promhttp.Handler()) ``` 3. Best practices - Log niveaus gebruiken: DEBUG, INFO, WARN, ERROR. - Structuur en consistentie: Gebruik gestructureerde logs met duidelijke velden. - Correlatie: Gebruik request-ID's en context om logs en metriekgegevens te koppelen. - Waarschuwingssystemen: Stel alerts in op basis van drempels (bijv. hoge errorpercentages, trage responsetijden). - Centraliseer logs en metriekgegevens: Gebruik ELK-stack (Elasticsearch, Logstash, Kibana), Grafana, of cloud-based oplossingen voor overzicht en analyse. - Beveiliging: Zorg dat logs geen gevoelige gegevens bevatten. Door deze aanpak te volgen, kun je prestaties en fouten in je Go-webapplicatie effectief monitoren en snel reageren op problemen.

Hier is een uitgebreide uitleg over het integreren van logging en monitoring in je Go-webapplicatie: ## Logging Integratie ### Populaire Logging Bibliotheken **1. Logrus (aanbevolen)** ```go import log "github.com/sirupsen/logrus" func init() { log.SetFormatter(&log.JSONFormatter{}) log.SetLevel(log.InfoLevel) } func handleRequest(w http.ResponseWriter, r *http.Request) { log.WithFields(log.Fields{ "method": r.Method, "path": r.URL.Path, "ip": r.RemoteAddr, }).Info("Request ontvangen") } ``` **2. Zerolog (zeer performant)** ```go import "github.com/rs/zerolog/log" func handleRequest(w http.ResponseWriter, r *http.Request) { log.Info(). Str("method", r.Method). Str("path", r.URL.Path). Str("ip", r.RemoteAddr). Msg("Request verwerkt") } ``` **3. Standaard library met structuur** ```go import "log" type StructuredLogger struct { *log.Logger } func (l *StructuredLogger) LogRequest(method, path, ip string) { l.Printf(`{"level":"info","method":"%s","path":"%s","ip":"%s","timestamp":"%s"}`, method, path, ip, time.Now().Format(time.RFC3339)) } ``` ## Monitoring Integratie ### Metrische Bibliotheken **1. Prometheus Client** ```go import ( "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" ) var ( requestCount = prometheus.NewCounterVec( prometheus.CounterOpts{ Name: "http_requests_total", Help: "Totaal aantal HTTP requests", }, []string{"method", "path", "status"}, ) requestDuration = prometheus.NewHistogramVec( prometheus.HistogramOpts{ Name: "http_request_duration_seconds", Help: "Request duur in seconden", }, []string{"method", "path"}, ) ) func init() { prometheus.MustRegister(requestCount, requestDuration) } // Monitoring middleware func monitoringMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { start := time.Now() rw := &responseWriter{ResponseWriter: w, statusCode: 200} next.ServeHTTP(rw, r) duration := time.Since(start).Seconds() requestCount.WithLabelValues(r.Method, r.URL.Path, fmt.Sprintf("%d", rw.statusCode)).Inc() requestDuration.WithLabelValues(r.Method, r.URL.Path).Observe(duration) }) } ``` **2. Expvar (ingebouwd)** ```go import "expvar" var ( requestStats = expvar.NewMap("http") errorCount = expvar.NewInt("errors") ) func incrementRequestCounter(method string) { key := fmt.Sprintf("requests_%s", method) requestStats.Add(key, 1) } ``` ## Best Practices voor Log Structuur ### Gestructureerde Logging ```go // GOED: Gestructureerd log.WithFields(log.Fields{ "user_id": userID, "action": "login", "ip": remoteIP, "user_agent": userAgent, "duration_ms": duration.Milliseconds(), }).Info("Gebruiker ingelogd") // SLECHT: Ongestructureerd log.Printf("User %s logged in from %s", userID, remoteIP) ``` ### Log Levels Correct Gebruiken ```go func processOrder(orderID string) error { log.WithField("order_id", orderID).Debug("Order verwerking gestart") // Business logic if err := validateOrder(orderID); err != nil { log.WithFields(log.Fields{ "order_id": orderID, "error": err.Error(), }).Error("Order validatie mislukt") return err } log.WithField("order_id", orderID).Info("Order succesvol verwerkt") return nil } ``` ## Waarschuwingssystemen Opzetten ### 1. Error Rate Monitoring ```go var ( errorRate = prometheus.NewCounterVec( prometheus.CounterOpts{ Name: "application_errors_total", Help: "Totaal aantal applicatiefouten", }, []string{"type", "endpoint"}, ) ) func logError(errorType, endpoint string, err error) { errorRate.WithLabelValues(errorType, endpoint).Inc() log.WithFields(log.Fields{ "type": errorType, "endpoint": endpoint, "error": err.Error(), }).Error("Applicatiefout opgetreden") } ``` ### 2. Performance Waarschuwingen ```go func trackPerformance(operation string, fn func()) { start := time.Now() fn() duration := time.Since(start) if duration > 2*time.Second { log.WithFields(log.Fields{ "operation": operation, "duration": duration.String(), }).Warn("Trage operatie gedetecteerd") } } ``` ## Complete Implementatie Voorbeeld ```go package main import ( "net/http" "time" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" log "github.com/sirupsen/logrus" ) type Monitoring struct { requestCount *prometheus.CounterVec requestDuration *prometheus.HistogramVec errorCount *prometheus.CounterVec } func NewMonitoring() *Monitoring { m := &Monitoring{ requestCount: prometheus.NewCounterVec( prometheus.CounterOpts{ Name: "http_requests_total", Help: "Totaal aantal HTTP requests", }, []string{"method", "path", "status"}, ), requestDuration: prometheus.NewHistogramVec( prometheus.HistogramOpts{ Name: "http_request_duration_seconds", Help: "Request duur in seconden", }, []string{"method", "path"}, ), errorCount: prometheus.NewCounterVec( prometheus.CounterOpts{ Name: "application_errors_total", Help: "Totaal aantal applicatiefouten", }, []string{"type", "endpoint"}, ), } prometheus.MustRegister(m.requestCount, m.requestDuration, m.errorCount) return m } func (m *Monitoring) Middleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { start := time.Now() rw := &responseWriter{ResponseWriter: w, statusCode: 200} // Log request log.WithFields(log.Fields{ "method": r.Method, "path": r.URL.Path, "ip": r.RemoteAddr, }).Info("Inkomend request") next.ServeHTTP(rw, r) // Metriek bijwerken duration := time.Since(start).Seconds() m.requestCount.WithLabelValues(r.Method, r.URL.Path, fmt.Sprintf("%d", rw.statusCode)).Inc() m.requestDuration.WithLabelValues(r.Method, r.URL.Path).Observe(duration) // Waarschuwing voor trage requests if duration > 5.0 { log.WithFields(log.Fields{ "method": r.Method, "path": r.URL.Path, "duration": duration, }).Warn("Trage request gedetecteerd") } }) } func main() { // Logging configureren log.SetFormatter(&log.JSONFormatter{}) log.SetLevel(log.InfoLevel) // Monitoring initialiseren monitoring := NewMonitoring() // Routes opzetten mux := http.NewServeMux() mux.Handle("/metrics", promhttp.Handler()) mux.HandleFunc("/api/users", handleUsers) // Server starten met monitoring middleware handler := monitoring.Middleware(mux) log.Info("Server gestart op poort 8080") http.ListenAndServe(":8080", handler) } ``` ## Aanbevolen Tools Stack - **Logging**: Logrus of Zerolog - **Monitoring**: Prometheus + Grafana - **Tracing**: OpenTelemetry - **Alerting**: Alertmanager (Prometheus) - **Log Aggregatie**: ELK Stack of Loki Deze setup geeft je volledig inzicht in je applicatieprestaties, fouten en gebruikersgedrag, met de mogelijkheid om proactief problemen te detecteren via waarschuwingen.