fix: slog handler compatibility

Author: ucatbas

gcp_handler.go

@@ -27,55 +27,59 @@ import (
 
 // GoogleCloudSlogHandler wraps Google Cloud Logging's Logger for use with slog.
 type GoogleCloudSlogHandler struct {
-	client *logging.Client
-	logger *logging.Logger
-	level  slog.Level
+	logger      *logging.Logger
+	client      *logging.Client
+	level       slog.Leveler
+	groupPrefix string
+	attrs       []slog.Attr
 }
 
+var _ slog.Handler = &GoogleCloudSlogHandler{}
+
 // NewGoogleCloudSlogHandler initializes a new GoogleCloudSlogHandler.
-func NewGoogleCloudSlogHandler(ctx context.Context, projectID, logName string, level slog.Level) (*GoogleCloudSlogHandler, error) {
+func NewGoogleCloudSlogHandler(ctx context.Context, projectID, logName string, level slog.Level) *GoogleCloudSlogHandler {
 	client, err := logging.NewClient(ctx, projectID)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create logging client: %w", err)
+		return nil
 	}
 	return &GoogleCloudSlogHandler{
 		client: client,
 		logger: client.Logger(logName),
 		level:  level,
-	}, nil
+	}
+}
+
+func (h *GoogleCloudSlogHandler) Enabled(ctx context.Context, level slog.Level) bool {
+	minLevel := slog.LevelInfo
+	if h.level != nil {
+		minLevel = h.level.Level()
+	}
+	return level >= minLevel
 }
 
 // Handle adapts slog.Record entries to Google Cloud Logging entries.
 func (h *GoogleCloudSlogHandler) Handle(ctx context.Context, r slog.Record) error {
-	// Convert slog.Level to Google Cloud Logging severity
-	var severity logging.Severity
-	switch r.Level {
-	case slog.LevelDebug:
-		severity = logging.Debug
-	case slog.LevelInfo:
-		severity = logging.Info
-	case slog.LevelWarn:
-		severity = logging.Warning
-	case slog.LevelError:
-		severity = logging.Error
-	default:
-		severity = logging.Default
+	// Check if the log level is enabled
+	if !h.Enabled(ctx, r.Level) {
+		return nil
 	}
 
-	// Construct the payload with message and additional attributes
+	// Convert slog.Level to Google Cloud Logging severity
+	severity := h.mapSeverity(r.Level)
+
+	// Construct the payload with message, time, and additional attributes
 	payload := map[string]interface{}{
 		"message": r.Message,
-		"level":   r.Level.String(),
 		"time":    r.Time,
 	}
 
 	// Add attributes from slog fields
 	r.Attrs(func(a slog.Attr) bool {
-		payload[a.Key] = a.Value
+		payload[a.Key] = h.formatAttrValue(a.Value)
 		return true
 	})
 
-	// Send log entry to Google Cloud Logging
+	// Send log entry to Google Cloud Logging and return any errors
 	h.logger.Log(logging.Entry{
 		Payload:  payload,
 		Severity: severity,
@@ -84,6 +88,71 @@ func (h *GoogleCloudSlogHandler) Handle(ctx context.Context, r slog.Record) erro
 	return nil
 }
 
+// mapSeverity converts slog.Level to Google Cloud Logging's Severity.
+func (h *GoogleCloudSlogHandler) mapSeverity(level slog.Level) logging.Severity {
+	switch level {
+	case slog.LevelDebug:
+		return logging.Debug
+	case slog.LevelInfo:
+		return logging.Info
+	case slog.LevelWarn:
+		return logging.Warning
+	case slog.LevelError:
+		return logging.Error
+	default:
+		return logging.Default
+	}
+}
+
+// formatAttrValue formats attribute values for Google Cloud Logging.
+func (h *GoogleCloudSlogHandler) formatAttrValue(value interface{}) interface{} {
+	switch v := value.(type) {
+	case string, int, int64, float64, bool:
+		return v
+	case error:
+		return v.Error()
+	default:
+		return fmt.Sprintf("%v", v) // Fallback for unsupported types
+	}
+}
+
+func (h *GoogleCloudSlogHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	for i, attr := range attrs {
+		attrs[i] = withGroupPrefix(h.groupPrefix, attr)
+	}
+
+	return &GoogleCloudSlogHandler{
+		logger:      h.logger,
+		level:       h.level,
+		groupPrefix: h.groupPrefix,
+		attrs:       append(h.attrs, attrs...),
+	}
+}
+
+func (h *GoogleCloudSlogHandler) WithGroup(name string) slog.Handler {
+	if name == "" {
+		return h
+	}
+	prefix := name + "."
+	if h.groupPrefix != "" {
+		prefix = h.groupPrefix + prefix
+	}
+
+	return &GoogleCloudSlogHandler{
+		logger:      h.logger,
+		level:       h.level,
+		attrs:       h.attrs,
+		groupPrefix: prefix,
+	}
+}
+
+func withGroupPrefix(groupPrefix string, attr slog.Attr) slog.Attr {
+	if groupPrefix != "" {
+		attr.Key = groupPrefix + attr.Key
+	}
+	return attr
+}
+
 // Close closes the Google Cloud Logging client.
 func (h *GoogleCloudSlogHandler) Close() error {
 	return h.client.Close()

gcp_handler_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"testing"
-	"time"
 
 	"log/slog"
 
@@ -26,47 +25,16 @@ func TestGoogleCloudSlogHandler(t *testing.T) {
 
 	// Initialize GoogleCloudSlogHandler
 	logName := "test-log"
-	handler, err := NewGoogleCloudSlogHandler(ctx, projectID, logName, slog.LevelInfo)
-	if err != nil {
-		t.Fatalf("failed to initialize GoogleCloudSlogHandler: %v", err)
-	}
-	defer func() {
-		if err := handler.Close(); err != nil {
-			t.Fatalf("failed to close handler: %v", err)
-		}
-	}()
-
-	// Define test cases
-	testCases := []struct {
-		level   slog.Level
-		message string
-		attrs   []slog.Attr
-	}{
-		{slog.LevelDebug, "Debug message", []slog.Attr{slog.String("key1", "value1")}},
-		{slog.LevelInfo, "Info message", []slog.Attr{slog.String("key2", "value2")}},
-		{slog.LevelWarn, "Warning message", []slog.Attr{slog.Int("key3", 123)}},
-		{slog.LevelError, "Error message", []slog.Attr{slog.Float64("key4", 3.14)}},
-	}
+	handler := NewGoogleCloudSlogHandler(ctx, projectID, logName, slog.LevelInfo)
+	defer handler.Close()
 
-	// Execute each test case
-	for _, tc := range testCases {
-		// Create a record for each test case
-		record := slog.Record{
-			Time:    time.Now(),
-			Level:   tc.level,
-			Message: tc.message,
-		}
+	// Set the handler for slog
+	slog.SetDefault(slog.New(handler))
 
-		for _, attr := range tc.attrs {
-			record.AddAttrs(attr)
-		}
-
-		// Handle the record
-		err := handler.Handle(ctx, record)
-		if err != nil {
-			t.Fatalf("unexpected error in Handle: %v", err)
-		}
-	}
+	// Example log entries
+	slog.Info("Starting application", "version", "1.0")
+	slog.Warn("This is a warning message", "component", "main")
+	slog.Error("An error occurred", "error", "sample error")
 
 	fmt.Printf("All logs written successfully to log: %s\n", logName)
 }

version.go

@@ -18,5 +18,5 @@ package sloggcp
 
 // Version is the current release version of GCP Cloud Logging Slog in use.
 func Version() string {
-	return "0.0.1"
+	return "0.0.2"
 }