perf(log/slog): reduce allocs on Any value handling

It reduce allocs of Any values handling by reusing the JSON Encoder and
using `fmt.Fprint` instead of `fmt.Sprint` for value formatting.

Solves: #74645

Author: masterkeysrd

src/log/slog/encoder.go

@@ -0,0 +1,8 @@
+package slog
+
+type encoder interface {
+	Reset()
+	Free()
+	Encode(v any) error
+	Bytes() []byte
+}

src/log/slog/handler.go

@@ -380,12 +380,13 @@ func (h *commonHandler) attrSep() string {
 // The initial value of sep determines whether to emit a separator
 // before the next key, after which it stays true.
 type handleState struct {
-	h       *commonHandler
-	buf     *buffer.Buffer
-	freeBuf bool           // should buf be freed?
-	sep     string         // separator to write before next key
-	prefix  *buffer.Buffer // for text: key prefix
-	groups  *[]string      // pool-allocated slice of active groups, for ReplaceAttr
+	h          *commonHandler
+	buf        *buffer.Buffer
+	freeBuf    bool           // should buf be freed?
+	sep        string         // separator to write before next key
+	prefix     *buffer.Buffer // for text: key prefix
+	groups     *[]string      // pool-allocated slice of active groups, for ReplaceAttr
+	anyEncoder encoder
 }
 
 var groupPool = sync.Pool{New: func() any {
@@ -416,6 +417,10 @@ func (s *handleState) free() {
 		*gs = (*gs)[:0]
 		groupPool.Put(gs)
 	}
+	if s.anyEncoder != nil {
+		s.anyEncoder.Free()
+		s.anyEncoder = nil
+	}
 	s.prefix.Free()
 }
 
@@ -558,7 +563,7 @@ func (s *handleState) appendTwoStrings(x, y string) {
 		buf = appendEscapedJSONString(buf, x)
 		buf = appendEscapedJSONString(buf, y)
 		buf.WriteByte('"')
-	case !needsQuoting(x) && !needsQuoting(y):
+	case !needsQuoting([]byte(x)) && !needsQuoting([]byte(y)):
 		buf.WriteString(x)
 		buf.WriteString(y)
 	default:
@@ -574,7 +579,7 @@ func (s *handleState) appendString(str string) {
 		s.buf.WriteByte('"')
 	} else {
 		// text
-		if needsQuoting(str) {
+		if needsQuoting([]byte(str)) {
 			*s.buf = strconv.AppendQuote(*s.buf, str)
 		} else {
 			s.buf.WriteString(str)

src/log/slog/internal/benchmarks/benchmarks.go

@@ -37,6 +37,11 @@ var (
 	testInt      = 32768
 	testDuration = 23 * time.Second
 	testError    = errors.New("fail")
+	testEvent    = &event{
+		ID:          "testing_event_#01",
+		Description: "Some text for this description to simulate a real scenario.",
+		CreatedAt:   time.Date(2025, time.July, 5, 0, 0, 0, 0, time.UTC),
+	}
 )
 
 var testAttrs = []slog.Attr{
@@ -48,3 +53,9 @@ var testAttrs = []slog.Attr{
 }
 
 const wantText = "time=1651363200 level=0 msg=Test logging, but use a somewhat realistic message length. string=7e3b3b2aaeff56a7108fe11e154200dd/7819479873059528190 status=32768 duration=23000000000 time=1651363200 error=fail\n"
+
+type event struct {
+	ID          string    `json:"id"`
+	Description string    `json:"description"`
+	CreatedAt   time.Time `json:"created_at"`
+}

src/log/slog/internal/benchmarks/benchmarks_test.go

@@ -85,7 +85,7 @@ func BenchmarkAttrs(b *testing.B) {
 							slog.Int("status", testInt),
 							slog.Duration("duration", testDuration),
 							slog.Time("time", testTime),
-							slog.Any("error", testError),
+							slog.Any("event", testEvent),
 						)
 					},
 				},
@@ -133,7 +133,7 @@ func BenchmarkAttrs(b *testing.B) {
 							slog.Int("status", testInt),
 							slog.Duration("duration", testDuration),
 							slog.Time("time", testTime),
-							slog.Any("error", testError),
+							slog.Any("event", testEvent),
 						)
 					},
 				},

src/log/slog/json_handler.go

@@ -11,7 +11,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log/slog/internal/buffer"
 	"strconv"
 	"sync"
 	"time"
@@ -113,7 +112,7 @@ func appendJSONValue(s *handleState, v Value) error {
 		// json.Marshal is funny about floats; it doesn't
 		// always match strconv.AppendFloat. So just call it.
 		// That's expensive, but floats are rare.
-		if err := appendJSONMarshal(s.buf, v.Float64()); err != nil {
+		if err := appendJSONMarshal(s, v.Float64()); err != nil {
 			return err
 		}
 	case KindBool:
@@ -129,27 +128,71 @@ func appendJSONValue(s *handleState, v Value) error {
 		if err, ok := a.(error); ok && !jm {
 			s.appendString(err.Error())
 		} else {
-			return appendJSONMarshal(s.buf, a)
+			return appendJSONMarshal(s, a)
 		}
 	default:
 		panic(fmt.Sprintf("bad kind: %s", v.Kind()))
 	}
 	return nil
 }
 
-func appendJSONMarshal(buf *buffer.Buffer, v any) error {
-	// Use a json.Encoder to avoid escaping HTML.
-	var bb bytes.Buffer
-	enc := json.NewEncoder(&bb)
-	enc.SetEscapeHTML(false)
+func appendJSONMarshal(s *handleState, v any) error {
+	// Aquire a new encoder if not asigned.
+	if s.anyEncoder == nil {
+		s.anyEncoder = newJSONMarshalEncoder()
+	}
+
+	enc := s.anyEncoder
+	enc.Reset() // reset the encoder, if was reused
 	if err := enc.Encode(v); err != nil {
 		return err
 	}
-	bs := bb.Bytes()
-	buf.Write(bs[:len(bs)-1]) // remove final newline
+
+	bs := enc.Bytes()
+	s.buf.Write(bs[:len(bs)-1]) // remove final newline
 	return nil
 }
 
+type jsonMarhsalEncoder struct {
+	buf *bytes.Buffer
+	enc *json.Encoder
+}
+
+func newJSONMarshalEncoder() encoder {
+	if enc := jsonEncoderPool.Get(); enc != nil {
+		return enc.(*jsonMarhsalEncoder)
+	}
+
+	buf := &bytes.Buffer{}
+
+	// Use a json.Encoder to avoid escaping HTML.
+	jsonEnc := json.NewEncoder(buf)
+	jsonEnc.SetEscapeHTML(false)
+
+	return &jsonMarhsalEncoder{buf: buf, enc: jsonEnc}
+}
+
+func (e *jsonMarhsalEncoder) Reset() {
+	e.buf.Reset()
+}
+
+func (e *jsonMarhsalEncoder) Encode(v any) error {
+	return e.enc.Encode(v)
+}
+
+func (e *jsonMarhsalEncoder) Bytes() []byte {
+	return e.buf.Bytes()
+}
+
+func (e *jsonMarhsalEncoder) Free() {
+	const maxBufferSize = 8 << 10
+	if e.buf.Cap() <= maxBufferSize {
+		jsonEncoderPool.Put(e)
+	}
+}
+
+var jsonEncoderPool = sync.Pool{}
+
 // appendEscapedJSONString escapes s for JSON and appends it to buf.
 // It does not surround the string in quotation marks.
 //

src/log/slog/text_handler.go

@@ -5,6 +5,7 @@
 package slog
 
 import (
+	"bytes"
 	"context"
 	"encoding"
 	"fmt"
@@ -114,7 +115,21 @@ func appendTextValue(s *handleState, v Value) error {
 			s.buf.WriteString(strconv.Quote(string(bs)))
 			return nil
 		}
-		s.appendString(fmt.Sprintf("%+v", v.Any()))
+		if s.anyEncoder == nil {
+			s.anyEncoder = newTextMarshalEncoder()
+		}
+
+		enc := s.anyEncoder
+		enc.Reset()
+		enc.Encode(v.Any())
+		bs := enc.Bytes()
+		if needsQuoting(bs) {
+			s.buf.WriteByte('"')
+			s.buf.Write(bs)
+			s.buf.WriteByte('"')
+			return nil
+		}
+		s.buf.Write(bs)
 	default:
 		*s.buf = v.append(*s.buf)
 	}
@@ -136,7 +151,43 @@ func byteSlice(a any) ([]byte, bool) {
 	return nil, false
 }
 
-func needsQuoting(s string) bool {
+type textMarshalEncoder struct {
+	buf *bytes.Buffer
+}
+
+func newTextMarshalEncoder() encoder {
+	if enc := textEncoderPool.Get(); enc != nil {
+		return enc.(*textMarshalEncoder)
+	}
+
+	buf := &bytes.Buffer{}
+
+	return &textMarshalEncoder{buf: buf}
+}
+
+func (e *textMarshalEncoder) Reset() {
+	e.buf.Reset()
+}
+
+func (e *textMarshalEncoder) Encode(v any) error {
+	fmt.Fprintf(e.buf, "%+v", v)
+	return nil
+}
+
+func (e *textMarshalEncoder) Bytes() []byte {
+	return e.buf.Bytes()
+}
+
+func (e *textMarshalEncoder) Free() {
+	const maxBufferSize = 4 << 10
+	if e.buf.Cap() <= maxBufferSize {
+		textEncoderPool.Put(e)
+	}
+}
+
+var textEncoderPool = sync.Pool{}
+
+func needsQuoting(s []byte) bool {
 	if len(s) == 0 {
 		return true
 	}
@@ -151,7 +202,7 @@ func needsQuoting(s string) bool {
 			i++
 			continue
 		}
-		r, size := utf8.DecodeRuneInString(s[i:])
+		r, size := utf8.DecodeRune(s[i:])
 		if r == utf8.RuneError || unicode.IsSpace(r) || !unicode.IsPrint(r) {
 			return true
 		}

src/log/slog/text_handler_test.go

@@ -168,7 +168,7 @@ func TestNeedsQuoting(t *testing.T) {
 		{"a b", true},
 		{"badutf8\xF6", true},
 	} {
-		got := needsQuoting(test.in)
+		got := needsQuoting([]byte(test.in))
 		if got != test.want {
 			t.Errorf("%q: got %t, want %t", test.in, got, test.want)
 		}