renamte log level to legacy log level

Author: joao-r-reis

cluster.go

@@ -267,9 +267,12 @@ type ClusterConfig struct {
 	// If not specified, Logger will be used instead.
 	StructuredLogger AdvancedLogger
 
-	// MinimumLogLevel for this ClusterConfig.
+	// LegacyLogLevel for this ClusterConfig, this is only applied for legacy loggers (field Logger).
+	// This log level is not applied to StructuredLogger because the log level is already a part of the interface
+	// so the implementation can decide when not to log something.
+	//
 	// If not specified, LogLevelWarn will be used as the default.
-	MinimumLogLevel LogLevel
+	LegacyLogLevel LogLevel
 
 	// internal config for testing
 	disableControlConn bool
@@ -306,19 +309,19 @@ func NewCluster(hosts ...string) *ClusterConfig {
 		ConvictionPolicy:       &SimpleConvictionPolicy{},
 		ReconnectionPolicy:     &ConstantReconnectionPolicy{MaxRetries: 3, Interval: 1 * time.Second},
 		WriteCoalesceWaitTime:  200 * time.Microsecond,
-		MinimumLogLevel:        LogLevelWarn,
+		LegacyLogLevel:         LogLevelWarn,
 	}
 	return cfg
 }
 
 func (cfg *ClusterConfig) newLogger() loggerAdapter {
 	if cfg.StructuredLogger != nil {
-		return newInternalLoggerFromAdvancedLogger(cfg.StructuredLogger, cfg.MinimumLogLevel)
+		return newInternalLoggerFromAdvancedLogger(cfg.StructuredLogger)
 	}
 	if cfg.Logger == nil {
-		return newInternalLoggerFromStdLogger(&defaultLogger{}, cfg.MinimumLogLevel)
+		return newInternalLoggerFromStdLogger(&defaultLogger{}, cfg.LegacyLogLevel)
 	}
-	return newInternalLoggerFromStdLogger(cfg.Logger, cfg.MinimumLogLevel)
+	return newInternalLoggerFromStdLogger(cfg.Logger, cfg.LegacyLogLevel)
 }
 
 // CreateSession initializes the cluster based on this config and returns a

conn.go

@@ -146,7 +146,7 @@ type ConnConfig struct {
 	Keepalive        time.Duration
 	Logger           StdLogger
 	StructuredLogger AdvancedLogger
-	MinimumLogLevel  LogLevel
+	LegacyLogLevel   LogLevel
 
 	tlsConfig       *tls.Config
 	disableCoalesce bool

connectionpool.go

@@ -156,7 +156,7 @@ func connConfig(cfg *ClusterConfig) (*ConnConfig, error) {
 		Keepalive:        cfg.SocketKeepalive,
 		Logger:           cfg.Logger,
 		StructuredLogger: cfg.StructuredLogger,
-		MinimumLogLevel:  cfg.MinimumLogLevel,
+		LegacyLogLevel:   cfg.LegacyLogLevel,
 	}, nil
 }
 

logger.go

@@ -91,9 +91,9 @@ func (l *defaultLogger) Printf(format string, v ...interface{}) { log.Printf(for
 func (l *defaultLogger) Println(v ...interface{})               { log.Println(v...) }
 
 var nilInternalLogger internalLogger = loggerAdapter{
-	minimumLogLevel: LogLevelNone,
-	advLogger:       nopLogger{},
-	legacyLogger:    nil,
+	legacyLogLevel: LogLevelNone,
+	advLogger:      nopLogger{},
+	legacyLogger:   nil,
 }
 
 type LogLevel int
@@ -146,13 +146,12 @@ type AdvancedLogger interface {
 
 type internalLogger interface {
 	AdvancedLogger
-	MinimumLogLevel() LogLevel
 }
 
 type loggerAdapter struct {
-	minimumLogLevel LogLevel
-	advLogger       AdvancedLogger
-	legacyLogger    StdLogger
+	legacyLogLevel LogLevel
+	advLogger      AdvancedLogger
+	legacyLogger   StdLogger
 }
 
 func (recv loggerAdapter) logLegacy(msg string, fields ...LogField) {
@@ -173,61 +172,48 @@ func (recv loggerAdapter) logLegacy(msg string, fields ...LogField) {
 }
 
 func (recv loggerAdapter) Error(msg string, fields ...LogField) {
-	if LogLevelError <= recv.minimumLogLevel {
-		if recv.advLogger != nil {
-			recv.advLogger.Error(msg, fields...)
-		} else {
-			recv.logLegacy(msg, fields...)
-		}
+	if recv.advLogger != nil {
+		recv.advLogger.Error(msg, fields...)
+	} else if LogLevelError <= recv.legacyLogLevel {
+		recv.logLegacy(msg, fields...)
 	}
 }
 
 func (recv loggerAdapter) Warning(msg string, fields ...LogField) {
-	if LogLevelWarn <= recv.minimumLogLevel {
-		if recv.advLogger != nil {
-			recv.advLogger.Warning(msg, fields...)
-		} else {
-			recv.logLegacy(msg, fields...)
-		}
+	if recv.advLogger != nil {
+		recv.advLogger.Warning(msg, fields...)
+	} else if LogLevelWarn <= recv.legacyLogLevel {
+		recv.logLegacy(msg, fields...)
 	}
 }
 
 func (recv loggerAdapter) Info(msg string, fields ...LogField) {
-	if LogLevelInfo <= recv.minimumLogLevel {
-		if recv.advLogger != nil {
-			recv.advLogger.Info(msg, fields...)
-		} else {
-			recv.logLegacy(msg, fields...)
-		}
+	if recv.advLogger != nil {
+		recv.advLogger.Info(msg, fields...)
+	} else if LogLevelInfo <= recv.legacyLogLevel {
+		recv.logLegacy(msg, fields...)
 	}
 }
 
 func (recv loggerAdapter) Debug(msg string, fields ...LogField) {
-	if LogLevelDebug <= recv.minimumLogLevel {
-		if recv.advLogger != nil {
-			recv.advLogger.Debug(msg, fields...)
-		} else {
-			recv.logLegacy(msg, fields...)
-		}
+	if recv.advLogger != nil {
+		recv.advLogger.Debug(msg, fields...)
+	} else if LogLevelDebug <= recv.legacyLogLevel {
+		recv.logLegacy(msg, fields...)
 	}
 }
 
-func (recv loggerAdapter) MinimumLogLevel() LogLevel {
-	return recv.minimumLogLevel
-}
-
-func newInternalLoggerFromAdvancedLogger(logger AdvancedLogger, level LogLevel) loggerAdapter {
+func newInternalLoggerFromAdvancedLogger(logger AdvancedLogger) loggerAdapter {
 	return loggerAdapter{
-		minimumLogLevel: level,
-		advLogger:       logger,
-		legacyLogger:    nil,
+		advLogger:    logger,
+		legacyLogger: nil,
 	}
 }
 
 func newInternalLoggerFromStdLogger(logger StdLogger, level LogLevel) loggerAdapter {
 	return loggerAdapter{
-		minimumLogLevel: level,
-		advLogger:       nil,
-		legacyLogger:    logger,
+		legacyLogLevel: level,
+		advLogger:      nil,
+		legacyLogger:   logger,
 	}
 }