Update module github.com/golangci/golangci-lint to v2.3.0 (#95)

* Update module github.com/golangci/golangci-lint to v2.3.0

* Fix lint violations

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Colin O'Dell <[email protected]>

Author: renovate[bot]

Makefile

@@ -1,5 +1,5 @@
 # renovate: datasource=go depName=github.com/golangci/golangci-lint
-GOLANGCI_LINT_VERSION=v2.2.2
+GOLANGCI_LINT_VERSION=v2.3.0
 # renovate: datasource=go depName=gotest.tools/gotestsum
 GOTESTSUM_VERSION=v1.12.3
 # renovate: datasource=go depName=github.com/boumenot/gocover-cobertura

build/config/.golangci.yml

@@ -168,7 +168,7 @@ linters:
       enable-all-rules: false
       rules:
         - name: argument-limit
-          arguments: [4]
+          arguments: [5]
         - name: atomic
           disabled: false
         - name: blank-imports

pkg/notifier/slack/slack.go

@@ -74,7 +74,7 @@ func (s *Transport) Validate(ctx context.Context) error {
 		return notifier.Permanent(fmt.Errorf("authentication failed: %w", err))
 	}
 
-	slog.Info("Slack transport connected", "transport", s.key, "slack_team", resp.Team, "slack_user", resp.User)
+	slog.InfoContext(ctx, "Slack transport connected", "transport", s.key, "slack_team", resp.Team, "slack_user", resp.User)
 	return nil
 }
 

pkg/server/handler.go

@@ -6,6 +6,7 @@
 package server
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -25,16 +26,16 @@ func CreateEventProcessingHandler(parserKey string, parser event.Parser, process
 			slog.String("path", request.URL.Path),
 		)
 
-		logger.Debug("handling incoming webhook")
+		logger.DebugContext(request.Context(), "handling incoming webhook")
 
 		evt, err := parser.Parse(request)
 		if err != nil {
-			logAndSendErrorResponse(logger, writer, "failed to parse event", err)
+			logAndSendErrorResponse(request.Context(), logger, writer, "failed to parse event", err)
 			return
 		}
 
 		if evt == nil { // Event is ignorable
-			logger.Debug("ignoring uninteresting event")
+			logger.DebugContext(request.Context(), "ignoring uninteresting event")
 			http.Error(writer, "thanks but we're not interested in that event", 200)
 			return
 		}
