reorg and refactor of types

Author: ndyakov

commands.go

@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/redis/go-redis/v9/internal"
+	"github.com/redis/go-redis/v9/logging"
 )
 
 // KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
@@ -28,23 +29,15 @@ func usePrecise(dur time.Duration) bool {
 
 func formatMs(ctx context.Context, dur time.Duration) int64 {
 	if dur > 0 && dur < time.Millisecond {
-		internal.Logger.Printf(
-			ctx,
-			"specified duration is %s, but minimal supported value is %s - truncating to 1ms",
-			dur, time.Millisecond,
-		)
+		logging.LoggerWithLevel().Infof(ctx, "specified duration is %s, but minimal supported value is %s - truncating to 1ms", dur, time.Millisecond)
 		return 1
 	}
 	return int64(dur / time.Millisecond)
 }
 
 func formatSec(ctx context.Context, dur time.Duration) int64 {
 	if dur > 0 && dur < time.Second {
-		internal.Logger.Printf(
-			ctx,
-			"specified duration is %s, but minimal supported value is %s - truncating to 1s",
-			dur, time.Second,
-		)
+		logging.LoggerWithLevel().Infof(ctx, "specified duration is %s, but minimal supported value is %s - truncating to 1s", dur, time.Second)
 		return 1
 	}
 	return int64(dur / time.Second)

export_test.go

@@ -6,9 +6,9 @@ import (
 	"net"
 	"strings"
 
-	"github.com/redis/go-redis/v9/internal"
 	"github.com/redis/go-redis/v9/internal/hashtag"
 	"github.com/redis/go-redis/v9/internal/pool"
+	"github.com/redis/go-redis/v9/logging"
 )
 
 func (c *baseClient) Pool() pool.Pooler {
@@ -87,7 +87,7 @@ func (c *clusterState) IsConsistent(ctx context.Context) bool {
 func GetSlavesAddrByName(ctx context.Context, c *SentinelClient, name string) []string {
 	addrs, err := c.Replicas(ctx, name).Result()
 	if err != nil {
-		internal.Logger.Printf(ctx, "sentinel: Replicas name=%q failed: %s",
+		logging.LoggerWithLevel.Errorf(ctx, "sentinel: Replicas name=%q failed: %s",
 			name, err)
 		return []string{}
 	}

internal/auth/streaming/pool_hook.go

@@ -166,7 +166,7 @@ func (r *ReAuthPoolHook) OnPut(_ context.Context, conn *pool.Conn) (bool, bool,
 			defer func() {
 				if rec := recover(); rec != nil {
 					// once again - safety first
-					internal.Logger.Printf(context.Background(), "panic in reauth worker: %v", rec)
+					LoggerWrapper.Printf(context.Background(), "panic in reauth worker: %v", rec)
 				}
 				r.scheduledLock.Lock()
 				delete(r.scheduledReAuth, connID)

internal/log.go

@@ -38,6 +38,7 @@ var LogLevel LogLevelT = LogLevelError
 type LogLevelT int
 
 // Log level constants for the entire go-redis library
+// TODO(ndyakov): In v10 align those levels with slog.Level
 const (
 	LogLevelError LogLevelT = iota // 0 - errors only
 	LogLevelWarn                   // 1 - warnings and errors

internal/pool/conn.go

@@ -11,9 +11,9 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/redis/go-redis/v9/internal"
 	"github.com/redis/go-redis/v9/internal/maintnotifications/logs"
 	"github.com/redis/go-redis/v9/internal/proto"
+	"github.com/redis/go-redis/v9/logging"
 )
 
 var noDeadline = time.Time{}
@@ -508,7 +508,7 @@ func (cn *Conn) getEffectiveReadTimeout(normalTimeout time.Duration) time.Durati
 		// Deadline has passed, clear relaxed timeouts atomically and use normal timeout
 		newCount := cn.relaxedCounter.Add(-1)
 		if newCount <= 0 {
-			internal.Logger.Printf(context.Background(), logs.UnrelaxedTimeoutAfterDeadline(cn.GetID()))
+			logging.LoggerWithLevel().Infof(context.Background(), logs.UnrelaxedTimeoutAfterDeadline(cn.GetID()))
 			cn.clearRelaxedTimeout()
 		}
 		return normalTimeout
@@ -542,7 +542,7 @@ func (cn *Conn) getEffectiveWriteTimeout(normalTimeout time.Duration) time.Durat
 		// Deadline has passed, clear relaxed timeouts atomically and use normal timeout
 		newCount := cn.relaxedCounter.Add(-1)
 		if newCount <= 0 {
-			internal.Logger.Printf(context.Background(), logs.UnrelaxedTimeoutAfterDeadline(cn.GetID()))
+			logging.LoggerWithLevel().Infof(context.Background(), logs.UnrelaxedTimeoutAfterDeadline(cn.GetID()))
 			cn.clearRelaxedTimeout()
 		}
 		return normalTimeout

internal/pool/pool.go

@@ -122,7 +122,7 @@ type Options struct {
 	DialerRetryTimeout time.Duration
 
 	// Optional logger for connection pool operations.
-	Logger *logging.CustomLogger
+	Logger logging.Lgr
 }
 
 type lastDialErrorWrap struct {
@@ -1050,10 +1050,9 @@ func (p *ConnPool) isHealthyConn(cn *Conn, nowNs int64) bool {
 	return true
 }
 
-func (p *ConnPool) logger() *logging.CustomLogger {
-	var logger *logging.CustomLogger
+func (p *ConnPool) logger() logging.Lgr {
 	if p.cfg != nil && p.cfg.Logger != nil {
-		logger = p.cfg.Logger
+		return p.cfg.Logger
 	}
-	return logger
+	return logging.LoggerWithLevel()
 }

logging/custom.go

@@ -5,17 +5,15 @@ import (
 	"fmt"
 )
 
-// CustomLogger is a logger interface with leveled logging methods.
-//
-// This interface can be implemented by custom loggers to provide leveled logging.
-type CustomLogger struct {
-	logger        LoggerWithLevel
+// LoggerWrapper is a slog.Logger wrapper that implements the Lgr interface.
+type LoggerWrapper struct {
+	logger        LoggerWithLevelI
 	loggerLevel   *LogLevelT
 	printfAdapter PrintfAdapter
 }
 
-func NewCustomLogger(logger LoggerWithLevel, opts ...CustomLoggerOption) *CustomLogger {
-	cl := &CustomLogger{
+func NewLoggerWrapper(logger LoggerWithLevelI, opts ...LoggerWrapperOption) *LoggerWrapper {
+	cl := &LoggerWrapper{
 		logger: logger,
 	}
 	for _, opt := range opts {
@@ -24,16 +22,16 @@ func NewCustomLogger(logger LoggerWithLevel, opts ...CustomLoggerOption) *Custom
 	return cl
 }
 
-type CustomLoggerOption func(*CustomLogger)
+type LoggerWrapperOption func(*LoggerWrapper)
 
-func WithPrintfAdapter(adapter PrintfAdapter) CustomLoggerOption {
-	return func(cl *CustomLogger) {
+func WithPrintfAdapter(adapter PrintfAdapter) LoggerWrapperOption {
+	return func(cl *LoggerWrapper) {
 		cl.printfAdapter = adapter
 	}
 }
 
-func WithLoggerLevel(level LogLevelT) CustomLoggerOption {
-	return func(cl *CustomLogger) {
+func WithLoggerLevel(level LogLevelT) LoggerWrapperOption {
+	return func(cl *LoggerWrapper) {
 		cl.loggerLevel = &level
 	}
 }
@@ -43,15 +41,15 @@ func WithLoggerLevel(level LogLevelT) CustomLoggerOption {
 type PrintfAdapter func(ctx context.Context, format string, v ...any) (context.Context, string, []any)
 
 // Error is a structured error level logging method with context and arguments.
-func (cl *CustomLogger) Error(ctx context.Context, msg string, args ...any) {
+func (cl *LoggerWrapper) Error(ctx context.Context, msg string, args ...any) {
 	if cl == nil || cl.logger == nil {
 		legacyLoggerWithLevel.Errorf(ctx, msg, args...)
 		return
 	}
 	cl.logger.ErrorContext(ctx, msg, args...)
 }
 
-func (cl *CustomLogger) Errorf(ctx context.Context, format string, v ...any) {
+func (cl *LoggerWrapper) Errorf(ctx context.Context, format string, v ...any) {
 	if cl == nil || cl.logger == nil {
 		legacyLoggerWithLevel.Errorf(ctx, format, v...)
 		return
@@ -60,15 +58,15 @@ func (cl *CustomLogger) Errorf(ctx context.Context, format string, v ...any) {
 }
 
 // Warn is a structured warning level logging method with context and arguments.
-func (cl *CustomLogger) Warn(ctx context.Context, msg string, args ...any) {
+func (cl *LoggerWrapper) Warn(ctx context.Context, msg string, args ...any) {
 	if cl == nil || cl.logger == nil {
 		legacyLoggerWithLevel.Warnf(ctx, msg, args...)
 		return
 	}
 	cl.logger.WarnContext(ctx, msg, args...)
 }
 
-func (cl *CustomLogger) Warnf(ctx context.Context, format string, v ...any) {
+func (cl *LoggerWrapper) Warnf(ctx context.Context, format string, v ...any) {
 	if cl == nil || cl.logger == nil {
 		legacyLoggerWithLevel.Warnf(ctx, format, v...)
 		return
@@ -77,7 +75,7 @@ func (cl *CustomLogger) Warnf(ctx context.Context, format string, v ...any) {
 }
 
 // Info is a structured info level logging method with context and arguments.
-func (cl *CustomLogger) Info(ctx context.Context, msg string, args ...any) {
+func (cl *LoggerWrapper) Info(ctx context.Context, msg string, args ...any) {
 	if cl == nil || cl.logger == nil {
 		legacyLoggerWithLevel.Infof(ctx, msg, args...)
 		return
@@ -86,15 +84,15 @@ func (cl *CustomLogger) Info(ctx context.Context, msg string, args ...any) {
 }
 
 // Debug is a structured debug level logging method with context and arguments.
-func (cl *CustomLogger) Debug(ctx context.Context, msg string, args ...any) {
+func (cl *LoggerWrapper) Debug(ctx context.Context, msg string, args ...any) {
 	if cl == nil || cl.logger == nil {
 		legacyLoggerWithLevel.Debugf(ctx, msg, args...)
 		return
 	}
 	cl.logger.DebugContext(ctx, msg, args...)
 }
 
-func (cl *CustomLogger) Infof(ctx context.Context, format string, v ...any) {
+func (cl *LoggerWrapper) Infof(ctx context.Context, format string, v ...any) {
 	if cl == nil || cl.logger == nil {
 		legacyLoggerWithLevel.Infof(ctx, format, v...)
 		return
@@ -103,33 +101,33 @@ func (cl *CustomLogger) Infof(ctx context.Context, format string, v ...any) {
 	cl.logger.InfoContext(cl.printfToStructured(ctx, format, v...))
 }
 
-func (cl *CustomLogger) Debugf(ctx context.Context, format string, v ...any) {
+func (cl *LoggerWrapper) Debugf(ctx context.Context, format string, v ...any) {
 	if cl == nil || cl.logger == nil {
 		legacyLoggerWithLevel.Debugf(ctx, format, v...)
 		return
 	}
 	cl.logger.DebugContext(cl.printfToStructured(ctx, format, v...))
 }
 
-func (cl *CustomLogger) printfToStructured(ctx context.Context, format string, v ...any) (context.Context, string, []any) {
+func (cl *LoggerWrapper) printfToStructured(ctx context.Context, format string, v ...any) (context.Context, string, []any) {
 	if cl != nil && cl.printfAdapter != nil {
 		return cl.printfAdapter(ctx, format, v...)
 	}
 	return ctx, fmt.Sprintf(format, v...), nil
 }
 
-func (cl *CustomLogger) Enabled(ctx context.Context, level LogLevelT) bool {
+func (cl *LoggerWrapper) Enabled(ctx context.Context, level LogLevelT) bool {
 	if cl != nil && cl.loggerLevel != nil {
 		return level >= *cl.loggerLevel
 	}
 
 	return legacyLoggerWithLevel.Enabled(ctx, level)
 }
 
-// LoggerWithLevel is a logger interface with leveled logging methods.
+// LoggerWithLevelI is a logger interface with leveled logging methods.
 //
 // [slog.Logger] from the standard library satisfies this interface.
-type LoggerWithLevel interface {
+type LoggerWithLevelI interface {
 	// InfoContext logs an info level message
 	InfoContext(ctx context.Context, format string, v ...any)
 

logging/legacy.go

@@ -6,11 +6,11 @@ import (
 	"github.com/redis/go-redis/v9/internal"
 )
 
-// legacyLoggerAdapter is a logger that implements [LoggerWithLevel] interface
+// legacyLoggerAdapter is a logger that implements [LoggerWithLevelI] interface
 // using the global [internal.Logger] and [internal.LogLevel] variables.
 type legacyLoggerAdapter struct{}
 
-var _ LoggerWithLevel = (*legacyLoggerAdapter)(nil)
+var _ LoggerWithLevelI = (*legacyLoggerAdapter)(nil)
 
 // structuredToPrintf converts a structured log message and key-value pairs into something a Printf-style logger can understand.
 func (l *legacyLoggerAdapter) structuredToPrintf(msg string, v ...any) (string, []any) {
@@ -92,3 +92,7 @@ func (l *legacyLoggerAdapter) Enabled(ctx context.Context, level LogLevelT) bool
 }
 
 var legacyLoggerWithLevel = &legacyLoggerAdapter{}
+
+func LoggerWithLevel() Lgr {
+	return legacyLoggerWithLevel
+}

logging/logging.go

@@ -90,3 +90,21 @@ func (l *filterLogger) Printf(ctx context.Context, format string, v ...interface
 	}
 }
 
+// Lgr is a logger interface with leveled logging methods.
+// It is implemented by LoggerWrapper and legacyLoggerAdapter.
+// If you would like to use `slog.Logger` from the standard library, you can use LoggerWrapper.
+//
+//		logger := slog.New(slog.NewTextHandler(os.Stderr))
+//	    db := redis.NewClient(&redis.Options{
+//			Logger: logging.NewLoggerWrapper(logger),
+//		})
+//
+// This will NOT handle all logging at the moment, singe there is still a global logger in use.
+// that will be deprecated in the future.
+type Lgr interface {
+	Errorf(ctx context.Context, format string, v ...any)
+	Warnf(ctx context.Context, format string, v ...any)
+	Infof(ctx context.Context, format string, v ...any)
+	Debugf(ctx context.Context, format string, v ...any)
+	Enabled(ctx context.Context, level LogLevelT) bool
+}

maintnotifications/circuit_breaker.go

@@ -194,12 +194,11 @@ func (cb *CircuitBreaker) GetStats() CircuitBreakerStats {
 	}
 }
 
-func (cb *CircuitBreaker) logger() *logging.CustomLogger {
-	var logger *logging.CustomLogger
+func (cb *CircuitBreaker) logger() logging.Lgr {
 	if cb.config != nil && cb.config.Logger != nil {
-		logger = cb.config.Logger
+		return cb.config.Logger
 	}
-	return logger
+	return logging.LoggerWithLevel()
 }
 
 // CircuitBreakerStats provides statistics about a circuit breaker
@@ -352,10 +351,9 @@ func (cbm *CircuitBreakerManager) Reset() {
 	})
 }
 
-func (cbm *CircuitBreakerManager) logger() *logging.CustomLogger {
-	var logger *logging.CustomLogger
+func (cbm *CircuitBreakerManager) logger() logging.Lgr {
 	if cbm.config != nil && cbm.config.Logger != nil {
-		logger = cbm.config.Logger
+		return cbm.config.Logger
 	}
-	return logger
+	return logging.LoggerWithLevel()
 }