log level as const

Author: ndyakov

example/pubsub/main.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/redis/go-redis/v9"
 	"github.com/redis/go-redis/v9/hitless"
+	"github.com/redis/go-redis/v9/logging"
 )
 
 var ctx = context.Background()
@@ -34,7 +35,7 @@ func main() {
 	if hitlessManager == nil {
 		panic("hitless manager is nil")
 	}
-	loggingHook := hitless.NewLoggingHook(3)
+	loggingHook := hitless.NewLoggingHook(logging.LogLevelDebug)
 	hitlessManager.AddNotificationHook(loggingHook)
 
 	go func() {

hitless/README.md

@@ -26,15 +26,18 @@ client := redis.NewClient(opt)
 ## Configuration
 
 ```go
-import "github.com/redis/go-redis/v9/hitless"
+import (
+    "github.com/redis/go-redis/v9/hitless"
+    "github.com/redis/go-redis/v9/logging"
+)
 
 Config: &hitless.Config{
     Mode:                       hitless.MaintNotificationsAuto, // Notification mode
     MaxHandoffRetries:           3,  // Retry failed handoffs
     HandoffTimeout:             15 * time.Second, // Handoff operation timeout
     RelaxedTimeout:             10 * time.Second, // Extended timeout during migrations
     PostHandoffRelaxedDuration: 20 * time.Second, // Keep relaxed timeout after handoff
-    LogLevel:                   1,  // 0=errors, 1=warnings, 2=info, 3=debug
+    LogLevel:                   logging.LogLevelWarn, // LogLevelError, LogLevelWarn, LogLevelInfo, LogLevelDebug
     MaxWorkers:                 15, // Concurrent handoff workers
     HandoffQueueSize:           50, // Handoff request queue size
 }

hitless/config.go

@@ -9,6 +9,18 @@ import (
 
 	"github.com/redis/go-redis/v9/internal"
 	"github.com/redis/go-redis/v9/internal/util"
+	"github.com/redis/go-redis/v9/logging"
+)
+
+// LogLevel represents the logging level for hitless upgrades
+type LogLevel = logging.LogLevel
+
+// Log level constants for hitless upgrades
+const (
+	LogLevelError LogLevel = logging.LogLevelError // 0 - errors only
+	LogLevelWarn  LogLevel = logging.LogLevelWarn  // 1 - warnings and errors
+	LogLevelInfo  LogLevel = logging.LogLevelInfo  // 2 - info, warnings, and errors
+	LogLevelDebug LogLevel = logging.LogLevelDebug // 3 - debug, info, warnings, and errors
 )
 
 // MaintNotificationsMode represents the maintenance notifications mode
@@ -116,9 +128,9 @@ type Config struct {
 	ScaleDownDelay time.Duration
 
 	// LogLevel controls the verbosity of hitless upgrade logging.
-	// 0 = errors only, 1 = warnings, 2 = info, 3 = debug
-	// Default: 1 (warnings)
-	LogLevel int
+	// LogLevelError (0) = errors only, LogLevelWarn (1) = warnings, LogLevelInfo (2) = info, LogLevelDebug (3) = debug
+	// Default: LogLevelWarn (warnings)
+	LogLevel LogLevel
 
 	// MaxHandoffRetries is the maximum number of times to retry a failed handoff.
 	// After this many retries, the connection will be removed from the pool.
@@ -141,7 +153,7 @@ func DefaultConfig() *Config {
 		HandoffQueueSize:           0, // Auto-calculated based on max workers
 		PostHandoffRelaxedDuration: 0, // Auto-calculated based on relaxed timeout
 		ScaleDownDelay:             2 * time.Second,
-		LogLevel:                   1,
+		LogLevel:                   LogLevelWarn,
 
 		// Connection Handoff Configuration
 		MaxHandoffRetries: 3,
@@ -168,7 +180,7 @@ func (c *Config) Validate() error {
 	if c.PostHandoffRelaxedDuration < 0 {
 		return ErrInvalidPostHandoffRelaxedDuration
 	}
-	if c.LogLevel < 0 || c.LogLevel > 3 {
+	if !c.LogLevel.IsValid() {
 		return ErrInvalidLogLevel
 	}
 
@@ -281,8 +293,7 @@ func (c *Config) ApplyDefaultsWithPoolSize(poolSize int) *Config {
 		result.MaxHandoffRetries = c.MaxHandoffRetries
 	}
 
-	if result.LogLevel >= 3 {
-		result.LogLevel = 3
+	if result.LogLevel >= LogLevelDebug {
 		internal.Logger.Printf(context.Background(), "hitless: debug logging enabled")
 		internal.Logger.Printf(context.Background(), "hitless: config: %+v", result)
 	}

hitless/config_test.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/redis/go-redis/v9/internal/util"
+	"github.com/redis/go-redis/v9/logging"
 )
 
 func TestConfig(t *testing.T) {
@@ -293,8 +294,8 @@ func TestIntegrationWithApplyDefaults(t *testing.T) {
 	t.Run("ProcessorWithPartialConfigAppliesDefaults", func(t *testing.T) {
 		// Create a partial config with only some fields set
 		partialConfig := &Config{
-			MaxWorkers: 15, // Custom value (>= 10 to test preservation)
-			LogLevel:   2,  // Custom value
+			MaxWorkers: 15,                    // Custom value (>= 10 to test preservation)
+			LogLevel:   logging.LogLevelInfo, // Custom value
 			// Other fields left as zero values - should get defaults
 		}
 

hitless/errors.go

@@ -11,7 +11,7 @@ var (
 	ErrInvalidHandoffWorkers             = errors.New("hitless: MaxWorkers must be greater than or equal to 0")
 	ErrInvalidHandoffQueueSize           = errors.New("hitless: handoff queue size must be greater than 0")
 	ErrInvalidPostHandoffRelaxedDuration = errors.New("hitless: post-handoff relaxed duration must be greater than or equal to 0")
-	ErrInvalidLogLevel                   = errors.New("hitless: log level must be between 0 and 3")
+	ErrInvalidLogLevel                   = errors.New("hitless: log level must be LogLevelError (0), LogLevelWarn (1), LogLevelInfo (2), or LogLevelDebug (3)")
 	ErrInvalidEndpointType               = errors.New("hitless: invalid endpoint type")
 	ErrInvalidMaintNotifications         = errors.New("hitless: invalid maintenance notifications setting (must be 'disabled', 'enabled', or 'auto')")
 	ErrMaxHandoffRetriesReached          = errors.New("hitless: max handoff retries reached")

hitless/hitless_manager.go

@@ -148,11 +148,14 @@ func (hm *HitlessManager) TrackMovingOperationWithConnID(ctx context.Context, ne
 	// Use LoadOrStore for atomic check-and-set operation
 	if _, loaded := hm.activeMovingOps.LoadOrStore(key, movingOp); loaded {
 		// Duplicate MOVING notification, ignore
-		if hm.config.LogLevel >= 3 { // Warning level
-			internal.Logger.Printf(ctx, "hitless: conn[%d] seqID[%d] Duplicate MOVING operation ignored: %s", connID, seqID, key.String())
+		if hm.config.LogLevel >= LogLevelDebug { // Debug level
+			internal.Logger.Printf(context.Background(), "hitless: conn[%d] seqID[%d] Duplicate MOVING operation ignored: %s", connID, seqID, key.String())
 		}
 		return nil
 	}
+	if hm.config.LogLevel >= LogLevelDebug { // Debug level
+		internal.Logger.Printf(context.Background(), "hitless: conn[%d] seqID[%d] Tracking MOVING operation: %s", connID, seqID, key.String())
+	}
 
 	// Increment active operation count atomically
 	hm.activeOperationCount.Add(1)
@@ -170,10 +173,16 @@ func (hm *HitlessManager) UntrackOperationWithConnID(seqID int64, connID uint64)
 
 	// Remove from active operations atomically
 	if _, loaded := hm.activeMovingOps.LoadAndDelete(key); loaded {
+		if hm.config.LogLevel >= LogLevelDebug { // Debug level
+			internal.Logger.Printf(context.Background(), "hitless: conn[%d] seqID[%d] Untracking MOVING operation: %s", connID, seqID, key.String())
+		}
 		// Decrement active operation count only if operation existed
 		hm.activeOperationCount.Add(-1)
 	} else {
-		if hm.config.LogLevel >= 3 { // Warning level
+		for key, _ := range hm.GetActiveMovingOperations() {
+			internal.Logger.Printf(context.Background(), "hitless: active op: key: %s", key.String())
+		}
+		if hm.config.LogLevel >= LogLevelDebug { // Debug level
 			internal.Logger.Printf(context.Background(), "hitless: conn[%d] seqID[%d] Operation not found for untracking: %s", connID, seqID, key.String())
 		}
 	}

hitless/hooks.go

@@ -5,17 +5,18 @@ import (
 
 	"github.com/redis/go-redis/v9/internal"
 	"github.com/redis/go-redis/v9/internal/pool"
+	"github.com/redis/go-redis/v9/logging"
 	"github.com/redis/go-redis/v9/push"
 )
 
 // LoggingHook is an example hook implementation that logs all notifications.
 type LoggingHook struct {
-	LogLevel int
+	LogLevel logging.LogLevel
 }
 
 // PreHook logs the notification before processing and allows modification.
 func (lh *LoggingHook) PreHook(ctx context.Context, notificationCtx push.NotificationHandlerContext, notificationType string, notification []interface{}) ([]interface{}, bool) {
-	if lh.LogLevel >= 2 { // Info level
+	if lh.LogLevel >= logging.LogLevelInfo { // Info level
 		// Log the notification type and content
 		connID := uint64(0)
 		if conn, ok := notificationCtx.Conn.(*pool.Conn); ok {
@@ -32,15 +33,15 @@ func (lh *LoggingHook) PostHook(ctx context.Context, notificationCtx push.Notifi
 	if conn, ok := notificationCtx.Conn.(*pool.Conn); ok {
 		connID = conn.GetID()
 	}
-	if result != nil && lh.LogLevel >= 1 { // Warning level
+	if result != nil && lh.LogLevel >= logging.LogLevelWarn { // Warning level
 		internal.Logger.Printf(ctx, "hitless: conn[%d] %s notification processing failed: %v - %v", connID, notificationType, result, notification)
-	} else if lh.LogLevel >= 3 { // Debug level
+	} else if lh.LogLevel >= logging.LogLevelDebug { // Debug level
 		internal.Logger.Printf(ctx, "hitless: conn[%d] %s notification processed successfully", connID, notificationType)
 	}
 }
 
 // NewLoggingHook creates a new logging hook with the specified log level.
-// Log levels: 0=errors, 1=warnings, 2=info, 3=debug
-func NewLoggingHook(logLevel int) *LoggingHook {
+// Log levels: LogLevelError=errors, LogLevelWarn=warnings, LogLevelInfo=info, LogLevelDebug=debug
+func NewLoggingHook(logLevel logging.LogLevel) *LoggingHook {
 	return &LoggingHook{LogLevel: logLevel}
 }

hitless/notification_handler.go

@@ -106,7 +106,7 @@ func (snh *NotificationHandler) handleMoving(ctx context.Context, handlerCtx pus
 	deadline := time.Now().Add(time.Duration(timeS) * time.Second)
 	// If newEndpoint is empty, we should schedule a handoff to the current endpoint in timeS/2 seconds
 	if newEndpoint == "" || newEndpoint == internal.RedisNull {
-		if snh.manager.config.LogLevel >= 3 { // Debug level
+		if snh.manager.config.LogLevel >= LogLevelDebug { // Debug level
 			internal.Logger.Printf(ctx, "hitless: conn[%d] scheduling handoff to current endpoint in %v seconds",
 				poolConn.GetID(), timeS/2)
 		}
@@ -169,7 +169,7 @@ func (snh *NotificationHandler) handleMigrating(ctx context.Context, handlerCtx
 	}
 
 	// Apply relaxed timeout to this specific connection
-	if snh.manager.config.LogLevel >= 3 { // Debug level
+	if snh.manager.config.LogLevel >= LogLevelDebug { // Debug level
 		internal.Logger.Printf(ctx, "hitless: conn[%d] applying relaxed timeout (%v) for MIGRATING notification",
 			conn.GetID(),
 			snh.manager.config.RelaxedTimeout)
@@ -199,7 +199,7 @@ func (snh *NotificationHandler) handleMigrated(ctx context.Context, handlerCtx p
 	}
 
 	// Clear relaxed timeout for this specific connection
-	if snh.manager.config.LogLevel >= 3 { // Debug level
+	if snh.manager.config.LogLevel >= LogLevelDebug { // Debug level
 		connID := conn.GetID()
 		internal.Logger.Printf(ctx, "hitless: conn[%d] clearing relaxed timeout for MIGRATED notification", connID)
 	}
@@ -228,7 +228,7 @@ func (snh *NotificationHandler) handleFailingOver(ctx context.Context, handlerCt
 	}
 
 	// Apply relaxed timeout to this specific connection
-	if snh.manager.config.LogLevel >= 3 { // Debug level
+	if snh.manager.config.LogLevel >= LogLevelDebug { // Debug level
 		connID := conn.GetID()
 		internal.Logger.Printf(ctx, "hitless: conn[%d] applying relaxed timeout (%v) for FAILING_OVER notification", connID, snh.manager.config.RelaxedTimeout)
 	}
@@ -257,7 +257,7 @@ func (snh *NotificationHandler) handleFailedOver(ctx context.Context, handlerCtx
 	}
 
 	// Clear relaxed timeout for this specific connection
-	if snh.manager.config.LogLevel >= 3 { // Debug level
+	if snh.manager.config.LogLevel >= LogLevelDebug { // Debug level
 		connID := conn.GetID()
 		internal.Logger.Printf(ctx, "hitless: conn[%d] clearing relaxed timeout for FAILED_OVER notification", connID)
 	}

hitless/pool_hook.go

@@ -217,7 +217,7 @@ func (ph *PoolHook) onDemandWorker() {
 
 		case <-time.After(ph.workerTimeout):
 			// Worker has been idle for too long, exit to save resources
-			if ph.config != nil && ph.config.LogLevel >= 3 { // Debug level
+			if ph.config != nil && ph.config.LogLevel >= LogLevelDebug { // Debug level
 				internal.Logger.Printf(context.Background(),
 					"hitless: worker exiting due to inactivity timeout (%v)", ph.workerTimeout)
 			}
@@ -258,6 +258,7 @@ func (ph *PoolHook) processHandoffRequest(request HandoffRequest) {
 
 	// Perform the handoff with cancellable context
 	shouldRetry, err := ph.performConnectionHandoffWithPool(shutdownCtx, request.Conn, request.Pool)
+	minRetryBackoff := 500 * time.Millisecond
 	if err != nil {
 		if shouldRetry {
 			now := time.Now()
@@ -268,20 +269,31 @@ func (ph *PoolHook) processHandoffRequest(request HandoffRequest) {
 			}
 
 			afterTime := deadline.Sub(now)
-			if afterTime < handoffTimeout/2 {
+			if afterTime > handoffTimeout/2 {
 				afterTime = handoffTimeout / 2
 			}
+			if afterTime < minRetryBackoff {
+				afterTime = minRetryBackoff
+			}
 
 			internal.Logger.Printf(context.Background(), "Handoff failed for conn[%d] WILL RETRY After %v: %v", request.ConnID, afterTime, err)
 			time.AfterFunc(afterTime, func() {
 				if err := ph.queueHandoff(request.Conn); err != nil {
 					internal.Logger.Printf(context.Background(), "can't queue handoff for retry: %v", err)
-					ph.removeConn(ctx, request, err)
+					ph.removeConn(context.Background(), request, err)
 				}
 			})
+			return
 		} else {
 			go ph.removeConn(ctx, request, err)
 		}
+
+		// Clear handoff state if not returned for retry
+		seqID := request.Conn.GetMovingSeqID()
+		connID := request.Conn.GetID()
+		if ph.hitlessManager != nil {
+			ph.hitlessManager.UntrackOperationWithConnID(seqID, connID)
+		}
 	}
 }
 
@@ -290,14 +302,14 @@ func (ph *PoolHook) removeConn(ctx context.Context, request HandoffRequest, err
 	conn := request.Conn
 	if pooler != nil {
 		pooler.Remove(ctx, conn, err)
-		if ph.config != nil && ph.config.LogLevel >= 1 { // Warning level
+		if ph.config != nil && ph.config.LogLevel >= LogLevelWarn { // Warning level
 			internal.Logger.Printf(ctx,
 				"hitless: removed connection %d from pool due to max handoff retries reached",
 				conn.GetID())
 		}
 	} else {
 		conn.Close()
-		if ph.config != nil && ph.config.LogLevel >= 1 { // Warning level
+		if ph.config != nil && ph.config.LogLevel >= LogLevelWarn { // Warning level
 			internal.Logger.Printf(ctx,
 				"hitless: no pool provided for connection %d, cannot remove due to handoff initialization failure: %v",
 				conn.GetID(), err)
@@ -335,7 +347,7 @@ func (ph *PoolHook) queueHandoff(conn *pool.Conn) error {
 			// Queue is full - log and attempt scaling
 			queueLen := len(ph.handoffQueue)
 			queueCap := cap(ph.handoffQueue)
-			if ph.config != nil && ph.config.LogLevel >= 1 { // Warning level
+			if ph.config != nil && ph.config.LogLevel >= LogLevelWarn { // Warning level
 				internal.Logger.Printf(context.Background(),
 					"hitless: handoff queue is full (%d/%d), attempting timeout queuing and scaling workers",
 					queueLen, queueCap)
@@ -352,14 +364,8 @@ func (ph *PoolHook) queueHandoff(conn *pool.Conn) error {
 // When error is returned, the connection handoff should be retried if err is not ErrMaxHandoffRetriesReached
 func (ph *PoolHook) performConnectionHandoffWithPool(ctx context.Context, conn *pool.Conn, pooler pool.Pooler) (shouldRetry bool, err error) {
 	// Clear handoff state after successful handoff
-	seqID := conn.GetMovingSeqID()
 	connID := conn.GetID()
 
-	// Notify hitless manager of completion if available
-	if ph.hitlessManager != nil {
-		defer ph.hitlessManager.UntrackOperationWithConnID(seqID, connID)
-	}
-
 	newEndpoint := conn.GetHandoffEndpoint()
 	if newEndpoint == "" {
 		return false, ErrConnectionInvalidHandoffState
@@ -373,7 +379,7 @@ func (ph *PoolHook) performConnectionHandoffWithPool(ctx context.Context, conn *
 	}
 
 	if retries > maxRetries {
-		if ph.config != nil && ph.config.LogLevel >= 1 { // Warning level
+		if ph.config != nil && ph.config.LogLevel >= LogLevelWarn { // Warning level
 			internal.Logger.Printf(ctx,
 				"hitless: reached max retries (%d) for handoff of connection %d to %s",
 				maxRetries, conn.GetID(), conn.GetHandoffEndpoint())
@@ -425,8 +431,8 @@ func (ph *PoolHook) performConnectionHandoffWithPool(ctx context.Context, conn *
 
 		if ph.config.LogLevel >= 2 { // Info level
 			internal.Logger.Printf(context.Background(),
-				"hitless: applied post-handoff relaxed timeout (%v) until %v for connection %d",
-				relaxedTimeout, deadline.Format("15:04:05.000"), connID)
+				"hitless: conn[%d] applied post-handoff relaxed timeout (%v) until %v",
+				connID, relaxedTimeout, deadline.Format("15:04:05.000"))
 		}
 	}
 

internal/log.go

@@ -6,6 +6,19 @@ import (
 	"log"
 	"os"
 	"strings"
+
+	"github.com/redis/go-redis/v9/logging"
+)
+
+// LogLevel is an alias to the public logging.LogLevel for internal use
+type LogLevel = logging.LogLevel
+
+// Log level constants for internal use
+const (
+	LogLevelError = logging.LogLevelError
+	LogLevelWarn  = logging.LogLevelWarn
+	LogLevelInfo  = logging.LogLevelInfo
+	LogLevelDebug = logging.LogLevelDebug
 )
 
 // TODO (ned): Revisit logging