Great question—you’re right that the official golang/glog library doesn’t expose built-in APIs to modify logging thresholds or verbosity levels at runtime. All default configuration happens at startup via flags, which requires a restart to change. But don’t worry, we can work around this by tapping into glog’s internal state (with some caveats) and adding our own control mechanisms.

Here’s a practical approach to achieve runtime updates without recompiling or restarting your service:

Key Background #

Glog stores its configuration in unexported global variables (like stderrThreshold, vLevel, and vmodule). While these aren’t meant to be modified directly, we can safely adjust them with proper concurrency guards, since glog doesn’t handle synchronization for these variables on its own.

Step-by-Step Implementation #

1. Add Concurrency Safety #

First, define a mutex to protect access to glog’s internal config variables—this prevents race conditions when multiple goroutines try to modify or read the settings at the same time:

import "sync"

var configMu sync.RWMutex

2. Build Helper Functions to Modify Settings #

Create wrapper functions to update the specific config values you care about. These functions will handle locking and type conversion:

Update stderrThreshold

import "github.com/golang/glog"

// SetStderrThreshold updates the stderr logging threshold at runtime
func SetStderrThreshold(levelStr string) error {
	targetLevel, err := glog.LevelFromString(levelStr)
	if err != nil {
		return err
	}

	configMu.Lock()
	defer configMu.Unlock()
	glog.stderrThreshold = targetLevel
	return nil
}

Update Verbosity (V Level)

import "strconv"

// SetVLevel updates the global verbosity level at runtime
func SetVLevel(level int) {
	configMu.Lock()
	defer configMu.Unlock()
	glog.vLevel = level
}

Update vmodule (Optional)

If you need to adjust per-module verbosity, you can add a function to refresh the vmodule pattern:

// SetVModule updates the vmodule filter pattern at runtime
func SetVModule(pattern string) error {
	configMu.Lock()
	defer configMu.Unlock()
	glog.vmodule = pattern
	// Re-initialize vmodule parsing to apply the new pattern
	return glog.initVmodule()
}

3. Expose a Control Interface #

Add a way to trigger these updates without restarting the service. A simple HTTP endpoint is easy to implement and use:

import (
	"log"
	"net/http"
)

func main() {
	defer glog.Flush()

	// Endpoint to update stderr threshold
	http.HandleFunc("/log/set-stderr-threshold", func(w http.ResponseWriter, r *http.Request) {
		level := r.URL.Query().Get("level")
		if level == "" {
			http.Error(w, "Missing 'level' parameter (e.g., INFO, WARNING, ERROR)", http.StatusBadRequest)
			return
		}

		if err := SetStderrThreshold(level); err != nil {
			http.Error(w, "Invalid level: "+err.Error(), http.StatusBadRequest)
			return
		}

		w.Write([]byte("Successfully updated stderr threshold to: " + level))
	})

	// Endpoint to update verbosity level
	http.HandleFunc("/log/set-v-level", func(w http.ResponseWriter, r *http.Request) {
		levelStr := r.URL.Query().Get("level")
		if levelStr == "" {
			http.Error(w, "Missing 'level' parameter (e.g., 2, 3)", http.StatusBadRequest)
			return
		}

		level, err := strconv.Atoi(levelStr)
		if err != nil {
			http.Error(w, "Invalid level number: "+err.Error(), http.StatusBadRequest)
			return
		}

		SetVLevel(level)
		w.Write([]byte("Successfully updated verbosity level to: " + levelStr))
	})

	log.Fatal(http.ListenAndServe(":8080", nil))
}

4. Test the Runtime Updates #

Use curl or any HTTP client to send requests to your endpoints:

# Set stderr threshold to WARNING
curl http://localhost:8080/log/set-stderr-threshold?level=WARNING

# Set verbosity level to 3
curl http://localhost:8080/log/set-v-level?level=3

Important Caveats #

• Dependency on Unexported Variables: This approach relies on glog’s internal unexported variables, which could change between versions. Always test this when upgrading glog.
• Concurrency Safety: The mutex is critical here—without it, concurrent modifications could lead to race conditions or unexpected behavior.
• Alternative Libraries: If long-term maintainability is a concern, consider switching to logging libraries with native runtime configuration support (like Zap or Logrus). But if you’re stuck with glog, this method works reliably.

内容的提问来源于stack exchange，提问作者hsiaoairplane