@@ -46,20 +47,20 @@ func CreateEventProcessingHandler(parserKey string, parser event.Parser, process
 		for _, processor := range processors {
 			notifications, err = processor.Process(request.Context(), *evt, notifications)
 			if err != nil {
-				logAndSendErrorResponse(logger, writer, fmt.Sprintf("failed during processing (processor %T)", processor), err)
+				logAndSendErrorResponse(request.Context(), logger, writer, fmt.Sprintf("failed during processing (processor %T)", processor), err)
 				return
 			}
 		}
 
 		if len(notifications) == 0 {
-			logger.Debug("no notifications to send after processing")
+			logger.DebugContext(request.Context(), "no notifications to send after processing")
 			http.Error(writer, "no notifications to send", 200)
 			return
 		}
 
 		logger = logger.With(slog.Int("total_notifications", len(notifications)))
 
-		logger.Debug("dispatching notifications")
+		logger.DebugContext(request.Context(), "dispatching notifications")
 
 		errorCount := 0
 		for _, n := range notifications {
@@ -78,7 +79,7 @@ func CreateEventProcessingHandler(parserKey string, parser event.Parser, process
 	}
 }
 
-func logAndSendErrorResponse(logger *slog.Logger, writer http.ResponseWriter, errorPrefix string, err error) {
+func logAndSendErrorResponse(ctx context.Context, logger *slog.Logger, writer http.ResponseWriter, errorPrefix string, err error) {
 	statusCode := 500
 
 	var httpError *Error
@@ -88,9 +89,9 @@ func logAndSendErrorResponse(logger *slog.Logger, writer http.ResponseWriter, er
 	}
 
 	if statusCode < 500 {
-		logger.Warn(errorPrefix, "error", err)
+		logger.WarnContext(ctx, errorPrefix, "error", err)
 	} else {
-		logger.Error(errorPrefix, "error", err)
+		logger.ErrorContext(ctx, errorPrefix, "error", err)
 	}
 
 	http.Error(writer, fmt.Sprintf("%s: %v", errorPrefix, err), statusCode)

pkg/user/handler.go

@@ -49,20 +49,20 @@ func (ph *PreferencesHandler) GetPreferences(writer http.ResponseWriter, request
 	u, err := ph.userStore.Get(request.Context(), key)
 	if err != nil {
 		if errors.Is(err, ErrUserNotFound) {
-			slog.Info("user not found", "key", key)
+			slog.InfoContext(request.Context(), "user not found", "key", key)
 			http.Error(writer, "user not found", http.StatusNotFound)
 			return
 		}
 
-		slog.Error("failed to get user", "key", key, "error", err)
+		slog.ErrorContext(request.Context(), "failed to get user", "key", key, "error", err)
 		http.Error(writer, "failed to get user", http.StatusInternalServerError)
 		return
 	}
 
 	hydratedUserPreferences := ph.buildCurrentUserPreferences(request.Context(), preference.Chain{u.Preferences, ph.defaults})
 	resp := preferencesBody{Preferences: hydratedUserPreferences}
 
-	writeJson(writer, resp)
+	writeJson(request.Context(), writer, resp)
 }
 
 // UpdatePreferences updates the preferences for a given user
@@ -72,25 +72,25 @@ func (ph *PreferencesHandler) UpdatePreferences(writer http.ResponseWriter, requ
 
 	var req preferencesBody
 	if err := json.NewDecoder(request.Body).Decode(&req); err != nil {
-		slog.Error("failed to decode request", "error", err)
+		slog.ErrorContext(request.Context(), "failed to decode request", "error", err)
 		http.Error(writer, "failed to decode request", http.StatusBadRequest)
 		return
 	}
 
 	err := ph.userStore.SetPreferences(request.Context(), key, req.Preferences)
 	if err != nil {
 		if errors.Is(err, ErrUserNotFound) {
-			slog.Info("user not found", "key", key)
+			slog.InfoContext(request.Context(), "user not found", "key", key)
 			http.Error(writer, "user not found", http.StatusNotFound)
 			return
 		}
 
-		slog.Error("failed to save preferences", "key", key, "error", err)
+		slog.ErrorContext(request.Context(), "failed to save preferences", "key", key, "error", err)
 		http.Error(writer, "failed to save preferences", http.StatusInternalServerError)
 		return
 	}
 
-	writeJson(writer, preferencesBody{
+	writeJson(request.Context(), writer, preferencesBody{
 		Preferences: ph.buildCurrentUserPreferences(request.Context(), preference.Chain{req.Preferences, ph.defaults}),
 	})
 }
@@ -152,7 +152,7 @@ type availableOptions struct {
 }
 
 // ListOptions returns the available sources and transports for setting preferences
-func (ph *PreferencesHandler) ListOptions(writer http.ResponseWriter, _ *http.Request) {
+func (ph *PreferencesHandler) ListOptions(writer http.ResponseWriter, request *http.Request) {
 	sources := make([]source, 0, len(ph.parsers))
 	for key, src := range ph.parsers {
 		sources = append(sources, source{
@@ -178,12 +178,12 @@ func (ph *PreferencesHandler) ListOptions(writer http.ResponseWriter, _ *http.Re
 		Transports: transports,
 	}
 
-	writeJson(writer, resp)
+	writeJson(request.Context(), writer, resp)
 }
 
-func writeJson(writer http.ResponseWriter, value any) {
+func writeJson(ctx context.Context, writer http.ResponseWriter, value any) {
 	if err := json.NewEncoder(writer).Encode(value); err != nil {
-		slog.Error("failed to encode response", "error", err)
+		slog.ErrorContext(ctx, "failed to encode response", "error", err)
 		writer.WriteHeader(500)
 	}
 }

server.go

@@ -175,7 +175,7 @@ func (s *Server) serveHttp(ctx context.Context) error {
 	// Mount all parsers
 	for key, parser := range s.parsers {
 		endpoint := "/event/" + key
-		slog.Debug("mounting parser", "endpoint", endpoint)
+		slog.DebugContext(ctx, "mounting parser", "endpoint", endpoint)
 		hsm.HandleFunc(endpoint, server.CreateEventProcessingHandler(key, parser, s.processors, s.notifier))
 	}
 
@@ -196,15 +196,15 @@ func (s *Server) serveHttp(ctx context.Context) error {
 	go (func() {
 		defer close(httpExited)
 
-		slog.Info("http server listening on " + s.listenAddr)
+		slog.InfoContext(ctx, "http server listening on "+s.listenAddr)
 
 		httpExited <- hs.ListenAndServe()
 	})()
 
 	select {
 	// Wait for the context to be canceled
 	case <-ctx.Done():
-		slog.Info("shutting down http server gracefully")
+		slog.InfoContext(ctx, "shutting down http server gracefully")
 		shutdownCtx, cancelShutdown := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancelShutdown()