build: separate sublogger and rotator pipe management

These are two separate concerns. So this commit splits them up and just
passes a LogWriter from the one to the other. This will become cleaner
in an upcoming commit where the Rotator will implement io.Writer and
there will no longer be a need for LogWriter.

build/sub_logger.go

@@ -2,11 +2,149 @@ package build
 
 import (
 	"fmt"
+	"io"
+	"sort"
 	"strings"
+	"sync"
 
 	"github.com/btcsuite/btclog"
 )
 
+// SubLogCreator can be used to create a new logger for a particular subsystem.
+type SubLogCreator interface {
+	// Logger returns a new logger for a particular subsytem.
+	Logger(subsystemTag string) btclog.Logger
+}
+
+// SubLoggerManager manages a set of subsystem loggers. Level updates will be
+// applied to all the loggers managed by the manager.
+type SubLoggerManager struct {
+	genLogger SubLogCreator
+
+	loggers SubLoggers
+	mu      sync.Mutex
+}
+
+// A compile time check to ensure SubLoggerManager implements the
+// LeveledSubLogger interface.
+var _ LeveledSubLogger = (*SubLoggerManager)(nil)
+
+// NewSubLoggerManager constructs a new SubLoggerManager.
+func NewSubLoggerManager(w io.Writer) *SubLoggerManager {
+	return &SubLoggerManager{
+		loggers:   SubLoggers{},
+		genLogger: btclog.NewBackend(w),
+	}
+}
+
+// GenSubLogger creates a new sub-logger and adds it to the set managed by the
+// SubLoggerManager. A shutdown callback function is provided to be able to shut
+// down in case of a critical error.
+func (r *SubLoggerManager) GenSubLogger(subsystem string,
+	shutdown func()) btclog.Logger {
+
+	// Create a new logger with the given subsystem tag.
+	logger := r.genLogger.Logger(subsystem)
+
+	// Wrap the new logger in a Shutdown logger so that the shutdown
+	// call back is called if a critical log is ever written via this new
+	// logger.
+	l := NewShutdownLogger(logger, shutdown)
+
+	r.RegisterSubLogger(subsystem, l)
+
+	return l
+}
+
+// RegisterSubLogger registers the given logger under the given subsystem name.
+func (r *SubLoggerManager) RegisterSubLogger(subsystem string,
+	logger btclog.Logger) {
+
+	// Add the new logger to the set of loggers managed by the manager.
+	r.mu.Lock()
+	r.loggers[subsystem] = logger
+	r.mu.Unlock()
+}
+
+// SubLoggers returns all currently registered subsystem loggers for this log
+// writer.
+//
+// NOTE: This is part of the LeveledSubLogger interface.
+func (r *SubLoggerManager) SubLoggers() SubLoggers {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	return r.loggers
+}
+
+// SupportedSubsystems returns a sorted string slice of all keys in the
+// subsystems map, corresponding to the names of the subsystems.
+//
+// NOTE: This is part of the LeveledSubLogger interface.
+func (r *SubLoggerManager) SupportedSubsystems() []string {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	// Convert the subsystemLoggers map keys to a string slice.
+	subsystems := make([]string, 0, len(r.loggers))
+	for subsysID := range r.loggers {
+		subsystems = append(subsystems, subsysID)
+	}
+
+	// Sort the subsystems for stable display.
+	sort.Strings(subsystems)
+
+	return subsystems
+}
+
+// SetLogLevel sets the logging level for provided subsystem. Invalid
+// subsystems are ignored. Uninitialized subsystems are dynamically created as
+// needed.
+//
+// NOTE: This is part of the LeveledSubLogger interface.
+func (r *SubLoggerManager) SetLogLevel(subsystemID string, logLevel string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	r.setLogLevelUnsafe(subsystemID, logLevel)
+}
+
+// setLogLevelUnsafe sets the logging level for provided subsystem. Invalid
+// subsystems are ignored. Uninitialized subsystems are dynamically created as
+// needed.
+//
+// NOTE: the SubLoggerManager mutex must be held before calling this method.
+func (r *SubLoggerManager) setLogLevelUnsafe(subsystemID string,
+	logLevel string) {
+
+	// Ignore invalid subsystems.
+	logger, ok := r.loggers[subsystemID]
+	if !ok {
+		return
+	}
+
+	// Defaults to info if the log level is invalid.
+	level, _ := btclog.LevelFromString(logLevel)
+
+	logger.SetLevel(level)
+}
+
+// SetLogLevels sets the log level for all subsystem loggers to the passed
+// level. It also dynamically creates the subsystem loggers as needed, so it
+// can be used to initialize the logging system.
+//
+// NOTE: This is part of the LeveledSubLogger interface.
+func (r *SubLoggerManager) SetLogLevels(logLevel string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	// Configure all sub-systems with the new logging level. Dynamically
+	// create loggers as needed.
+	for subsystemID := range r.loggers {
+		r.setLogLevelUnsafe(subsystemID, logLevel)
+	}
+}
+
 // SubLoggers is a type that holds a map of subsystem loggers keyed by their
 // subsystem name.
 type SubLoggers map[string]btclog.Logger