Logging: detect log level through layers of wrappers

pkg/util/log/log.go

@@ -63,11 +63,16 @@ const (
 	errorLevel
 )
 
-type leveledLogger interface {
-	level() logLevel
+type privateLevelDetector struct {
+	string
+	logLevel
 }
 
-var _ leveledLogger = levelFilter{}
+func (x *privateLevelDetector) String() string {
+	return x.string
+}
+
+var _ log.Logger = levelFilter{}
 
 // Pass through Logger and implement the DebugEnabled interface that spanlogger looks for.
 type levelFilter struct {
@@ -93,8 +98,15 @@ func newFilter(logger log.Logger, lvl dslog.Level) log.Logger {
 	}
 }
 
-func (f levelFilter) level() logLevel {
-	return f.lvl
+// If we are called with a special magic struct, use it to pass back the logging level.
+func (f levelFilter) Log(keyvals ...interface{}) error {
+	if len(keyvals) > 0 {
+		if x, ok := keyvals[len(keyvals)-1].(*privateLevelDetector); ok {
+			x.logLevel = f.lvl
+			return nil
+		}
+	}
+	return f.Logger.Log(keyvals...)
 }
 
 func (f *levelFilter) DebugEnabled() bool {

pkg/util/log/slogadapter.go

@@ -12,20 +12,20 @@ import (
 // SlogFromGoKit returns slog adapter for logger.
 func SlogFromGoKit(logger log.Logger) *slog.Logger {
 	var sl slog.Level
-	x, ok := logger.(leveledLogger)
-	if !ok {
+	x := privateLevelDetector{
+		string:   "This struct is expected to be used with levelLogger only",
+		logLevel: debugLevel,
+	}
+	logger.Log("test", &x)
+	switch x.logLevel {
+	case infoLevel:
+		sl = slog.LevelInfo
+	case warnLevel:
+		sl = slog.LevelWarn
+	case errorLevel:
+		sl = slog.LevelError
+	default:
 		sl = slog.LevelDebug
-	} else {
-		switch x.level() {
-		case infoLevel:
-			sl = slog.LevelInfo
-		case warnLevel:
-			sl = slog.LevelWarn
-		case errorLevel:
-			sl = slog.LevelError
-		default:
-			sl = slog.LevelDebug
-		}
 	}
 
 	lvl := slog.LevelVar{}

pkg/util/log/slogadapter_test.go

@@ -8,6 +8,7 @@ import (
 	"log/slog"
 	"testing"
 
+	"github.com/go-kit/log"
 	"github.com/go-kit/log/level"
 	dslog "github.com/grafana/dskit/log"
 	"github.com/stretchr/testify/assert"
@@ -61,6 +62,7 @@ func TestSlogFromGoKit(t *testing.T) {
 
 	t.Run("enabled for the right slog levels when go-kit level not configured", func(t *testing.T) {
 		mLogger := &mockLogger{}
+		mLogger.On("Log", "test", mock.AnythingOfType("*log.privateLevelDetector")).Return(nil) // Probing call from SlogFromGoKit.
 		slogger := SlogFromGoKit(mLogger)
 
 		for _, sl := range slogLevels {
@@ -70,6 +72,7 @@ func TestSlogFromGoKit(t *testing.T) {
 
 	t.Run("wraps go-kit logger", func(*testing.T) {
 		mLogger := &mockLogger{}
+		mLogger.On("Log", "test", mock.AnythingOfType("*log.privateLevelDetector")).Return(nil) // Probing call from SlogFromGoKit.
 		slogger := SlogFromGoKit(mLogger)
 
 		for _, l := range levels {
@@ -90,3 +93,29 @@ func TestSlogFromGoKit(t *testing.T) {
 		}
 	})
 }
+
+func BenchmarkSlogFromGoKit(b *testing.B) {
+	// Set up a logger with a stack of wrappers, similar to what tsdb gets.
+	var lvl dslog.Level
+	_ = lvl.Set("info")
+	var logger log.Logger
+	logger = noopLogger{}
+	logger = newFilter(logger, lvl)
+	logger = WithUserID("userID", logger)
+
+	sl := SlogFromGoKit(logger)
+	b.Run("log", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			sl.Info("msg", "foo", "bar", "more", "data")
+		}
+	})
+	b.Run("debuglog", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			sl.Debug("msg", "foo", "bar", "more", "data")
+		}
+	})
+}
+
+type noopLogger struct{}
+
+func (noopLogger) Log(...interface{}) error { return nil }