feat: add GetLogLevel and GetAllLogLevels

levels.go

@@ -28,3 +28,42 @@ func LevelFromString(level string) (LogLevel, error) {
 	err := lvl.Set(level)
 	return LogLevel(lvl), err
 }
+
+// LevelName returns the name of a LogLevel.
+func LevelName(level LogLevel) string {
+	return zapcore.Level(level).String()
+}
+
+// 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) {
+	if name == "*" || name == "" {
+		loggerMutex.RLock()
+		defLvl := defaultLevel
+		loggerMutex.RUnlock()
+		return LevelName(defLvl), nil
+	}
+	if lvl, ok := levels[name]; ok {
+		return 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()
+	defLvl := defaultLevel
+	loggerMutex.RUnlock()
+	result["*"] = LevelName(defLvl)
+
+	// Add all subsystem levels
+	for name, level := range levels {
+		result[name] = level.Level().String()
+	}
+
+	return result
+}

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{})
@@ -51,3 +62,131 @@ func TestLogLevel(t *testing.T) {
 	}
 	<-done
 }
+
+// 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 != LevelName(expected) {
+			t.Errorf("GetLogLevel() = %v, want %v", lvl, LevelName(expected))
+		}
+
+		// explicit "*"
+		lvl, err = GetLogLevel("*")
+		if err != nil {
+			t.Errorf(`GetLogLevel("*") returned error: %v`, err)
+		} else if lvl != LevelName(expected) {
+			t.Errorf(`GetLogLevel("*") = %v, want %v`, lvl, LevelName(expected))
+		}
+
+		// empty string
+		lvl, err = GetLogLevel("")
+		if err != nil {
+			t.Errorf(`GetLogLevel("") returned error: %v`, err)
+		} else if lvl != LevelName(expected) {
+			t.Errorf(`GetLogLevel("") = %v, want %v`, lvl, LevelName(expected))
+		}
+	}
+}
+
+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["*"] != LevelName(LevelWarn) {
+		t.Errorf("baseline GetAllLogLevels()[\"*\"] = %v; want %v", base["*"], LevelName(LevelWarn))
+	}
+
+	expected := map[string]LogLevel{
+		"test1": LevelDebug,
+		"test2": LevelInfo,
+		"test3": LevelWarn,
+	}
+	SetupLogging(Config{
+		Level:           LevelError,
+		SubsystemLevels: expected,
+		Stderr:          true,
+	})
+
+	all := GetAllLogLevels()
+
+	if all["*"] != LevelName(LevelError) {
+		t.Errorf(`GetAllLogLevels()["*"] = %v; want %v`, all["*"], LevelName(LevelError))
+	}
+	for name, want := range expected {
+		got, ok := all[name]
+		if !ok {
+			t.Errorf("missing key %q in GetAllLogLevels()", name)
+			continue
+		}
+		if got != LevelName(want) {
+			t.Errorf(`GetAllLogLevels()["%s"] = %v; want %v`, name, got, LevelName(want))
+		}
+	}
+
+	// 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 != LevelName(LevelFatal) {
+		t.Errorf(`GetAllLogLevels()["dynamic"] = %v; want %v`, lvl, LevelName(LevelFatal))
+	}
+
+	// ensure immutability
+	snapshot := GetAllLogLevels()
+	snapshot["*"] = LevelName(LevelDebug)
+	snapshot["newkey"] = LevelName(LevelInfo)
+
+	// ensure original state unchanged
+	fresh := GetAllLogLevels()
+	if fresh["*"] != LevelName(LevelError) {
+		t.Errorf(`immutable check failed: fresh["*"] = %v; want %v`, fresh["*"], LevelName(LevelError))
+	}
+	if _, exists := fresh["newkey"]; exists {
+		t.Error(`immutable check failed: "newkey" should not leak into real map`)
+	}
+}
+
+func TestLevelName(t *testing.T) {
+	testLevels := []LogLevel{LevelDebug, LevelInfo, LevelWarn, LevelError}
+	expectNames := []string{"debug", "info", "warn", "error"}
+
+	for i := range testLevels {
+		name := LevelName(testLevels[i])
+		if name != expectNames[i] {
+			t.Errorf("unexpected name for level: expected %s, got %s", expectNames[i], name)
+		}
+	}
+}

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,7 @@ func SetLogLevel(name, level string) error {
 	// wildcard, change all
 	if name == "*" {
 		SetAllLoggers(lvl)
+		defaultLevel = lvl
 		return nil
 	}