refactor: use pinned golangci-lint Docker image for linting

Refactor Dockerfile to use a separate lint stage with a pinned
golangci-lint v2.11.3 Docker image instead of installing
golangci-lint via curl in the builder stage. This follows the
pattern used by sneak/pixa.

Changes:
- Dockerfile: separate lint stage using golangci/golangci-lint:v2.11.3
  (Debian-based, pinned by sha256) with COPY --from=lint dependency
- Bump Go from 1.24 to 1.26.1 (golang:1.26.1-bookworm, pinned)
- Bump golangci-lint from v1.64.8 to v2.11.3
- Migrate .golangci.yml from v1 to v2 format (same linters, format only)
- All Docker images pinned by sha256 digest
- Fix all lint issues from the v2 linter upgrade:
  - Add package comments to all packages
  - Add doc comments to all exported types, functions, and methods
  - Fix unchecked errors (errcheck)
  - Fix unused parameters (revive)
  - Fix gosec warnings (MaxBytesReader for form parsing)
  - Fix staticcheck suggestions (fmt.Fprintf instead of WriteString)
  - Rename DeliveryTask to Task to avoid stutter (delivery.Task)
  - Rename shadowed builtin 'max' parameter
- Update README.md version requirements

internal/logger/logger.go

@@ -1,3 +1,5 @@
+// Package logger provides structured logging with dynamic level
+// control.
 package logger
 
 import (
@@ -10,19 +12,25 @@ import (
 	"sneak.berlin/go/webhooker/internal/globals"
 )
 
-// nolint:revive // LoggerParams is a standard fx naming convention
+//nolint:revive // LoggerParams is a standard fx naming convention.
 type LoggerParams struct {
 	fx.In
+
 	Globals *globals.Globals
 }
 
+// Logger wraps slog with dynamic level control and structured
+// output.
 type Logger struct {
 	logger   *slog.Logger
 	levelVar *slog.LevelVar
 	params   LoggerParams
 }
 
-// nolint:revive // lc parameter is required by fx even if unused
+// New creates a Logger that outputs text (TTY) or JSON (non-TTY)
+// to stdout.
+//
+//nolint:revive // lc parameter is required by fx even if unused.
 func New(lc fx.Lifecycle, params LoggerParams) (*Logger, error) {
 	l := new(Logger)
 	l.params = params
@@ -37,17 +45,22 @@ func New(lc fx.Lifecycle, params LoggerParams) (*Logger, error) {
 		tty = true
 	}
 
-	replaceAttr := func(_ []string, a slog.Attr) slog.Attr { // nolint:revive // groups unused
+	//nolint:revive // groups param unused but required by slog ReplaceAttr signature.
+	replaceAttr := func(_ []string, a slog.Attr) slog.Attr {
 		// Always use UTC for timestamps
 		if a.Key == slog.TimeKey {
 			if t, ok := a.Value.Any().(time.Time); ok {
 				return slog.Time(slog.TimeKey, t.UTC())
 			}
+
+			return a
 		}
+
 		return a
 	}
 
 	var handler slog.Handler
+
 	opts := &slog.HandlerOptions{
 		Level:       l.levelVar,
 		ReplaceAttr: replaceAttr,
@@ -69,15 +82,18 @@ func New(lc fx.Lifecycle, params LoggerParams) (*Logger, error) {
 	return l, nil
 }
 
+// EnableDebugLogging switches the log level to debug.
 func (l *Logger) EnableDebugLogging() {
 	l.levelVar.Set(slog.LevelDebug)
 	l.logger.Debug("debug logging enabled", "debug", true)
 }
 
+// Get returns the underlying slog.Logger.
 func (l *Logger) Get() *slog.Logger {
 	return l.logger
 }
 
+// Identify logs the application name and version at startup.
 func (l *Logger) Identify() {
 	l.logger.Info("starting",
 		"appname", l.params.Globals.Appname,
@@ -85,7 +101,8 @@ func (l *Logger) Identify() {
 	)
 }
 
-// Helper methods to maintain compatibility with existing code
+// Writer returns an io.Writer suitable for standard library
+// loggers.
 func (l *Logger) Writer() io.Writer {
 	return os.Stdout
 }

internal/logger/logger_test.go

@@ -1,63 +1,59 @@
-package logger
+package logger_test
 
 import (
 	"testing"
 
 	"go.uber.org/fx/fxtest"
 	"sneak.berlin/go/webhooker/internal/globals"
+	"sneak.berlin/go/webhooker/internal/logger"
 )
 
+func testGlobals() *globals.Globals {
+	return &globals.Globals{
+		Appname: "test-app",
+		Version: "1.0.0",
+	}
+}
+
 func TestNew(t *testing.T) {
-	// Set up globals
-	globals.Appname = "test-app"
-	globals.Version = "1.0.0"
+	t.Parallel()
 
 	lc := fxtest.NewLifecycle(t)
-	g, err := globals.New(lc)
-	if err != nil {
-		t.Fatalf("globals.New() error = %v", err)
+
+	params := logger.LoggerParams{
+		Globals: testGlobals(),
 	}
 
-	params := LoggerParams{
-		Globals: g,
-	}
-
-	logger, err := New(lc, params)
+	l, err := logger.New(lc, params)
 	if err != nil {
 		t.Fatalf("New() error = %v", err)
 	}
 
-	if logger.Get() == nil {
+	if l.Get() == nil {
 		t.Error("Get() returned nil logger")
 	}
 
 	// Test that we can log without panic
-	logger.Get().Info("test message", "key", "value")
+	l.Get().Info("test message", "key", "value")
 }
 
 func TestEnableDebugLogging(t *testing.T) {
-	// Set up globals
-	globals.Appname = "test-app"
-	globals.Version = "1.0.0"
+	t.Parallel()
 
 	lc := fxtest.NewLifecycle(t)
-	g, err := globals.New(lc)
-	if err != nil {
-		t.Fatalf("globals.New() error = %v", err)
+
+	params := logger.LoggerParams{
+		Globals: testGlobals(),
 	}
 
-	params := LoggerParams{
-		Globals: g,
-	}
-
-	logger, err := New(lc, params)
+	l, err := logger.New(lc, params)
 	if err != nil {
 		t.Fatalf("New() error = %v", err)
 	}
 
 	// Enable debug logging should not panic
-	logger.EnableDebugLogging()
+	l.EnableDebugLogging()
 
 	// Test debug logging
-	logger.Get().Debug("debug message", "test", true)
+	l.Get().Debug("debug message", "test", true)
 }