Add slog logging handler

Author: mihaioprescu

go.mod

@@ -5,6 +5,7 @@ go 1.22
 toolchain go1.22.0
 
 require (
+	github.com/samber/lo v1.47.0
 	github.com/sirupsen/logrus v1.9.3
 	github.com/stretchr/testify v1.9.0
 	github.com/uptrace/opentelemetry-go-extra/otellogrus v0.3.1
@@ -27,6 +28,7 @@ require (
 	go.opentelemetry.io/otel/log v0.4.0 // indirect
 	go.opentelemetry.io/otel/metric v1.29.0 // indirect
 	golang.org/x/sys v0.24.0 // indirect
+	golang.org/x/text v0.16.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -26,6 +26,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
+github.com/samber/lo v1.47.0 h1:z7RynLwP5nbyRscyvcD043DWYoOcYRv3mV8lBeqOCLc=
+github.com/samber/lo v1.47.0/go.mod h1:RmDH9Ct32Qy3gduHQuKJ3gW1fMHAnE/fAzQuf6He5cU=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
@@ -51,6 +53,8 @@ go.opentelemetry.io/otel/trace v1.29.0/go.mod h1:eHl3w0sp3paPkYstJOmAimxhiFXPg+M
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
 golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
+golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=

slog/converter.go

@@ -0,0 +1,216 @@
+package slog
+
+import (
+	"context"
+	"github.com/samber/lo"
+	"log/slog"
+	"runtime"
+	"slices"
+)
+
+var sourceKey = "source"
+var errorKeys = []string{"error", "err"}
+
+func convert(addSource bool, replaceAttr func(groups []string, a slog.Attr) slog.Attr, loggerAttr []slog.Attr, groups []string, record *slog.Record) map[string]any {
+	attrs := appendRecordAttrsToAttrs(loggerAttr, groups, record)
+
+	attrs = replaceError(attrs, errorKeys...)
+	if addSource {
+		attrs = append(attrs, source(sourceKey, record))
+	}
+	attrs = replaceAttrs(replaceAttr, []string{}, attrs...)
+	attrs = removeEmptyAttrs(attrs)
+
+	output := attrsToMap(attrs...)
+
+	return output
+}
+
+type replaceAttrFn = func(groups []string, a slog.Attr) slog.Attr
+
+func appendRecordAttrsToAttrs(attrs []slog.Attr, groups []string, record *slog.Record) []slog.Attr {
+	output := slices.Clone(attrs)
+
+	slices.Reverse(groups)
+	record.Attrs(func(attr slog.Attr) bool {
+		for i := range groups {
+			attr = slog.Group(groups[i], attr)
+		}
+		output = append(output, attr)
+		return true
+	})
+
+	return output
+}
+
+func replaceError(attrs []slog.Attr, errorKeys ...string) []slog.Attr {
+	replaceAttr := func(groups []string, a slog.Attr) slog.Attr {
+		if len(groups) > 1 {
+			return a
+		}
+
+		for i := range errorKeys {
+			if a.Key == errorKeys[i] {
+				if err, ok := a.Value.Any().(error); ok {
+					return slog.Any(a.Key, err.Error())
+				}
+			}
+		}
+		return a
+	}
+	return replaceAttrs(replaceAttr, []string{}, attrs...)
+}
+
+func replaceAttrs(fn replaceAttrFn, groups []string, attrs ...slog.Attr) []slog.Attr {
+	for i := range attrs {
+		attr := attrs[i]
+		value := attr.Value.Resolve()
+		if value.Kind() == slog.KindGroup {
+			attrs[i].Value = slog.GroupValue(replaceAttrs(fn, append(groups, attr.Key), value.Group()...)...)
+		} else if fn != nil {
+			attrs[i] = fn(groups, attr)
+		}
+	}
+
+	return attrs
+}
+
+func source(sourceKey string, r *slog.Record) slog.Attr {
+	fs := runtime.CallersFrames([]uintptr{r.PC})
+	f, _ := fs.Next()
+	var args []any
+	if f.Function != "" {
+		args = append(args, slog.String("function", f.Function))
+	}
+	if f.File != "" {
+		args = append(args, slog.String("file", f.File))
+	}
+	if f.Line != 0 {
+		args = append(args, slog.Int("line", f.Line))
+	}
+
+	return slog.Group(sourceKey, args...)
+}
+
+func removeEmptyAttrs(attrs []slog.Attr) []slog.Attr {
+	return lo.FilterMap(attrs, func(attr slog.Attr, _ int) (slog.Attr, bool) {
+		if attr.Key == "" {
+			return attr, false
+		}
+
+		if attr.Value.Kind() == slog.KindGroup {
+			values := removeEmptyAttrs(attr.Value.Group())
+			if len(values) == 0 {
+				return attr, false
+			}
+
+			attr.Value = slog.GroupValue(values...)
+			return attr, true
+		}
+
+		return attr, !attr.Value.Equal(slog.Value{})
+	})
+}
+
+func attrsToMap(attrs ...slog.Attr) map[string]any {
+	output := map[string]any{}
+
+	attrsByKey := groupValuesByKey(attrs)
+	for k, values := range attrsByKey {
+		v := mergeAttrValues(values...)
+		if v.Kind() == slog.KindGroup {
+			output[k] = attrsToMap(v.Group()...)
+		} else {
+			output[k] = v.Any()
+		}
+	}
+
+	return output
+}
+
+func groupValuesByKey(attrs []slog.Attr) map[string][]slog.Value {
+	result := map[string][]slog.Value{}
+
+	for _, item := range attrs {
+		key := item.Key
+		result[key] = append(result[key], item.Value)
+	}
+
+	return result
+}
+
+func mergeAttrValues(values ...slog.Value) slog.Value {
+	v := values[0]
+
+	for i := 1; i < len(values); i++ {
+		if v.Kind() != slog.KindGroup || values[i].Kind() != slog.KindGroup {
+			v = values[i]
+			continue
+		}
+
+		v = slog.GroupValue(append(v.Group(), values[i].Group()...)...)
+	}
+
+	return v
+}
+
+func appendAttrsToGroup(groups []string, actualAttrs []slog.Attr, newAttrs ...slog.Attr) []slog.Attr {
+	actualAttrs = slices.Clone(actualAttrs)
+
+	if len(groups) == 0 {
+		return uniqAttrs(append(actualAttrs, newAttrs...))
+	}
+
+	for i := range actualAttrs {
+		attr := actualAttrs[i]
+		if attr.Key == groups[0] && attr.Value.Kind() == slog.KindGroup {
+			actualAttrs[i] = slog.Group(groups[0], lo.ToAnySlice(appendAttrsToGroup(groups[1:], attr.Value.Group(), newAttrs...))...)
+			return actualAttrs
+		}
+	}
+
+	return uniqAttrs(
+		append(
+			actualAttrs,
+			slog.Group(
+				groups[0],
+				lo.ToAnySlice(appendAttrsToGroup(groups[1:], []slog.Attr{}, newAttrs...))...,
+			),
+		),
+	)
+}
+
+func uniqAttrs(attrs []slog.Attr) []slog.Attr {
+	return uniqByLast(attrs, func(item slog.Attr) string {
+		return item.Key
+	})
+}
+
+func uniqByLast[T any, U comparable](collection []T, iteratee func(item T) U) []T {
+	result := make([]T, 0, len(collection))
+	seen := make(map[U]int, len(collection))
+	seenIndex := 0
+
+	for _, item := range collection {
+		key := iteratee(item)
+
+		if index, ok := seen[key]; ok {
+			result[index] = item
+			continue
+		}
+
+		seen[key] = seenIndex
+		seenIndex++
+		result = append(result, item)
+	}
+
+	return result
+}
+
+func contextExtractor(ctx context.Context, fns []func(ctx context.Context) []slog.Attr) []slog.Attr {
+	var attrs []slog.Attr
+	for _, fn := range fns {
+		attrs = append(attrs, fn(ctx)...)
+	}
+	return attrs
+}

slog/handler.go

@@ -0,0 +1,96 @@
+package slog
+
+import (
+	"context"
+	"github.com/snabble/go-logging/v2"
+
+	"log/slog"
+
+	"github.com/sirupsen/logrus"
+)
+
+var logLevelsFromSlog = map[slog.Level]logrus.Level{
+	slog.LevelDebug: logrus.DebugLevel,
+	slog.LevelInfo:  logrus.InfoLevel,
+	slog.LevelWarn:  logrus.WarnLevel,
+	slog.LevelError: logrus.ErrorLevel,
+}
+
+var logLevelsToSlog = map[logrus.Level]slog.Level{
+	logrus.DebugLevel: slog.LevelDebug,
+	logrus.InfoLevel:  slog.LevelInfo,
+	logrus.WarnLevel:  slog.LevelWarn,
+	logrus.ErrorLevel: slog.LevelError,
+}
+
+type Option struct {
+	Level           slog.Level
+	Logger          *logging.Logger
+	AttrFromContext []func(ctx context.Context) []slog.Attr
+	AddSource       bool
+	ReplaceAttr     func(groups []string, a slog.Attr) slog.Attr
+}
+
+func New() *slog.Logger {
+	return slog.New(
+		Option{
+			Level:  logLevelsToSlog[logging.Log.GetLevel()],
+			Logger: logging.Log,
+		}.newLogrusHandler())
+}
+
+func (o Option) newLogrusHandler() slog.Handler {
+	if o.AttrFromContext == nil {
+		o.AttrFromContext = []func(ctx context.Context) []slog.Attr{}
+	}
+
+	return &LogrusHandler{
+		option: o,
+		attrs:  []slog.Attr{},
+		groups: []string{},
+	}
+}
+
+type LogrusHandler struct {
+	option Option
+	attrs  []slog.Attr
+	groups []string
+}
+
+func (h *LogrusHandler) Enabled(_ context.Context, level slog.Level) bool {
+	return level >= h.option.Level.Level()
+}
+
+func (h *LogrusHandler) Handle(ctx context.Context, record slog.Record) error {
+	level := logLevelsFromSlog[record.Level]
+	fromContext := contextExtractor(ctx, h.option.AttrFromContext)
+	args := convert(h.option.AddSource, h.option.ReplaceAttr, append(h.attrs, fromContext...), h.groups, &record)
+
+	logging.NewEntry(h.option.Logger).
+		WithContext(ctx).
+		WithTime(record.Time).
+		WithFields(args).
+		Log(level, record.Message)
+
+	return nil
+}
+
+func (h *LogrusHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	return &LogrusHandler{
+		option: h.option,
+		attrs:  appendAttrsToGroup(h.groups, h.attrs, attrs...),
+		groups: h.groups,
+	}
+}
+
+func (h *LogrusHandler) WithGroup(name string) slog.Handler {
+	if name == "" {
+		return h
+	}
+
+	return &LogrusHandler{
+		option: h.option,
+		attrs:  h.attrs,
+		groups: append(h.groups, name),
+	}
+}

slog/handler_test.go

@@ -0,0 +1,51 @@
+package slog
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"github.com/sirupsen/logrus"
+	"github.com/snabble/go-logging/v2"
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func Test_Slog_Set(t *testing.T) {
+	a := assert.New(t)
+
+	// given: an error logger in text format
+	logging.Set("error", true)
+	defer logging.Set("info", false)
+	logging.Log.Formatter.(*logrus.TextFormatter).DisableColors = true
+	b := bytes.NewBuffer(nil)
+	logging.Log.Out = b
+
+	slog := New()
+
+	// when: I log something
+	slog.Info("should be ignored ..")
+	slog.With("foo", "bar").Error("oops")
+
+	// then: only the error text is contained, and it is text formatted
+	a.Regexp(`^time.* level\=error msg\=oops foo\=bar.*`, b.String())
+}
+
+func Test_Slog_WithError(t *testing.T) {
+	a := assert.New(t)
+
+	// given: an logger in text format
+	logging.Set("info", true)
+	defer logging.Set("info", false)
+	logging.Log.Formatter.(*logrus.TextFormatter).DisableColors = true
+	b := bytes.NewBuffer(nil)
+	logging.Log.Out = b
+
+	slog := New()
+
+	err := func() error {
+		return fmt.Errorf("found an error: %w", errors.New("an error occurred"))
+	}()
+	slog.Error("oops", "error", err)
+
+	a.Regexp(`^time.* level\=error msg\=oops error\="found an error: an error occurred"`, b.String())
+}