build: go 1.24

We were running behind and there were quite some deprecations to update.
This was mostly in the upstream copy/pasta package but seems quite
minimal.

vendor/github.com/charmbracelet/log/.golangci.yml

@@ -15,20 +15,27 @@ issues:
 linters:
   enable:
     - bodyclose
-    - dupl
-    - exportloopref
+    - exhaustive
     - goconst
     - godot
     - godox
+    - gofumpt
     - goimports
+    - gomoddirectives
     - goprintffuncname
     - gosec
     - misspell
+    - nakedret
+    - nestif
+    - nilerr
+    - noctx
     - nolintlint
     - prealloc
     - revive
     - rowserrcheck
     - sqlclosecheck
+    - tparallel
     - unconvert
     - unparam
     - whitespace
+    - wrapcheck

vendor/github.com/charmbracelet/log/json.go

@@ -1,61 +1,151 @@
 package log
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"time"
 )
 
 func (l *Logger) jsonFormatter(keyvals ...interface{}) {
-	m := make(map[string]interface{}, len(keyvals)/2)
-	for i := 0; i < len(keyvals); i += 2 {
-		switch keyvals[i] {
-		case TimestampKey:
-			if t, ok := keyvals[i+1].(time.Time); ok {
-				m[TimestampKey] = t.Format(l.timeFormat)
-			}
-		case LevelKey:
-			if level, ok := keyvals[i+1].(Level); ok {
-				m[LevelKey] = level.String()
-			}
-		case CallerKey:
-			if caller, ok := keyvals[i+1].(string); ok {
-				m[CallerKey] = caller
-			}
-		case PrefixKey:
-			if prefix, ok := keyvals[i+1].(string); ok {
-				m[PrefixKey] = prefix
-			}
-		case MessageKey:
-			if msg := keyvals[i+1]; msg != nil {
-				m[MessageKey] = fmt.Sprint(msg)
-			}
+	jw := &jsonWriter{w: &l.b}
+	jw.start()
+
+	i := 0
+	for i < len(keyvals) {
+		switch kv := keyvals[i].(type) {
+		case slogAttr:
+			l.jsonFormatterRoot(jw, kv.Key, kv.Value)
+			i++
 		default:
-			var (
-				key string
-				val interface{}
-			)
-			switch k := keyvals[i].(type) {
-			case fmt.Stringer:
-				key = k.String()
-			case error:
-				key = k.Error()
-			default:
-				key = fmt.Sprint(k)
+			if i+1 < len(keyvals) {
+				l.jsonFormatterRoot(jw, keyvals[i], keyvals[i+1])
 			}
-			switch v := keyvals[i+1].(type) {
-			case error:
-				val = v.Error()
-			case fmt.Stringer:
-				val = v.String()
-			default:
-				val = v
-			}
-			m[key] = val
+			i += 2
 		}
 	}
 
-	e := json.NewEncoder(&l.b)
-	e.SetEscapeHTML(false)
-	_ = e.Encode(m)
+	jw.end()
+	l.b.WriteRune('\n')
+}
+
+func (l *Logger) jsonFormatterRoot(jw *jsonWriter, key, value any) {
+	switch key {
+	case TimestampKey:
+		if t, ok := value.(time.Time); ok {
+			jw.objectItem(TimestampKey, t.Format(l.timeFormat))
+		}
+	case LevelKey:
+		if level, ok := value.(Level); ok {
+			jw.objectItem(LevelKey, level.String())
+		}
+	case CallerKey:
+		if caller, ok := value.(string); ok {
+			jw.objectItem(CallerKey, caller)
+		}
+	case PrefixKey:
+		if prefix, ok := value.(string); ok {
+			jw.objectItem(PrefixKey, prefix)
+		}
+	case MessageKey:
+		if msg := value; msg != nil {
+			jw.objectItem(MessageKey, fmt.Sprint(msg))
+		}
+	default:
+		l.jsonFormatterItem(jw, key, value)
+	}
+}
+
+func (l *Logger) jsonFormatterItem(jw *jsonWriter, key, value any) {
+	switch k := key.(type) {
+	case fmt.Stringer:
+		jw.objectKey(k.String())
+	case error:
+		jw.objectKey(k.Error())
+	default:
+		jw.objectKey(fmt.Sprint(k))
+	}
+	switch v := value.(type) {
+	case error:
+		jw.objectValue(v.Error())
+	case slogLogValuer:
+		l.writeSlogValue(jw, v.LogValue())
+	case slogValue:
+		l.writeSlogValue(jw, v.Resolve())
+	case fmt.Stringer:
+		jw.objectValue(v.String())
+	default:
+		jw.objectValue(v)
+	}
+}
+
+func (l *Logger) writeSlogValue(jw *jsonWriter, v slogValue) {
+	switch v.Kind() { //nolint:exhaustive
+	case slogKindGroup:
+		jw.start()
+		for _, attr := range v.Group() {
+			l.jsonFormatterItem(jw, attr.Key, attr.Value)
+		}
+		jw.end()
+	default:
+		jw.objectValue(v.Any())
+	}
+}
+
+type jsonWriter struct {
+	w *bytes.Buffer
+	d int
+}
+
+func (w *jsonWriter) start() {
+	w.w.WriteRune('{')
+	w.d = 0
+}
+
+func (w *jsonWriter) end() {
+	w.w.WriteRune('}')
+}
+
+func (w *jsonWriter) objectItem(key string, value any) {
+	w.objectKey(key)
+	w.objectValue(value)
+}
+
+func (w *jsonWriter) objectKey(key string) {
+	if w.d > 0 {
+		w.w.WriteRune(',')
+	}
+	w.d++
+
+	pos := w.w.Len()
+	err := w.writeEncoded(key)
+	if err != nil {
+		w.w.Truncate(pos)
+		w.w.WriteString(`"invalid key"`)
+	}
+	w.w.WriteRune(':')
+}
+
+func (w *jsonWriter) objectValue(value any) {
+	pos := w.w.Len()
+	err := w.writeEncoded(value)
+	if err != nil {
+		w.w.Truncate(pos)
+		w.w.WriteString(`"invalid value"`)
+	}
+}
+
+func (w *jsonWriter) writeEncoded(v any) error {
+	e := json.NewEncoder(w.w)
+	e.SetEscapeHTML(false)
+	if err := e.Encode(v); err != nil {
+		return fmt.Errorf("failed to encode value: %w", err)
+	}
+
+	// trailing \n added by json.Encode
+	b := w.w.Bytes()
+	if len(b) > 0 && b[len(b)-1] == '\n' {
+		w.w.Truncate(w.w.Len() - 1)
+	}
+	return nil
 }

vendor/github.com/charmbracelet/log/level.go

@@ -8,7 +8,7 @@ import (
 )
 
 // Level is a logging level.
-type Level int32
+type Level int
 
 const (
 	// DebugLevel is the debug level.
@@ -22,12 +22,12 @@ const (
 	// FatalLevel is the fatal level.
 	FatalLevel Level = 12
 	// noLevel is used with log.Print.
-	noLevel Level = math.MaxInt32
+	noLevel Level = math.MaxInt
 )
 
 // String returns the string representation of the level.
 func (l Level) String() string {
-	switch l {
+	switch l { //nolint:exhaustive
 	case DebugLevel:
 		return "debug"
 	case InfoLevel:

vendor/github.com/charmbracelet/log/level_121.go

@@ -1,15 +0,0 @@
-//go:build go1.21
-// +build go1.21
-
-package log
-
-import "log/slog"
-
-// fromSlogLevel converts slog.Level to log.Level.
-var fromSlogLevel = map[slog.Level]Level{
-	slog.LevelDebug: DebugLevel,
-	slog.LevelInfo:  InfoLevel,
-	slog.LevelWarn:  WarnLevel,
-	slog.LevelError: ErrorLevel,
-	slog.Level(12):  FatalLevel,
-}

vendor/github.com/charmbracelet/log/level_no121.go

@@ -1,15 +0,0 @@
-//go:build !go1.21
-// +build !go1.21
-
-package log
-
-import "golang.org/x/exp/slog"
-
-// fromSlogLevel converts slog.Level to log.Level.
-var fromSlogLevel = map[slog.Level]Level{
-	slog.LevelDebug: DebugLevel,
-	slog.LevelInfo:  InfoLevel,
-	slog.LevelWarn:  WarnLevel,
-	slog.LevelError: ErrorLevel,
-	slog.Level(12):  FatalLevel,
-}

vendor/github.com/charmbracelet/log/logger.go

@@ -30,7 +30,7 @@ type Logger struct {
 
 	isDiscard uint32
 
-	level           int32
+	level           int64
 	prefix          string
 	timeFunc        TimeFunction
 	timeFormat      string
@@ -59,7 +59,7 @@ func (l *Logger) Log(level Level, msg interface{}, keyvals ...interface{}) {
 	}
 
 	// check if the level is allowed
-	if atomic.LoadInt32(&l.level) > int32(level) {
+	if atomic.LoadInt64(&l.level) > int64(level) {
 		return
 	}
 
@@ -129,6 +129,8 @@ func (l *Logger) handle(level Level, ts time.Time, frames []runtime.Frame, msg i
 		l.logfmtFormatter(kvs...)
 	case JSONFormatter:
 		l.jsonFormatter(kvs...)
+	case TextFormatter:
+		fallthrough
 	default:
 		l.textFormatter(kvs...)
 	}
@@ -234,7 +236,7 @@ func (l *Logger) GetLevel() Level {
 func (l *Logger) SetLevel(level Level) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
-	atomic.StoreInt32(&l.level, int32(level))
+	atomic.StoreInt64(&l.level, int64(level))
 }
 
 // GetPrefix returns the current prefix.
@@ -334,7 +336,8 @@ func (l *Logger) With(keyvals ...interface{}) *Logger {
 	sl.b = bytes.Buffer{}
 	sl.mu = &sync.RWMutex{}
 	sl.helpers = &sync.Map{}
-	sl.fields = append(l.fields, keyvals...)
+	sl.fields = append(make([]interface{}, 0, len(l.fields)+len(keyvals)), l.fields...)
+	sl.fields = append(sl.fields, keyvals...)
 	sl.styles = &st
 	return &sl
 }

vendor/github.com/charmbracelet/log/logger_121.go

@@ -10,11 +10,20 @@ import (
 	"sync/atomic"
 )
 
+// type aliases for slog.
+type (
+	slogAttr      = slog.Attr
+	slogValue     = slog.Value
+	slogLogValuer = slog.LogValuer
+)
+
+const slogKindGroup = slog.KindGroup
+
 // Enabled reports whether the logger is enabled for the given level.
 //
 // Implements slog.Handler.
 func (l *Logger) Enabled(_ context.Context, level slog.Level) bool {
-	return atomic.LoadInt32(&l.level) <= int32(fromSlogLevel[level])
+	return atomic.LoadInt64(&l.level) <= int64(level)
 }
 
 // Handle handles the Record. It will only be called if Enabled returns true.
@@ -27,13 +36,13 @@ func (l *Logger) Handle(ctx context.Context, record slog.Record) error {
 
 	fields := make([]interface{}, 0, record.NumAttrs()*2)
 	record.Attrs(func(a slog.Attr) bool {
-		fields = append(fields, a.Key, a.Value.String())
+		fields = append(fields, a.Key, a.Value)
 		return true
 	})
 	// Get the caller frame using the record's PC.
 	frames := runtime.CallersFrames([]uintptr{record.PC})
 	frame, _ := frames.Next()
-	l.handle(fromSlogLevel[record.Level], l.timeFunc(record.Time), []runtime.Frame{frame}, record.Message, fields...)
+	l.handle(Level(record.Level), l.timeFunc(record.Time), []runtime.Frame{frame}, record.Message, fields...)
 	return nil
 }
 

vendor/github.com/charmbracelet/log/logger_no121.go

@@ -11,11 +11,20 @@ import (
 	"golang.org/x/exp/slog"
 )
 
+// type alises for slog.
+type (
+	slogAttr      = slog.Attr
+	slogValue     = slog.Value
+	slogLogValuer = slog.LogValuer
+)
+
+const slogKindGroup = slog.KindGroup
+
 // Enabled reports whether the logger is enabled for the given level.
 //
 // Implements slog.Handler.
 func (l *Logger) Enabled(_ context.Context, level slog.Level) bool {
-	return atomic.LoadInt32(&l.level) <= int32(fromSlogLevel[level])
+	return atomic.LoadInt64(&l.level) <= int64(level)
 }
 
 // Handle handles the Record. It will only be called if Enabled returns true.
@@ -24,13 +33,13 @@ func (l *Logger) Enabled(_ context.Context, level slog.Level) bool {
 func (l *Logger) Handle(_ context.Context, record slog.Record) error {
 	fields := make([]interface{}, 0, record.NumAttrs()*2)
 	record.Attrs(func(a slog.Attr) bool {
-		fields = append(fields, a.Key, a.Value.String())
+		fields = append(fields, a.Key, a.Value)
 		return true
 	})
 	// Get the caller frame using the record's PC.
 	frames := runtime.CallersFrames([]uintptr{record.PC})
 	frame, _ := frames.Next()
-	l.handle(fromSlogLevel[record.Level], l.timeFunc(record.Time), []runtime.Frame{frame}, record.Message, fields...)
+	l.handle(Level(record.Level), l.timeFunc(record.Time), []runtime.Frame{frame}, record.Message, fields...)
 	return nil
 }
 

vendor/github.com/charmbracelet/log/pkg.go

@@ -7,6 +7,7 @@ import (
 	"log"
 	"os"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"github.com/muesli/termenv"
@@ -17,25 +18,27 @@ var (
 	registry = sync.Map{}
 
 	// defaultLogger is the default global logger instance.
+	defaultLogger     atomic.Pointer[Logger]
 	defaultLoggerOnce sync.Once
-	defaultLogger     *Logger
 )
 
 // Default returns the default logger. The default logger comes with timestamp enabled.
 func Default() *Logger {
-	defaultLoggerOnce.Do(func() {
-		if defaultLogger != nil {
-			// already set via SetDefault.
-			return
-		}
-		defaultLogger = NewWithOptions(os.Stderr, Options{ReportTimestamp: true})
-	})
-	return defaultLogger
+	dl := defaultLogger.Load()
+	if dl == nil {
+		defaultLoggerOnce.Do(func() {
+			defaultLogger.CompareAndSwap(
+				nil, NewWithOptions(os.Stderr, Options{ReportTimestamp: true}),
+			)
+		})
+		dl = defaultLogger.Load()
+	}
+	return dl
 }
 
 // SetDefault sets the default global logger.
 func SetDefault(logger *Logger) {
-	defaultLogger = logger
+	defaultLogger.Store(logger)
 }
 
 // New returns a new logger with the default options.
@@ -49,7 +52,7 @@ func NewWithOptions(w io.Writer, o Options) *Logger {
 		b:               bytes.Buffer{},
 		mu:              &sync.RWMutex{},
 		helpers:         &sync.Map{},
-		level:           int32(o.Level),
+		level:           int64(o.Level),
 		reportTimestamp: o.ReportTimestamp,
 		reportCaller:    o.ReportCaller,
 		prefix:          o.Prefix,

vendor/github.com/charmbracelet/log/stdlog.go

@@ -14,7 +14,7 @@ func (l *stdLogWriter) Write(p []byte) (n int, err error) {
 	str := strings.TrimSuffix(string(p), "\n")
 
 	if l.opt != nil {
-		switch l.opt.ForceLevel {
+		switch l.opt.ForceLevel { //nolint:exhaustive
 		case DebugLevel:
 			l.l.Debug(str)
 		case InfoLevel:

vendor/github.com/charmbracelet/log/text.go

@@ -21,7 +21,7 @@ func (l *Logger) writeIndent(w io.Writer, str string, indent string, newline boo
 	// kindly borrowed from hclog
 	for {
 		nl := strings.IndexByte(str, '\n')
-		if nl == -1 {
+		if nl == -1 { //nolint:nestif
 			if str != "" {
 				_, _ = w.Write([]byte(indent))
 				val := escapeStringForOutput(str, false)