update

log/log.go

@@ -0,0 +1,351 @@
+package log
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"iter"
+	"net/http"
+	"os"
+	"runtime"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+type Level uint32
+
+type LevelFunc = func(ctx interface{}, msg interface{}, keyValuePairs ...interface{})
+
+var redacted = &Hook{
+	AcceptedLevels: logrus.AllLevels,
+	RedactionList: []string{
+		// Keys from the config
+		"(ApiKey:\")[\\w]*",
+		"(Secret:\")[\\w]*",
+		"(Spotify.*ID:\")[\\w]*",
+		"(PasswordEncryptionKey:[\\s]*\")[^\"]*",
+		"(UserHeader:[\\s]*\")[^\"]*",
+		"(TrustedSources:[\\s]*\")[^\"]*",
+		"(MetricsPath:[\\s]*\")[^\"]*",
+		"(DevAutoCreateAdminPassword:[\\s]*\")[^\"]*",
+		"(DevAutoLoginUsername:[\\s]*\")[^\"]*",
+
+		// UI appConfig
+		"(subsonicToken:)[\\w]+(\\s)",
+		"(subsonicSalt:)[\\w]+(\\s)",
+		"(token:)[^\\s]+",
+
+		// Subsonic query params
+		"([^\\w]t=)[\\w]+",
+		"([^\\w]s=)[^&]+",
+		"([^\\w]p=)[^&]+",
+		"([^\\w]jwt=)[^&]+",
+
+		// External services query params
+		"([^\\w]api_key=)[\\w]+",
+	},
+}
+
+const (
+	LevelFatal = Level(logrus.FatalLevel)
+	LevelError = Level(logrus.ErrorLevel)
+	LevelWarn  = Level(logrus.WarnLevel)
+	LevelInfo  = Level(logrus.InfoLevel)
+	LevelDebug = Level(logrus.DebugLevel)
+	LevelTrace = Level(logrus.TraceLevel)
+)
+
+type contextKey string
+
+const loggerCtxKey = contextKey("logger")
+
+type levelPath struct {
+	path  string
+	level Level
+}
+
+var (
+	currentLevel  Level
+	loggerMu      sync.RWMutex
+	defaultLogger = logrus.New()
+	logSourceLine = false
+	rootPath      string
+	logLevels     []levelPath
+)
+
+// SetLevel sets the global log level used by the simple logger.
+func SetLevel(l Level) {
+	loggerMu.Lock()
+	currentLevel = l
+	defaultLogger.Level = logrus.TraceLevel
+	loggerMu.Unlock()
+	logrus.SetLevel(logrus.Level(l))
+}
+
+func SetLevelString(l string) {
+	level := levelFromString(l)
+	SetLevel(level)
+}
+
+func levelFromString(l string) Level {
+	envLevel := strings.ToLower(l)
+	var level Level
+	switch envLevel {
+	case "fatal":
+		level = LevelFatal
+	case "error":
+		level = LevelError
+	case "warn":
+		level = LevelWarn
+	case "debug":
+		level = LevelDebug
+	case "trace":
+		level = LevelTrace
+	default:
+		level = LevelInfo
+	}
+	return level
+}
+
+// SetLogLevels sets the log levels for specific paths in the codebase.
+func SetLogLevels(levels map[string]string) {
+	loggerMu.Lock()
+	defer loggerMu.Unlock()
+	logLevels = nil
+	for k, v := range levels {
+		logLevels = append(logLevels, levelPath{path: k, level: levelFromString(v)})
+	}
+	sort.Slice(logLevels, func(i, j int) bool {
+		return logLevels[i].path > logLevels[j].path
+	})
+}
+
+func SetLogSourceLine(enabled bool) {
+	logSourceLine = enabled
+}
+
+func SetRedacting(enabled bool) {
+	if enabled {
+		loggerMu.Lock()
+		defer loggerMu.Unlock()
+		defaultLogger.AddHook(redacted)
+	}
+}
+
+func SetOutput(w io.Writer) {
+	if runtime.GOOS == "windows" {
+		w = CRLFWriter(w)
+	}
+	loggerMu.Lock()
+	defer loggerMu.Unlock()
+	defaultLogger.SetOutput(w)
+}
+
+// Redact applies redaction to a single string
+func Redact(msg string) string {
+	r, _ := redacted.redact(msg)
+	return r
+}
+
+func NewContext(ctx context.Context, keyValuePairs ...interface{}) context.Context {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+
+	logger, ok := ctx.Value(loggerCtxKey).(*logrus.Entry)
+	if !ok {
+		logger = createNewLogger()
+	}
+	logger = addFields(logger, keyValuePairs)
+	ctx = context.WithValue(ctx, loggerCtxKey, logger)
+
+	return ctx
+}
+
+func SetDefaultLogger(l *logrus.Logger) {
+	loggerMu.Lock()
+	defer loggerMu.Unlock()
+	defaultLogger = l
+}
+
+func CurrentLevel() Level {
+	loggerMu.RLock()
+	defer loggerMu.RUnlock()
+	return currentLevel
+}
+
+// IsGreaterOrEqualTo returns true if the caller's current log level is equal or greater than the provided level.
+func IsGreaterOrEqualTo(level Level) bool {
+	return shouldLog(level, 2)
+}
+
+func Fatal(args ...interface{}) {
+	log(LevelFatal, args...)
+	os.Exit(1)
+}
+
+func Error(args ...interface{}) {
+	log(LevelError, args...)
+}
+
+func Warn(args ...interface{}) {
+	log(LevelWarn, args...)
+}
+
+func Info(args ...interface{}) {
+	log(LevelInfo, args...)
+}
+
+func Debug(args ...interface{}) {
+	log(LevelDebug, args...)
+}
+
+func Trace(args ...interface{}) {
+	log(LevelTrace, args...)
+}
+
+func log(level Level, args ...interface{}) {
+	if !shouldLog(level, 3) {
+		return
+	}
+	logger, msg := parseArgs(args)
+	logger.Log(logrus.Level(level), msg)
+}
+
+func Writer() io.Writer {
+	loggerMu.RLock()
+	defer loggerMu.RUnlock()
+	return defaultLogger.Writer()
+}
+
+func shouldLog(requiredLevel Level, skip int) bool {
+	loggerMu.RLock()
+	level := currentLevel
+	levels := logLevels
+	loggerMu.RUnlock()
+
+	if level >= requiredLevel {
+		return true
+	}
+	if len(levels) == 0 {
+		return false
+	}
+
+	_, file, _, ok := runtime.Caller(skip)
+	if !ok {
+		return false
+	}
+
+	file = strings.TrimPrefix(file, rootPath)
+	for _, lp := range levels {
+		if strings.HasPrefix(file, lp.path) {
+			return lp.level >= requiredLevel
+		}
+	}
+	return false
+}
+
+func parseArgs(args []interface{}) (*logrus.Entry, string) {
+	var l *logrus.Entry
+	var err error
+	if args[0] == nil {
+		l = createNewLogger()
+		args = args[1:]
+	} else {
+		l, err = extractLogger(args[0])
+		if err != nil {
+			l = createNewLogger()
+		} else {
+			args = args[1:]
+		}
+	}
+	if len(args) > 1 {
+		kvPairs := args[1:]
+		l = addFields(l, kvPairs)
+	}
+	if logSourceLine {
+		_, file, line, ok := runtime.Caller(3)
+		if !ok {
+			file = "???"
+			line = 0
+		}
+		//_, filename := path.Split(file)
+		//l = l.WithField("filename", filename).WithField("line", line)
+		l = l.WithField(" source", fmt.Sprintf("file://%s:%d", file, line))
+	}
+
+	switch msg := args[0].(type) {
+	case error:
+		return l, msg.Error()
+	case string:
+		return l, msg
+	}
+
+	return l, ""
+}
+
+func addFields(logger *logrus.Entry, keyValuePairs []interface{}) *logrus.Entry {
+	for i := 0; i < len(keyValuePairs); i += 2 {
+		switch name := keyValuePairs[i].(type) {
+		case error:
+			logger = logger.WithField("error", name.Error())
+		case string:
+			if i+1 >= len(keyValuePairs) {
+				logger = logger.WithField(name, "!!!!Invalid number of arguments in log call!!!!")
+			} else {
+				switch v := keyValuePairs[i+1].(type) {
+				case time.Duration:
+					logger = logger.WithField(name, ShortDur(v))
+				case fmt.Stringer:
+					logger = logger.WithField(name, StringerValue(v))
+				case iter.Seq[string]:
+					logger = logger.WithField(name, formatSeq(v))
+				case []string:
+					logger = logger.WithField(name, formatSlice(v))
+				default:
+					logger = logger.WithField(name, v)
+				}
+			}
+		}
+	}
+	return logger
+}
+
+func extractLogger(ctx interface{}) (*logrus.Entry, error) {
+	switch ctx := ctx.(type) {
+	case *logrus.Entry:
+		return ctx, nil
+	case context.Context:
+		logger := ctx.Value(loggerCtxKey)
+		if logger != nil {
+			return logger.(*logrus.Entry), nil
+		}
+		return extractLogger(NewContext(ctx))
+	case *http.Request:
+		return extractLogger(ctx.Context())
+	}
+	return nil, errors.New("no logger found")
+}
+
+func createNewLogger() *logrus.Entry {
+	//logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true, DisableTimestamp: false, FullTimestamp: true})
+	//l.Formatter = &logrus.TextFormatter{ForceColors: true, DisableTimestamp: false, FullTimestamp: true}
+	loggerMu.RLock()
+	defer loggerMu.RUnlock()
+	logger := logrus.NewEntry(defaultLogger)
+	return logger
+}
+
+func init() {
+	defaultLogger.Level = logrus.TraceLevel
+	_, file, _, ok := runtime.Caller(0)
+	if !ok {
+		return
+	}
+	rootPath = strings.TrimSuffix(file, "log/log.go")
+}