reduce CPU use in zapadapter (#3773)

* Improve zadapter benchmark.

* Fix slow zadapter.

* comments and changelog

Author: thampiotr

CHANGELOG.md

@@ -22,6 +22,8 @@ Main (unreleased)
 
 - Fix `loki.source.firehose` to propagate specific cloudwatch event timestamps when useIncomingTs is set to true. (@michaelPotter)
 
+- Fix elevated CPU usage when using some `otelcol` components due to debug logging. (@thampiotr)
+
 v1.9.0
 -----------------
 

internal/util/zapadapter/zapadapter.go

@@ -40,7 +40,7 @@ func (lc *loggerCore) Enabled(zapcore.Level) bool {
 // With implements zapcore.Core, returning a new logger core with ff appended
 // to the list of fields.
 func (lc *loggerCore) With(ff []zapcore.Field) zapcore.Core {
-	// Encode all of the fields so that they're go-kit compatible and create a
+	// Encode all the fields so that they're go-kit compatible and create a
 	// new logger from it.
 	enc := newFieldEncoder()
 	defer func() { _ = enc.Close() }()
@@ -132,30 +132,34 @@ func (fe *fieldEncoder) Close() error {
 }
 
 func (fe *fieldEncoder) AddArray(key string, marshaler zapcore.ArrayMarshaler) error {
-	enc := newArrayFieldEncoder()
-	err := marshaler.MarshalLogArray(enc)
-	if err != nil {
-		return err
-	}
-	b, err := enc.jsonMarshal()
-	if err != nil {
-		return err
-	}
-	fe.fields = append(fe.fields, fe.keyName(key), string(b))
+	fe.fields = append(fe.fields, fe.keyName(key), lazyStringer{f: func() string {
+		enc := newArrayFieldEncoder()
+		err := marshaler.MarshalLogArray(enc)
+		if err != nil {
+			return err.Error()
+		}
+		b, err := enc.jsonMarshal()
+		if err != nil {
+			return err.Error()
+		}
+		return string(b)
+	}})
 	return nil
 }
 
 func (fe *fieldEncoder) AddObject(key string, marshaler zapcore.ObjectMarshaler) error {
-	enc := newObjectFieldEncoder()
-	err := marshaler.MarshalLogObject(enc)
-	if err != nil {
-		return err
-	}
-	b, err := enc.jsonMarshal()
-	if err != nil {
-		return err
-	}
-	fe.fields = append(fe.fields, fe.keyName(key), string(b))
+	fe.fields = append(fe.fields, fe.keyName(key), lazyStringer{f: func() string {
+		enc := newObjectFieldEncoder()
+		err := marshaler.MarshalLogObject(enc)
+		if err != nil {
+			return err.Error()
+		}
+		b, err := enc.jsonMarshal()
+		if err != nil {
+			return err.Error()
+		}
+		return string(b)
+	}})
 	return nil
 }
 
@@ -488,3 +492,11 @@ func (fe *arrayFieldEncoder) AppendReflected(value interface{}) error {
 	fe.arr = append(fe.arr, value)
 	return nil
 }
+
+type lazyStringer struct {
+	f func() string
+}
+
+func (l lazyStringer) String() string {
+	return l.f()
+}

internal/util/zapadapter/zapadapter_test.go

@@ -9,11 +9,12 @@ import (
 	"time"
 
 	"github.com/go-kit/log"
-	"github.com/go-kit/log/level"
-	"github.com/grafana/alloy/internal/util/zapadapter"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
+
+	"github.com/grafana/alloy/internal/runtime/logging"
+	"github.com/grafana/alloy/internal/util/zapadapter"
 )
 
 func Test(t *testing.T) {
@@ -121,6 +122,39 @@ func Test(t *testing.T) {
 	}
 }
 
+/*
+	As of 2025-06-04:
+
+goos: darwin
+goarch: arm64
+pkg: github.com/grafana/alloy/internal/util/zapadapter
+cpu: Apple M2
+Benchmark
+Benchmark/No_fields_enabled-8         	 1352374	       864.7 ns/op
+Benchmark/No_fields_disabled-8        	 6223372	       193.1 ns/op
+Benchmark/Any_enabled-8               	 1000000	      1332 ns/op
+Benchmark/Any_disabled-8              	 4654744	       240.5 ns/op
+Benchmark/Bool_enabled-8              	 1000000	      1015 ns/op
+Benchmark/Bool_disabled-8             	 5353936	       253.2 ns/op
+Benchmark/Duration_enabled-8          	 1000000	      1062 ns/op
+Benchmark/Duration_disabled-8         	 5175646	       238.0 ns/op
+Benchmark/Error_enabled-8             	 1000000	      1105 ns/op
+Benchmark/Error_disabled-8            	 4905226	       267.0 ns/op
+Benchmark/Float32_enabled-8           	 1000000	      1203 ns/op
+Benchmark/Float32_disabled-8          	 4813323	       233.6 ns/op
+Benchmark/Float64_enabled-8           	 1000000	      1037 ns/op
+Benchmark/Float64_disabled-8          	 5130016	       232.8 ns/op
+Benchmark/Int_enabled-8               	 1000000	      1065 ns/op
+Benchmark/Int_disabled-8              	 5154585	       241.0 ns/op
+Benchmark/String_enabled-8            	 1000000	      1025 ns/op
+Benchmark/String_disabled-8           	 5105998	       233.3 ns/op
+Benchmark/Time_enabled-8              	 1000000	      1143 ns/op
+Benchmark/Time_disabled-8             	 4857289	       248.3 ns/op
+Benchmark/Array_enabled-8             	  327018	      3529 ns/op
+Benchmark/Array_disabled-8            	 4889307	       252.8 ns/op
+Benchmark/Object_enabled-8            	  285597	      4187 ns/op
+Benchmark/Object_disabled-8           	 4864752	       245.3 ns/op
+*/
 func Benchmark(b *testing.B) {
 	// Benchmark various fields that may be commonly printed.
 
@@ -134,30 +168,45 @@ func Benchmark(b *testing.B) {
 	runBenchmark(b, "Int", zap.Int("key", 1234))
 	runBenchmark(b, "String", zap.String("key", "test"))
 	runBenchmark(b, "Time", zap.Time("key", time.Date(2022, 12, 1, 1, 1, 1, 1, time.UTC)))
-	runBenchmark(b, "Array", zap.Strings("key", []string{"foo", "bar"}))
+	runBenchmark(b, "Array", zap.Strings("key", []string{"foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar"}))
 	runBenchmark(b, "Object", zap.Object("key", testObject{
 		obj: map[string]any{
-			"foo": "bar",
-			"bar": 123,
-			"baz": true,
+			"foo":  "car",
+			"bar":  123,
+			"baz":  true,
+			"foo2": "bar2",
+			"bar2": 123,
+			"baz2": true,
 			"qux": map[string]any{
-				"foo": "car",
+				"foo":  "car",
+				"bar":  123,
+				"baz":  true,
+				"foo2": "bar2",
+				"bar2": 123,
+				"baz2": true,
 			},
 		},
 	}))
 }
 
 func runBenchmark(b *testing.B, name string, fields ...zap.Field) {
-	innerLogger := log.NewLogfmtLogger(io.Discard)
-	innerLogger = level.NewFilter(innerLogger, level.AllowAll())
+	innerLogger, err := logging.NewDeferred(io.Discard)
+	require.NoError(b, err)
+	err = innerLogger.Update(logging.Options{Level: logging.LevelInfo, Format: logging.FormatLogfmt})
+	require.NoError(b, err)
 
 	zapLogger := zapadapter.New(innerLogger)
 
-	b.Run(name, func(b *testing.B) {
+	b.Run(name+" enabled", func(b *testing.B) {
 		for i := 0; i < b.N; i++ {
 			zapLogger.Info("Hello, world!", fields...)
 		}
 	})
+	b.Run(name+" disabled", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			zapLogger.Debug("Hello, world!", fields...)
+		}
+	})
 }
 
 type testObject struct {