make log fields generic

Author: mattdholloway

pkg/observability/log/field.go

@@ -0,0 +1,29 @@
+package log
+
+import (
+	"fmt"
+	"time"
+)
+
+// Field is a key-value pair for structured logging.
+// This type is backend-agnostic — adapters convert it to their native field type.
+type Field struct {
+	Key   string
+	Value any
+}
+
+// Convenience constructors for common field types.
+
+func String(key, value string) Field       { return Field{Key: key, Value: value} }
+func Int(key string, value int) Field      { return Field{Key: key, Value: value} }
+func Int64(key string, value int64) Field  { return Field{Key: key, Value: value} }
+func Float64(key string, value float64) Field { return Field{Key: key, Value: value} }
+func Bool(key string, value bool) Field    { return Field{Key: key, Value: value} }
+func Err(err error) Field                  { return Field{Key: "error", Value: err} }
+func Duration(key string, value time.Duration) Field { return Field{Key: key, Value: value} }
+func Any(key string, value any) Field      { return Field{Key: key, Value: value} }
+
+// Stringer returns the string representation of a Field.
+func (f Field) String() string {
+	return fmt.Sprintf("%s=%v", f.Key, f.Value)
+}

pkg/observability/log/logger.go

@@ -2,17 +2,16 @@ package log
 
 import (
 	"context"
-	"log/slog"
 )
 
 type Logger interface {
-	Log(ctx context.Context, level Level, msg string, fields ...slog.Attr)
-	Debug(msg string, fields ...slog.Attr)
-	Info(msg string, fields ...slog.Attr)
-	Warn(msg string, fields ...slog.Attr)
-	Error(msg string, fields ...slog.Attr)
-	Fatal(msg string, fields ...slog.Attr)
-	WithFields(fields ...slog.Attr) Logger
+	Log(ctx context.Context, level Level, msg string, fields ...Field)
+	Debug(msg string, fields ...Field)
+	Info(msg string, fields ...Field)
+	Warn(msg string, fields ...Field)
+	Error(msg string, fields ...Field)
+	Fatal(msg string, fields ...Field)
+	WithFields(fields ...Field) Logger
 	WithError(err error) Logger
 	Named(name string) Logger
 	WithLevel(level Level) Logger

pkg/observability/log/noop_adapter.go

@@ -2,7 +2,6 @@ package log
 
 import (
 	"context"
-	"log/slog"
 )
 
 type NoopLogger struct{}
@@ -17,31 +16,31 @@ func (l *NoopLogger) Level() Level {
 	return DebugLevel
 }
 
-func (l *NoopLogger) Log(_ context.Context, _ Level, _ string, _ ...slog.Attr) {
+func (l *NoopLogger) Log(_ context.Context, _ Level, _ string, _ ...Field) {
 	// No-op
 }
 
-func (l *NoopLogger) Debug(_ string, _ ...slog.Attr) {
+func (l *NoopLogger) Debug(_ string, _ ...Field) {
 	// No-op
 }
 
-func (l *NoopLogger) Info(_ string, _ ...slog.Attr) {
+func (l *NoopLogger) Info(_ string, _ ...Field) {
 	// No-op
 }
 
-func (l *NoopLogger) Warn(_ string, _ ...slog.Attr) {
+func (l *NoopLogger) Warn(_ string, _ ...Field) {
 	// No-op
 }
 
-func (l *NoopLogger) Error(_ string, _ ...slog.Attr) {
+func (l *NoopLogger) Error(_ string, _ ...Field) {
 	// No-op
 }
 
-func (l *NoopLogger) Fatal(_ string, _ ...slog.Attr) {
+func (l *NoopLogger) Fatal(_ string, _ ...Field) {
 	// No-op
 }
 
-func (l *NoopLogger) WithFields(_ ...slog.Attr) Logger {
+func (l *NoopLogger) WithFields(_ ...Field) Logger {
 	return l
 }
 

pkg/observability/log/slog_adapter.go

@@ -2,6 +2,7 @@ package log
 
 import (
 	"context"
+	"fmt"
 	"log/slog"
 )
 
@@ -21,42 +22,40 @@ func (l *SlogLogger) Level() Level {
 	return l.level
 }
 
-func (l *SlogLogger) Log(ctx context.Context, level Level, msg string, fields ...slog.Attr) {
+func (l *SlogLogger) Log(ctx context.Context, level Level, msg string, fields ...Field) {
 	slogLevel := convertLevel(level)
-	l.logger.LogAttrs(ctx, slogLevel, msg, fields...)
+	l.logger.LogAttrs(ctx, slogLevel, msg, fieldsToSlogAttrs(fields)...)
 }
 
-func (l *SlogLogger) Debug(msg string, fields ...slog.Attr) {
+func (l *SlogLogger) Debug(msg string, fields ...Field) {
 	l.Log(context.Background(), DebugLevel, msg, fields...)
 }
 
-func (l *SlogLogger) Info(msg string, fields ...slog.Attr) {
+func (l *SlogLogger) Info(msg string, fields ...Field) {
 	l.Log(context.Background(), InfoLevel, msg, fields...)
 }
 
-func (l *SlogLogger) Warn(msg string, fields ...slog.Attr) {
+func (l *SlogLogger) Warn(msg string, fields ...Field) {
 	l.Log(context.Background(), WarnLevel, msg, fields...)
 }
 
-func (l *SlogLogger) Error(msg string, fields ...slog.Attr) {
+func (l *SlogLogger) Error(msg string, fields ...Field) {
 	l.Log(context.Background(), ErrorLevel, msg, fields...)
 }
 
-func (l *SlogLogger) Fatal(msg string, fields ...slog.Attr) {
+func (l *SlogLogger) Fatal(msg string, fields ...Field) {
 	l.Log(context.Background(), FatalLevel, msg, fields...)
-	// Sync to ensure the log message is flushed before panic
 	_ = l.Sync()
 	panic("fatal: " + msg)
 }
 
-func (l *SlogLogger) WithFields(fields ...slog.Attr) Logger {
-	fieldKvPairs := make([]any, 0, len(fields)*2)
-	for _, attr := range fields {
-		k, v := attr.Key, attr.Value
-		fieldKvPairs = append(fieldKvPairs, k, v.Any())
+func (l *SlogLogger) WithFields(fields ...Field) Logger {
+	args := make([]any, 0, len(fields)*2)
+	for _, f := range fields {
+		args = append(args, f.Key, f.Value)
 	}
 	return &SlogLogger{
-		logger: l.logger.With(fieldKvPairs...),
+		logger: l.logger.With(args...),
 		level:  l.level,
 	}
 }
@@ -86,10 +85,17 @@ func (l *SlogLogger) WithLevel(level Level) Logger {
 }
 
 func (l *SlogLogger) Sync() error {
-	// Slog does not require syncing
 	return nil
 }
 
+func fieldsToSlogAttrs(fields []Field) []slog.Attr {
+	attrs := make([]slog.Attr, 0, len(fields))
+	for _, f := range fields {
+		attrs = append(attrs, slog.Any(f.Key, f.Value))
+	}
+	return attrs
+}
+
 func convertLevel(level Level) slog.Level {
 	switch level {
 	case DebugLevel:
@@ -106,3 +112,8 @@ func convertLevel(level Level) slog.Level {
 		return slog.LevelInfo
 	}
 }
+
+// FormatValue formats any value as a string, used by adapters for display.
+func FormatValue(v any) string {
+	return fmt.Sprintf("%v", v)
+}

pkg/observability/log/slog_adapter_test.go

@@ -49,7 +49,7 @@ func TestSlogLogger_ConvenienceMethods(t *testing.T) {
 
 	tests := []struct {
 		name    string
-		logFunc func(string, ...slog.Attr)
+		logFunc func(string, ...Field)
 		level   string
 	}{
 		{"Debug", logger.Debug, "DEBUG"},
@@ -61,7 +61,7 @@ func TestSlogLogger_ConvenienceMethods(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			buf.Reset()
-			tt.logFunc("test message", slog.String("key", "value"))
+			tt.logFunc("test message", String("key", "value"))
 
 			output := buf.String()
 			assert.Contains(t, output, "test message")
@@ -76,12 +76,10 @@ func TestSlogLogger_Fatal(t *testing.T) {
 	slogger := slog.New(slog.NewTextHandler(buf, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	logger := NewSlogLogger(slogger, DebugLevel)
 
-	// Fatal should panic after logging
 	assert.Panics(t, func() {
 		logger.Fatal("fatal message")
 	})
 
-	// Verify the message was logged before panic
 	assert.Contains(t, buf.String(), "fatal message")
 }
 
@@ -90,10 +88,9 @@ func TestSlogLogger_WithFields(t *testing.T) {
 	slogger := slog.New(slog.NewTextHandler(buf, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	logger := NewSlogLogger(slogger, InfoLevel)
 
-	// Add fields and log
 	loggerWithFields := logger.WithFields(
-		slog.String("service", "test-service"),
-		slog.Int("port", 8080),
+		String("service", "test-service"),
+		Int("port", 8080),
 	)
 
 	loggerWithFields.Info("message with fields")
@@ -105,7 +102,6 @@ func TestSlogLogger_WithFields(t *testing.T) {
 	assert.Contains(t, output, "port")
 	assert.Contains(t, output, "8080")
 
-	// Original logger should not have the fields
 	buf.Reset()
 	logger.Info("message without fields")
 	output = buf.String()
@@ -147,10 +143,8 @@ func TestSlogLogger_WithLevel(t *testing.T) {
 	slogger := slog.New(slog.NewTextHandler(buf, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	logger := NewSlogLogger(slogger, InfoLevel)
 
-	// New logger with debug level
 	debugLogger := logger.WithLevel(DebugLevel)
 
-	// Verify levels are correct
 	assert.Equal(t, InfoLevel, logger.Level())
 	assert.Equal(t, DebugLevel, debugLogger.Level())
 }
@@ -160,7 +154,6 @@ func TestSlogLogger_Sync(t *testing.T) {
 	slogger := slog.New(slog.NewTextHandler(buf, nil))
 	logger := NewSlogLogger(slogger, InfoLevel)
 
-	// Sync should not error for slog (no-op)
 	err := logger.Sync()
 	assert.NoError(t, err)
 }
@@ -170,10 +163,9 @@ func TestSlogLogger_Chaining(t *testing.T) {
 	slogger := slog.New(slog.NewTextHandler(buf, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	logger := NewSlogLogger(slogger, DebugLevel)
 
-	// Chain multiple operations
 	chainedLogger := logger.
 		Named("service").
-		WithFields(slog.String("version", "1.0")).
+		WithFields(String("version", "1.0")).
 		WithLevel(InfoLevel)
 
 	chainedLogger.Info("chained message")
@@ -222,7 +214,7 @@ func TestSlogLogger_LogWithContext(t *testing.T) {
 	logger := NewSlogLogger(slogger, DebugLevel)
 
 	ctx := context.Background()
-	logger.Log(ctx, InfoLevel, "context message", slog.String("trace_id", "abc123"))
+	logger.Log(ctx, InfoLevel, "context message", String("trace_id", "abc123"))
 
 	output := buf.String()
 	assert.Contains(t, output, "context message")
@@ -235,7 +227,7 @@ func TestSlogLogger_WithFields_PreservesLevel(t *testing.T) {
 	slogger := slog.New(slog.NewTextHandler(buf, &slog.HandlerOptions{Level: slog.LevelDebug}))
 	logger := NewSlogLogger(slogger, WarnLevel)
 
-	withFields := logger.WithFields(slog.String("key", "value"))
+	withFields := logger.WithFields(String("key", "value"))
 
 	assert.Equal(t, WarnLevel, withFields.Level())
 
@@ -262,10 +254,10 @@ func TestSlogLogger_MultipleFields(t *testing.T) {
 	logger := NewSlogLogger(slogger, DebugLevel)
 
 	logger.Info("multi-field message",
-		slog.String("string_field", "value"),
-		slog.Int("int_field", 42),
-		slog.Bool("bool_field", true),
-		slog.Float64("float_field", 3.14),
+		String("string_field", "value"),
+		Int("int_field", 42),
+		Bool("bool_field", true),
+		Float64("float_field", 3.14),
 	)
 
 	output := buf.String()