Enable ANSI color log output only when log-level >= 3

Previously ANSI color codes were always emitted in log output.
This change makes color output opt-in: only when --log-level=3
or higher is specified will the console writer use ANSI colors.
At default levels (0/1/2), logs are plain text for cleaner output
in non-terminal environments (e.g. kubectl logs, log aggregators).

Changes:
- Add enableColor flag (logLevel >= 3) in ZapCustomLogger
- Set ConsoleWriter.NoColor based on the flag
- Guard FormatLevel and FormatCaller color wrapping
- Widen logLevel switch to handle >= 2 for TraceLevel
- Add TestGetLogLevel and TestAnsiColorOnlyEnabledAtLevel3 tests

Change-Id: Iae257ccb447b63d2a2f40c28b5096d53f1527ea2

Author: zhengxiexie

pkg/logger/logger.go

@@ -105,13 +105,18 @@ func getLogLevel(cfDebug bool, cfLogLevel int) int {
 // ZapCustomLogger creates a CustomLogger with both logr.Logger and zerolog.Logger using the same configuration as ZapLogger
 func ZapCustomLogger(cfDebug bool, cfLogLevel int) CustomLogger {
 	logLevel := getLogLevel(cfDebug, cfLogLevel)
+	enableColor := logLevel >= 3
 
 	// Create the custom console writer with zap-like formatting
 	consoleWriter := zerolog.ConsoleWriter{
 		Out:        os.Stdout,
+		NoColor:    !enableColor,
 		TimeFormat: logTmFmtWithMS,
 		FormatLevel: func(i interface{}) string {
 			levelStr := strings.ToUpper(fmt.Sprintf("%s", i))
+			if !enableColor {
+				return levelStr
+			}
 			switch levelStr {
 			case "TRACE":
 				return colorWhite + levelStr + colorReset
@@ -140,6 +145,9 @@ func ZapCustomLogger(cfDebug bool, cfLogLevel int) CustomLogger {
 			if idx := strings.LastIndex(caller, "/"); idx >= 0 {
 				caller = caller[idx+1:]
 			}
+			if !enableColor {
+				return caller
+			}
 			return colorYellow + caller + colorReset
 		},
 		FormatFieldName: func(i interface{}) string {
@@ -154,7 +162,7 @@ func ZapCustomLogger(cfDebug bool, cfLogLevel int) CustomLogger {
 	// Set the log level based on the calculated level
 	var zeroLogLevel zerolog.Level
 	switch {
-	case logLevel == 2:
+	case logLevel >= 2:
 		zeroLogLevel = zerolog.TraceLevel
 	case logLevel == 1:
 		zeroLogLevel = zerolog.DebugLevel

pkg/logger/logger_test.go

@@ -1,8 +1,13 @@
 package logger
 
 import (
+	"bytes"
+	"fmt"
+	"strings"
 	"testing"
 	"time"
+
+	"github.com/rs/zerolog"
 )
 
 func TestZapLoggerLevels(t *testing.T) {
@@ -79,3 +84,95 @@ func TestCustomLogger(t *testing.T) {
 
 	t.Log("CustomLogger test completed - verify all log levels are displayed with proper formatting and colors")
 }
+
+func TestGetLogLevel(t *testing.T) {
+	testCases := []struct {
+		name     string
+		debug    bool
+		logLevel int
+		expected int
+	}{
+		{"default", false, 0, 0},
+		{"debug_flag_only", true, 0, 2},
+		{"log_level_1", false, 1, 1},
+		{"log_level_3", false, 3, 3},
+		{"debug_with_higher_level", true, 3, 3},
+		{"debug_with_lower_level", true, 1, 2},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := getLogLevel(tc.debug, tc.logLevel)
+			if got != tc.expected {
+				t.Errorf("getLogLevel(%v, %d) = %d, want %d", tc.debug, tc.logLevel, got, tc.expected)
+			}
+		})
+	}
+}
+
+func TestAnsiColorOnlyEnabledAtLevel3(t *testing.T) {
+	// Helper: create a console writer via the same logic as ZapCustomLogger,
+	// but write to a buffer so we can inspect the output.
+	buildWriter := func(logLevel int) (*bytes.Buffer, zerolog.Logger) {
+		enableColor := logLevel >= 3
+		buf := &bytes.Buffer{}
+		cw := zerolog.ConsoleWriter{
+			Out:        buf,
+			NoColor:    !enableColor,
+			TimeFormat: logTmFmtWithMS,
+			FormatLevel: func(i interface{}) string {
+			levelStr := strings.ToUpper(fmt.Sprintf("%s", i))
+				if !enableColor {
+					return levelStr
+				}
+				switch levelStr {
+				case "INFO":
+					return colorGreen + levelStr + colorReset
+				case "WARN":
+					return colorMagenta + levelStr + colorReset
+				case "ERROR":
+					return colorBrightRed + levelStr + colorReset
+				default:
+					return levelStr
+				}
+			},
+		}
+		l := zerolog.New(cw).Level(zerolog.InfoLevel)
+		return buf, l
+	}
+
+	t.Run("level_0_no_color", func(t *testing.T) {
+		buf, l := buildWriter(0)
+		l.Info().Msg("hello")
+		output := buf.String()
+		if strings.Contains(output, "\033[") {
+			t.Errorf("log-level=0 should not contain ANSI codes, got: %q", output)
+		}
+	})
+
+	t.Run("level_2_no_color", func(t *testing.T) {
+		buf, l := buildWriter(2)
+		l.Info().Msg("hello")
+		output := buf.String()
+		if strings.Contains(output, "\033[") {
+			t.Errorf("log-level=2 should not contain ANSI codes, got: %q", output)
+		}
+	})
+
+	t.Run("level_3_has_color", func(t *testing.T) {
+		buf, l := buildWriter(3)
+		l.Info().Msg("hello")
+		output := buf.String()
+		if !strings.Contains(output, "\033[") {
+			t.Errorf("log-level=3 should contain ANSI codes, got: %q", output)
+		}
+	})
+
+	t.Run("level_4_has_color", func(t *testing.T) {
+		buf, l := buildWriter(4)
+		l.Info().Msg("hello")
+		output := buf.String()
+		if !strings.Contains(output, "\033[") {
+			t.Errorf("log-level=4 should contain ANSI codes, got: %q", output)
+		}
+	})
+}