Add Msg.SlogRecord and use slog formatting to marshal it

json-handler.go

@@ -14,11 +14,11 @@ type JsonHandler struct {
 	SlogHandler slog.Handler
 }
 
-func NewJsonHandler(w io.Writer) *JsonHandler {
+func NewJsonHandler(w io.Writer, minLevel Level) *JsonHandler {
 	return &JsonHandler{
 		SlogHandler: slog.NewJSONHandler(w, &slog.HandlerOptions{
 			AddSource:   false,
-			Level:       slog.LevelDebug - 4,
+			Level:       toSlogMinLevel(minLevel),
 			ReplaceAttr: nil,
 		}),
 	}

msg.go

@@ -68,6 +68,7 @@ type msgWithValues struct {
 	values []interface{}
 }
 
+// TODO: Support Msg.SlogRecord
 func (me msgWithValues) Values(cb valueIterCallback) {
 	for _, v := range me.values {
 		if !cb(v) {
@@ -157,6 +158,7 @@ type msgWithText struct {
 	text func() string
 }
 
+// TODO: Support Msg.SlogRecord
 func (me msgWithText) Text() string {
 	return me.text()
 }

msgimpl.go

@@ -1,6 +1,8 @@
 package log
 
 import (
+	g "github.com/anacrolix/generics"
+	"log/slog"
 	"runtime"
 )
 
@@ -15,6 +17,8 @@ type MsgImpl interface {
 	Callers(skip int, pc []uintptr) int
 	// Iterates over the values as added LIFO.
 	Values(callback valueIterCallback)
+	// Returns Some(slog.Record) if the Msg supports it.
+	SlogRecord() g.Option[slog.Record]
 }
 
 // maybe implement finalizer to ensure msgs are sunk
@@ -31,3 +35,7 @@ func (m rootMsgImpl) Callers(skip int, pc []uintptr) int {
 }
 
 func (m rootMsgImpl) Values(valueIterCallback) {}
+
+func (m rootMsgImpl) SlogRecord() g.Option[slog.Record] {
+	return g.Some(slog.Record{Message: m.text()})
+}

slog-handler.go

@@ -2,6 +2,7 @@ package log
 
 import (
 	"context"
+	g "github.com/anacrolix/generics"
 	"log/slog"
 )
 
@@ -33,6 +34,10 @@ type slogMsg struct {
 	record slog.Record
 }
 
+func (s slogMsg) SlogRecord() g.Option[slog.Record] {
+	return g.Some(s.record)
+}
+
 func (s slogMsg) Text() string {
 	return s.record.Message
 }

slog-record-formatter.go

@@ -0,0 +1,48 @@
+package log
+
+import (
+	"bytes"
+	"context"
+	"log/slog"
+	"sync"
+)
+
+var (
+	gstbhLocker                 sync.Mutex
+	globalSlogTextBufferHandler = slogTextBufferHandler{}
+)
+
+func init() {
+	globalSlogTextBufferHandler.init()
+}
+
+func (me *slogTextBufferHandler) handleAppend(b []byte, r slog.Record) []byte {
+	me.buf.Reset()
+	err := me.handler.Handle(context.Background(), r)
+	if err != nil {
+		panic(err)
+	}
+	return append(b, me.buf.Bytes()...)
+}
+
+type slogTextBufferHandler struct {
+	buf     bytes.Buffer
+	handler *slog.TextHandler
+}
+
+func (me *slogTextBufferHandler) init() {
+	me.handler = slog.NewTextHandler(&me.buf, &slog.HandlerOptions{
+		AddSource: false,
+		Level:     toSlogMinLevel(NotSet),
+		ReplaceAttr: func(groups []string, a slog.Attr) (ret slog.Attr) {
+			if len(groups) == 0 {
+				switch a.Key {
+				case slog.TimeKey, slog.LevelKey:
+					return
+				}
+			}
+			ret = a
+			return
+		},
+	})
+}

slog.go

@@ -2,8 +2,10 @@ package log
 
 import (
 	"log/slog"
+	"math"
 )
 
+// Returns false if the level doesn't convert perfectly.
 func toSlogLevel(level Level) (slog.Level, bool) {
 	switch level {
 	case Never:
@@ -27,6 +29,27 @@ func toSlogLevel(level Level) (slog.Level, bool) {
 	}
 }
 
+func toSlogMinLevel(level Level) slog.Level {
+	switch level {
+	case NotSet:
+		return math.MinInt
+	case Debug:
+		return slog.LevelDebug
+	case Info:
+		return slog.LevelInfo
+	case Warning:
+		return slog.LevelWarn
+	case Error:
+		return slog.LevelError
+	case Critical:
+		return slog.LevelError + 1
+	case Disabled:
+		return math.MaxInt
+	default:
+		panic(level)
+	}
+}
+
 func fromSlogLevel(sl slog.Level) Level {
 	switch sl {
 	case slog.LevelDebug:

stream-handler.go

@@ -34,6 +34,14 @@ func twoLineFormatter(msg Record) []byte {
 		b = append(b, name...)
 	}
 	b = append(b, "]\n  "...)
+
+	slogRecord := msg.SlogRecord()
+	if slogRecord.Ok {
+		gstbhLocker.Lock()
+		defer gstbhLocker.Unlock()
+		return globalSlogTextBufferHandler.handleAppend(b, slogRecord.Value)
+	}
+
 	b = append(b, msg.Text()...)
 	msg.Values(func(value interface{}) (more bool) {
 		b = append(b, ' ')