Structured logging support for slog (#1033)

Author: giortzisg

_examples/slog/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"time"
@@ -22,9 +23,15 @@ func main() {
 
 	defer sentry.Flush(2 * time.Second)
 
-	logger := slog.New(sentryslog.Option{Level: slog.LevelDebug}.NewSentryHandler())
+	ctx := context.Background()
+	handler := sentryslog.Option{
+		EventLevel: []slog.Level{slog.LevelError, sentryslog.LevelFatal}, // Only Error and Fatal as events
+		LogLevel:   []slog.Level{slog.LevelWarn, slog.LevelInfo},         // Only Warn and Info as logs
+	}.NewSentryHandler(ctx)
+	logger := slog.New(handler)
 	logger = logger.With("release", "v1.0.0")
 
+	// message level is Error and will be handled only as Event.
 	logger.
 		With(
 			slog.Group("user",

slog/README.MD

@@ -29,38 +29,43 @@ import (
 	"log/slog"
 
 	"github.com/getsentry/sentry-go"
-	slogSentry "github.com/getsentry/sentry-go/slog"
+	sentryslog "github.com/getsentry/sentry-go/slog"
 )
 
 func main() {
 	// Initialize Sentry
 	err := sentry.Init(sentry.ClientOptions{
 		Dsn: "your-public-dsn",
 		Debug: true,
+        EnableLogs: true, 
 	})
 	if err != nil {
 		panic(err)
 	}
 	defer sentry.Flush(5 * time.Second)
 
-	// Set up slog with Sentry handler
-	handler := slogSentry.Option{
-		Level: slog.LevelError, // Minimum log level
-		AddSource: true,        // Include file/line source info
-	}.NewSentryHandler()
-	logger := slog.New(handler)
+	ctx := context.Background()
+	handler := sentryslog.Option{
+		EventLevel: []slog.Level{slog.LevelError, sentryslog.LevelFatal}, // Only Error and Fatal as events
+		LogLevel:   []slog.Level{slog.LevelWarn, slog.LevelInfo},         // Only Warn and Info as logs
+	}.NewSentryHandler(ctx)
+    logger := slog.New(handler)
 
 	// Example logging
-	logger.Info("This will not be sent to Sentry")
-	logger.Error("An error occurred", "user", "test-user")
+	logger.Info("This will be sent to sentry as a Log entry")
+	logger.Error("An error occurred", "user", "test-user") // this will be sent as an Event
+	// These will be ignored
+	logger.Debug("This will be ignored")
 }
 ```
 
 ## Configuration
 
 The slog-sentry package offers several options to customize how logs are handled and sent to Sentry. These are specified through the Option struct:
 
-- `Level`: Minimum log level to send to Sentry. Defaults to `slog.LevelDebug`.
+- `EventLevel`: Slice of specific levels to send `Events` to Sentry. Defaults to `[]slog.Level{slog.LevelError, LevelFatal}`.
+
+- `LogLevel`: Slice of specific levels to send `Log` entries to Sentry. Defaults to `[]slog.Level{slog.LevelDebug, slog.LevelInfo, slog.LevelWarn, slog.LevelError, LevelFatal}`.
 
 - `Hub`: Custom Sentry hub to use; defaults to the current Sentry hub if not set.
 
@@ -77,7 +82,7 @@ The slog-sentry package offers several options to customize how logs are handled
 
 ```go
 handler := slogSentry.Option{
-	Level: slog.LevelWarn,
+	EventLevel: slog.LevelWarn,
 	Converter: func(addSource bool, replaceAttr func([]string, slog.Attr) slog.Attr, attrs []slog.Attr, groups []string, record *slog.Record, hub *sentry.Hub) *sentry.Event {
 		// Custom conversion logic
 		return &sentry.Event{
@@ -88,6 +93,22 @@ handler := slogSentry.Option{
 }.NewSentryHandler()
 ```
 
+### Backwards Compatibility
+
+The old `Level` field is Deprecated but still works and will be converted to a slice of all levels starting from the minimum level:
+
+```go
+// Old way (still works)
+handler := sentryslog.Option{
+    Level: slog.LevelWarn, // Will be converted to EventLevel: [Warn, Error, Fatal]
+}.NewSentryHandler(ctx)
+
+// New way (preferred)
+handler := sentryslog.Option{
+    EventLevel: []slog.Level{slog.LevelWarn, slog.LevelError, sentryslog.LevelFatal},
+    LogLevel:   []slog.Level{slog.LevelDebug, slog.LevelInfo, slog.LevelWarn, slog.LevelError, sentryslog.LevelFatal},
+}.NewSentryHandler(ctx)
+```
 ## Notes
 
 - Always call `Flush` or `FlushWithContext` to ensure all events are sent to Sentry before program termination

slog/converter.go

@@ -4,9 +4,13 @@ import (
 	"encoding"
 	"fmt"
 	"log/slog"
+	"math"
 	"net/http"
+	"strconv"
+	"time"
 
 	"github.com/getsentry/sentry-go"
+	"github.com/getsentry/sentry-go/attribute"
 )
 
 var (
@@ -129,3 +133,46 @@ func handleFingerprint(v slog.Value, event *sentry.Event) {
 		event.Fingerprint = fingerprint
 	}
 }
+
+func attrToSentryLog(group string, a slog.Attr) []attribute.Builder {
+	key := group + a.Key
+	switch a.Value.Kind() {
+	case slog.KindAny:
+		return []attribute.Builder{attribute.String(key, fmt.Sprintf("%+v", a.Value.Any()))}
+	case slog.KindBool:
+		return []attribute.Builder{attribute.Bool(key, a.Value.Bool())}
+	case slog.KindDuration:
+		return []attribute.Builder{attribute.String(key, a.Value.Duration().String())}
+	case slog.KindFloat64:
+		return []attribute.Builder{attribute.Float64(key, a.Value.Float64())}
+	case slog.KindInt64:
+		return []attribute.Builder{attribute.Int64(key, a.Value.Int64())}
+	case slog.KindString:
+		return []attribute.Builder{attribute.String(key, a.Value.String())}
+	case slog.KindTime:
+		return []attribute.Builder{attribute.String(key, a.Value.Time().Format(time.RFC3339))}
+	case slog.KindUint64:
+		val := a.Value.Uint64()
+		if val <= math.MaxInt64 {
+			return []attribute.Builder{attribute.Int64(key, int64(val))}
+		} else {
+			return []attribute.Builder{attribute.String(key, strconv.FormatUint(val, 10))}
+		}
+	case slog.KindLogValuer:
+		return []attribute.Builder{attribute.String(key, a.Value.LogValuer().LogValue().String())}
+	case slog.KindGroup:
+		// Handle nested group attributes
+		var attrs []attribute.Builder
+		groupPrefix := key
+		if groupPrefix != "" {
+			groupPrefix += "."
+		}
+		for _, subAttr := range a.Value.Group() {
+			attrs = append(attrs, attrToSentryLog(groupPrefix, subAttr)...)
+		}
+		return attrs
+	}
+
+	sentry.DebugLogger.Printf("Invalid type: dropping attribute with key: %v and value: %v", a.Key, a.Value)
+	return []attribute.Builder{}
+}