Harden UDP audio transport and logging

log/log.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"os"
 	"sync"
+	"sync/atomic"
 	"time"
 )
 
@@ -40,10 +41,16 @@ type Logger interface {
 	Log(level Level, format string, args ...interface{})
 }
 
-var (
-	mu     sync.Mutex
-	logger Logger = &nopLogger{}
-)
+type loggerState struct {
+	logger Logger
+	level  Level
+}
+
+var logger atomic.Pointer[loggerState]
+
+func init() {
+	logger.Store(&loggerState{logger: &nopLogger{}, level: LevelError + 1})
+}
 
 type nopLogger struct{}
 
@@ -51,21 +58,28 @@ func (n *nopLogger) Log(level Level, format string, args ...interface{}) {}
 
 // SetLogger sets the destination for log messages. Pass nil to disable.
 func SetLogger(l Logger) {
-	mu.Lock()
-	defer mu.Unlock()
+	state := &loggerState{logger: l, level: LevelDebug}
 	if l == nil {
-		logger = &nopLogger{}
-	} else {
-		logger = l
+		state.logger = &nopLogger{}
+		state.level = LevelError + 1
+	} else if writer, ok := l.(*WriterLogger); ok {
+		state.level = writer.level
 	}
+	logger.Store(state)
+}
+
+// Enabled reports whether messages at level will be emitted. Callers should
+// use it to avoid computing expensive log arguments when logging is disabled.
+func Enabled(level Level) bool {
+	return level >= logger.Load().level
 }
 
 // WriterLogger is a simple Logger that writes to an io.Writer.
 type WriterLogger struct {
-	mu     sync.Mutex
-	w      io.Writer
-	level  Level
-	buf    []byte
+	mu    sync.Mutex
+	w     io.Writer
+	level Level
+	buf   []byte
 }
 
 // NewWriterLogger creates a logger that writes to w, filtering below level.
@@ -88,29 +102,29 @@ func (wl *WriterLogger) Log(level Level, format string, args ...interface{}) {
 }
 
 func Debug(format string, args ...interface{}) {
-	mu.Lock()
-	l := logger
-	mu.Unlock()
-	l.Log(LevelDebug, format, args...)
+	state := logger.Load()
+	if LevelDebug >= state.level {
+		state.logger.Log(LevelDebug, format, args...)
+	}
 }
 
 func Info(format string, args ...interface{}) {
-	mu.Lock()
-	l := logger
-	mu.Unlock()
-	l.Log(LevelInfo, format, args...)
+	state := logger.Load()
+	if LevelInfo >= state.level {
+		state.logger.Log(LevelInfo, format, args...)
+	}
 }
 
 func Warn(format string, args ...interface{}) {
-	mu.Lock()
-	l := logger
-	mu.Unlock()
-	l.Log(LevelWarn, format, args...)
+	state := logger.Load()
+	if LevelWarn >= state.level {
+		state.logger.Log(LevelWarn, format, args...)
+	}
 }
 
 func Error(format string, args ...interface{}) {
-	mu.Lock()
-	l := logger
-	mu.Unlock()
-	l.Log(LevelError, format, args...)
+	state := logger.Load()
+	if LevelError >= state.level {
+		state.logger.Log(LevelError, format, args...)
+	}
 }