addressed PR comments

Author: navinms711

src/code.cloudfoundry.org/gorouter/cmd/gorouter/adapter.go

@@ -0,0 +1,102 @@
+package main
+
+import (
+	grlog "code.cloudfoundry.org/gorouter/logger"
+	"code.cloudfoundry.org/lager/v3"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"log/slog"
+	"os"
+	"strings"
+	"time"
+)
+
+// zapLevelSink is a lager sink that uses a slog.Logger for logging.
+// It implements the lager.Sink interface, allowing it to be used with
+// lager's logging system. The Log method logs the message and source
+// using the slog.Logger, and the LogLevel method returns the current
+// logging level.
+type zapLevelSink struct {
+	logger *slog.Logger
+}
+
+func (z *zapLevelSink) Log(lf lager.LogFormat) {
+	z.logger.Info("zapLevelSink Log()", slog.String("Zap Level Sink log invoked", lf.Message),
+		slog.String("source", lf.Source))
+}
+
+func (z *zapLevelSink) LogLevel() lager.LogLevel {
+	switch strings.ToLower(grlog.GetLoggingLevel()) {
+	case "debug":
+		return lager.DEBUG
+	case "info":
+		return lager.INFO
+	case "error":
+		return lager.ERROR
+	case "warn":
+		// lager does not have a separate WARN level, it uses INFO for warnings.
+		return lager.INFO
+	case "fatal":
+		return lager.FATAL
+	default:
+		return lager.INFO
+	}
+}
+
+// The SetMinLevel method updates the logging level of the
+// zapLevelSink based on the provided lager.LogLevel, mapping it to
+// the corresponding zapcore.Level. The logger is expected to be set
+// before using this sink, and it will log an info message when the
+// logging level is updated.
+func (z *zapLevelSink) SetMinLevel(level lager.LogLevel) {
+	var zapLevel zapcore.Level
+	switch level {
+	case lager.DEBUG:
+		zapLevel = zapcore.DebugLevel
+	case lager.INFO:
+		zapLevel = zapcore.InfoLevel
+	case lager.ERROR:
+		zapLevel = zapcore.ErrorLevel
+	case lager.FATAL:
+		zapLevel = zapcore.FatalLevel
+	default:
+		// There is no lager.WARN level, so mapping it to zapcore.WarnLevel in default case.
+		zapLevel = zapcore.WarnLevel
+	}
+
+	grlog.SetLoggingLevel(zapLevel.String())
+
+	// Print the new log level to the logger to confirm the change.
+	// This is useful for debugging and confirming that the log level has been updated.
+	if z.logger != nil {
+		// We cannot use z.logger.Info() directly here because it won't print the
+		// log level when it is set to zapcore.ErrorLevel or zapcore.FatalLevel.
+		// Instead, we use slog.New() to log the message. This ensures that the
+		// log level change is always logged, regardless of the current log level.
+		tmpLogger := NewZapLoggerWithTimestamp()
+		tmpLogger.Info("Gorouter logger -> zapcore log level updated.",
+			zap.String("new log_level", zapLevel.String()))
+	}
+}
+
+// NewZapLoggerWithTimestamp creates a new zap.Logger with a custom
+// timestamp encoder that outputs the timestamp as a float64 representing
+// the number of seconds since the Unix epoch.
+func NewZapLoggerWithTimestamp() *zap.Logger {
+	cfg := zap.NewProductionEncoderConfig()
+	// customized keys for the JSON encoder
+	cfg.TimeKey = "timestamp"
+	cfg.LevelKey = "log_level"
+	cfg.MessageKey = "message"
+	// time encoded as float64
+	cfg.EncodeTime = func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
+		enc.AppendFloat64(float64(t.UnixNano()) / 1e9)
+	}
+	// Encode log level as int. zapcore.Level is 0-indexed,
+	// so add 1 to the level to match the gorouter's expected level.
+	cfg.EncodeLevel = func(l zapcore.Level, enc zapcore.PrimitiveArrayEncoder) {
+		enc.AppendInt(int(l + 1))
+	}
+	core := zapcore.NewCore(zapcore.NewJSONEncoder(cfg), zapcore.AddSync(os.Stdout), zap.InfoLevel)
+	return zap.New(core)
+}

src/code.cloudfoundry.org/gorouter/cmd/gorouter/main.go

