initial commit for TNZ-23119

Author: navinms711

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

@@ -8,10 +8,12 @@ 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"
@@ -50,13 +52,70 @@ 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 (s *zapLevelSink) Log(lf lager.LogFormat) {
+	s.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 (s *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:
+		zapLevel = zapcore.ErrorLevel
+	default:
+		zapLevel = zapcore.InfoLevel
+	}
+
+	grlog.SetLoggingLevel(zapLevel.String())
+
+	if s.logger != nil {
+		s.logger.Info("zapcore log level updated", slog.String("new-level", zapLevel.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 {
@@ -101,12 +160,31 @@ func main() {
 		runtime.GOMAXPROCS(c.GoMaxProcs)
 	}
 
+	// start the debugserver
 	if c.DebugAddr != "" {
-		reconfigurableSink := lager.ReconfigurableSink{}
-		_, err = debugserver.Run(c.DebugAddr, &reconfigurableSink)
+		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
+		_, 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()),
+		)
 	}
 
 	logger.Info("setting-up-nats-connection")

src/code.cloudfoundry.org/gorouter/logger/logger.go

@@ -98,6 +98,14 @@ func SetLoggingLevel(level string) {
 	conf.level.SetLevel(zapLevel)
 }
 
+/*
+GetLoggingLevel returns the current logging level.
+*/
+func GetLoggingLevel() string {
+	return conf.level.String()
+}
+
+// Logger is an interface that can be used to mock the logger in tests.
 type Logger interface {
 }