feat: add GetLogLevel and GetAllLogLevels

log_level_test.go

@@ -8,6 +8,17 @@ import (
 
 func TestLogLevel(t *testing.T) {
 	const subsystem = "log-level-test"
+
+	// Save original config and restore after test
+	originalConfig := GetConfig()
+	defer SetupLogging(originalConfig)
+
+	// Reset to a known state with error level default
+	SetupLogging(Config{
+		Level:  LevelError,
+		Stderr: true,
+	})
+
 	logger := Logger(subsystem)
 	reader := NewPipeReader()
 	done := make(chan struct{})

setup.go

@@ -86,6 +86,7 @@ var levels = make(map[string]zap.AtomicLevel)
 var primaryFormat LogFormat = ColorizedOutput
 
 // defaultLevel is the default log level
+// New loggers will be set to `defaultLevel` when created
 var defaultLevel LogLevel = LevelError
 
 // primaryCore is the primary logging core
@@ -205,6 +206,8 @@ func SetLogLevel(name, level string) error {
 	// wildcard, change all
 	if name == "*" {
 		SetAllLoggers(lvl)
+		// QUESTION: Do we want to use defaultLevel and override what new loggers will be set to?
+		defaultLevel = lvl
 		return nil
 	}
 
@@ -257,6 +260,44 @@ func GetSubsystems() []string {
 	return subs
 }
 
+// GetLogLevel returns the current log level for a given subsystem as a string.
+// Passing name="*" or name="" returns the defaultLevel.
+func GetLogLevel(name string) (string, error) {
+	key := "*"
+	if name != "" {
+		key = name
+	}
+
+	if key == "*" {
+		loggerMutex.RLock()
+		glevel := zapcore.Level(defaultLevel).String()
+		loggerMutex.RUnlock()
+		return glevel, nil
+	}
+	if lvl, ok := levels[key]; ok {
+		return zapcore.Level(LogLevel(lvl.Level())).String(), nil
+	}
+	return "", ErrNoSuchLogger
+}
+
+// GetAllLogLevels returns a map of all current log levels for all subsystems as strings.
+// The map includes a special "*" key that represents the defaultLevel.
+func GetAllLogLevels() map[string]string {
+	result := make(map[string]string, len(levels)+1)
+
+	// Add the default level with "*" key
+	loggerMutex.RLock()
+	result["*"] = zapcore.Level(defaultLevel).String()
+	loggerMutex.RUnlock()
+
+	// Add all subsystem levels
+	for name, level := range levels {
+		result[name] = zapcore.Level(LogLevel(level.Level())).String()
+	}
+
+	return result
+}
+
 func getLogger(name string) *zap.SugaredLogger {
 	loggerMutex.Lock()
 	defer loggerMutex.Unlock()

setup_test.go

@@ -258,6 +258,122 @@ func TestTeeCore(t *testing.T) {
 	log.Error("doo")
 }
 
+// Helper function to clear logger state between tests
+func clearLoggerState() {
+	clear(loggers)
+	clear(levels)
+}
+
+func TestGetDefaultLevel(t *testing.T) {
+	originalConfig := GetConfig()
+	defer SetupLogging(originalConfig)
+
+	// Clear any state from previous tests first
+	clearLoggerState()
+
+	testCases := []LogLevel{LevelDebug, LevelInfo, LevelWarn, LevelError}
+
+	for _, expected := range testCases {
+		SetupLogging(Config{Level: expected, Stderr: true})
+
+		// empty string arg
+		lvl, err := GetLogLevel("")
+		if err != nil {
+			t.Errorf("GetLogLevel() returned error: %v", err)
+		} else if lvl != zapcore.Level(expected).String() {
+			t.Errorf("GetLogLevel() = %v, want %v", lvl, zapcore.Level(expected).String())
+		}
+
+		// explicit "*"
+		lvl, err = GetLogLevel("*")
+		if err != nil {
+			t.Errorf(`GetLogLevel("*") returned error: %v`, err)
+		} else if lvl != zapcore.Level(expected).String() {
+			t.Errorf(`GetLogLevel("*") = %v, want %v`, lvl, zapcore.Level(expected).String())
+		}
+
+		// empty string
+		lvl, err = GetLogLevel("")
+		if err != nil {
+			t.Errorf(`GetLogLevel("") returned error: %v`, err)
+		} else if lvl != zapcore.Level(expected).String() {
+			t.Errorf(`GetLogLevel("") = %v, want %v`, lvl, zapcore.Level(expected).String())
+		}
+	}
+}
+
+func TestGetAllLogLevels(t *testing.T) {
+	originalConfig := GetConfig()
+	defer SetupLogging(originalConfig)
+
+	// Clear any state from previous tests first
+	clearLoggerState()
+
+	SetupLogging(Config{Level: LevelWarn, Stderr: true})
+	base := GetAllLogLevels()
+
+	if len(base) != 1 {
+		t.Errorf("baseline GetAllLogLevels() length = %d; want 1", len(base))
+	}
+	if base["*"] != zapcore.Level(LevelWarn).String() {
+		t.Errorf("baseline GetAllLogLevels()[\"*\"] = %v; want %v", base["*"], zapcore.Level(LevelWarn).String())
+	}
+
+	expected := map[string]LogLevel{
+		"test1": LevelDebug,
+		"test2": LevelInfo,
+		"test3": LevelWarn,
+	}
+	SetupLogging(Config{
+		Level:           LevelError,
+		SubsystemLevels: expected,
+		Stderr:          true,
+	})
+
+	all := GetAllLogLevels()
+
+	if all["*"] != zapcore.Level(LevelError).String() {
+		t.Errorf(`GetAllLogLevels()["*"] = %v; want %v`, all["*"], zapcore.Level(LevelError).String())
+	}
+	for name, want := range expected {
+		got, ok := all[name]
+		if !ok {
+			t.Errorf("missing key %q in GetAllLogLevels()", name)
+			continue
+		}
+		if got != zapcore.Level(want).String() {
+			t.Errorf(`GetAllLogLevels()["%s"] = %v; want %v`, name, got, zapcore.Level(want).String())
+		}
+	}
+
+	// dynamic logger test
+	_ = Logger("dynamic")
+	if err := SetLogLevel("dynamic", "fatal"); err != nil {
+		t.Fatalf("SetLogLevel(dynamic) failed: %v", err)
+	}
+
+	all = GetAllLogLevels()
+	if lvl, ok := all["dynamic"]; !ok {
+		t.Error(`missing "dynamic" key after creation`)
+	} else if lvl != zapcore.Level(LevelFatal).String() {
+		t.Errorf(`GetAllLogLevels()["dynamic"] = %v; want %v`, lvl, zapcore.Level(LevelFatal).String())
+	}
+
+	// ensure immutability
+	snapshot := GetAllLogLevels()
+	snapshot["*"] = zapcore.Level(LevelDebug).String()
+	snapshot["newkey"] = zapcore.Level(LevelInfo).String()
+
+	// ensure original state unchanged
+	fresh := GetAllLogLevels()
+	if fresh["*"] != zapcore.Level(LevelError).String() {
+		t.Errorf(`immutable check failed: fresh["*"] = %v; want %v`, fresh["*"], zapcore.Level(LevelError).String())
+	}
+	if _, exists := fresh["newkey"]; exists {
+		t.Error(`immutable check failed: "newkey" should not leak into real map`)
+	}
+}
+
 func TestLogToStderrAndStdout(t *testing.T) {
 	r, w, err := os.Pipe()
 	if err != nil {