@@ -8,16 +8,13 @@ import (
 	"log/slog"
 	"os"
 	"runtime"
-	"strings"
 	"syscall"
 	"time"
 
 	"code.cloudfoundry.org/gorouter/metrics_prometheus"
-	"go.uber.org/zap/zapcore"
 
 	"code.cloudfoundry.org/clock"
 	"code.cloudfoundry.org/debugserver"
-	"code.cloudfoundry.org/lager/v3"
 	"code.cloudfoundry.org/tlsconfig"
 	"github.com/cloudfoundry/dropsonde"
 	"github.com/cloudfoundry/dropsonde/metric_sender"
@@ -52,81 +49,13 @@ var (
 	h          *health.Health
 )
 
-// zapLevelSink is a lager sink that uses a slog.Logger for logging.
-// It implements the lager.Sink interface, allowing it to be used with
-// lager's logging system. The Log method logs the message and source
-// using the slog.Logger, and the LogLevel method returns the current
-// logging level.
-
-type zapLevelSink struct {
-	logger *slog.Logger
-}
-
-func (z *zapLevelSink) Log(lf lager.LogFormat) {
-	z.logger.Info("zapLevelSink Log()", slog.String("Zap Level Sink log invoked", lf.Message),
-		slog.String("source", lf.Source))
-}
-
-func (z *zapLevelSink) LogLevel() lager.LogLevel {
-	switch strings.ToLower(grlog.GetLoggingLevel()) {
-	case "debug":
-		return lager.DEBUG
-	case "info":
-		return lager.INFO
-	case "error":
-		return lager.ERROR
-	case "fatal":
-		return lager.FATAL
-	default:
-		return lager.INFO
-	}
-}
-
-// The SetMinLevel method updates the logging level of the
-// zapLevelSink based on the provided lager.LogLevel, mapping it to
-// the corresponding zapcore.Level. The logger is expected to be set
-// before using this sink, and it will log an info message when the
-// logging level is updated.
-
-func (z *zapLevelSink) SetMinLevel(level lager.LogLevel) {
-	var zapLevel zapcore.Level
-	switch level {
-	case lager.DEBUG:
-		zapLevel = zapcore.DebugLevel
-	case lager.INFO:
-		zapLevel = zapcore.InfoLevel
-	case lager.ERROR, lager.FATAL:
-		// For lager.ERROR and lager.FATAL, we use zapcore.ErrorLevel.
-		// This is because zapcore.ErrorLevel captures both error and fatal logs.
-		// Using zapcore.FatalLevel would cause the application to exit immediately.
-		// Because zapcore.FatalLevel calls os.Exit(1) after logging the message.
-		zapLevel = zapcore.ErrorLevel
-	default:
-		zapLevel = zapcore.InfoLevel
-	}
-
-	grlog.SetLoggingLevel(zapLevel.String())
-
-	// Print the new log level to the logger to confirm the change.
-	// This is useful for debugging and confirming that the log level has been updated.
-	if z.logger != nil {
-		// We cannot use z.logger.Info() directly here because it won't print the
-		// log level when it is set to zapcore.ErrorLevel or zapcore.FatalLevel.
-		// Instead, we use slog.New() to log the message. This ensures that the
-		// log level change is always logged, regardless of the current log level.
-		tmpLogger := slog.New(slog.NewTextHandler(os.Stdout, nil))
-		tmpLogger.Info("Gorouter logger -> zapcore log level updated.", slog.String("new-level", z.LogLevel().String()))
-	}
-}
-
 func main() {
 	flag.StringVar(&configFile, "c", "", "Configuration File")
 	flag.Parse()
 
 	prefix := "gorouter.stdout"
 	coreLogger := grlog.CreateLogger()
 	grlog.SetLoggingLevel("INFO")
-	coreLogger.Info("gorouter-startup-test-log", slog.String("test", "true"))
 
 	c, err := config.DefaultConfig()
 	if err != nil {
@@ -173,28 +102,17 @@ func main() {
 
 	// start the debugserver
 	if c.DebugAddr != "" {
-		logLevel, logErr := lager.LogLevelFromString(c.Logging.Level)
-		if logErr != nil {
-			logger.Error("invalid-log-level", grlog.ErrAttr(logErr))
-		}
-
 		// create a zapLevelSink that uses the logger
 		sink := &zapLevelSink{logger: logger}
-
-		// create a reconfigurable sink that can change log levels at runtime
-		reconfigurableSink := lager.NewReconfigurableSink(sink, logLevel)
-
-		// start the debugserver with the reconfigurable sink
+		// create a new debugserver with the address and the sink and run it
 		_, err = debugserver.Run(c.DebugAddr, sink)
 		if err != nil {
 			logger.Error("failed-to-start-debug-server", grlog.ErrAttr(err))
 		}
-
 		logger.Info("debugserver-started",
 			slog.String("address", c.DebugAddr),
 			slog.String("log_level", c.Logging.Level),
 			slog.String("log_format", c.Logging.Format.Timestamp),
-			slog.String("log_level_from_sink", reconfigurableSink.GetMinLevel().String()),
 		)
 	}