Refactor Logger (#13294)

Refactor Logger to make a logger interface and make it possible to
wrap loggers for specific purposes.

Co-authored-by: techknowlogick <techknowlogick@gitea.io>

modules/log/logger.go

@@ -4,149 +4,140 @@
 
 package log
 
-import (
-	"fmt"
-	"os"
-	"runtime"
-	"strings"
-	"time"
-)
+import "os"
 
-// Logger is default logger in the Gitea application.
-// it can contain several providers and log message into all providers.
-type Logger struct {
-	*MultiChannelledLog
-	bufferLength int64
+// Logger is the basic interface for logging
+type Logger interface {
+	LevelLogger
+	Trace(format string, v ...interface{})
+	IsTrace() bool
+	Debug(format string, v ...interface{})
+	IsDebug() bool
+	Info(format string, v ...interface{})
+	IsInfo() bool
+	Warn(format string, v ...interface{})
+	IsWarn() bool
+	Error(format string, v ...interface{})
+	ErrorWithSkip(skip int, format string, v ...interface{})
+	IsError() bool
+	Critical(format string, v ...interface{})
+	CriticalWithSkip(skip int, format string, v ...interface{})
+	IsCritical() bool
+	Fatal(format string, v ...interface{})
+	FatalWithSkip(skip int, format string, v ...interface{})
+	IsFatal() bool
 }
 
-// newLogger initializes and returns a new logger.
-func newLogger(name string, buffer int64) *Logger {
-	l := &Logger{
-		MultiChannelledLog: NewMultiChannelledLog(name, buffer),
-		bufferLength:       buffer,
-	}
-	return l
+// LevelLogger is the simplest logging interface
+type LevelLogger interface {
+	Flush()
+	Close()
+	GetLevel() Level
+	Log(skip int, level Level, format string, v ...interface{}) error
 }
 
-// SetLogger sets new logger instance with given logger provider and config.
-func (l *Logger) SetLogger(name, provider, config string) error {
-	eventLogger, err := NewChannelledLog(name, provider, config, l.bufferLength)
-	if err != nil {
-		return fmt.Errorf("Failed to create sublogger (%s): %v", name, err)
-	}
-
-	l.MultiChannelledLog.DelLogger(name)
-
-	err = l.MultiChannelledLog.AddLogger(eventLogger)
-	if err != nil {
-		if IsErrDuplicateName(err) {
-			return fmt.Errorf("Duplicate named sublogger %s %v", name, l.MultiChannelledLog.GetEventLoggerNames())
-		}
-		return fmt.Errorf("Failed to add sublogger (%s): %v", name, err)
-	}
-
-	return nil
+// SettableLogger is the interface of loggers which have subloggers
+type SettableLogger interface {
+	SetLogger(name, provider, config string) error
+	DelLogger(name string) (bool, error)
 }
 
-// DelLogger deletes a sublogger from this logger.
-func (l *Logger) DelLogger(name string) (bool, error) {
-	return l.MultiChannelledLog.DelLogger(name), nil
+// StacktraceLogger is a logger that can log stacktraces
+type StacktraceLogger interface {
+	GetStacktraceLevel() Level
 }
 
-// Log msg at the provided level with the provided caller defined by skip (0 being the function that calls this function)
-func (l *Logger) Log(skip int, level Level, format string, v ...interface{}) error {
-	if l.GetLevel() > level {
-		return nil
-	}
-	caller := "?()"
-	pc, filename, line, ok := runtime.Caller(skip + 1)
-	if ok {
-		// Get caller function name.
-		fn := runtime.FuncForPC(pc)
-		if fn != nil {
-			caller = fn.Name() + "()"
-		}
-	}
-	msg := format
-	if len(v) > 0 {
-		msg = ColorSprintf(format, v...)
-	}
-	stack := ""
-	if l.GetStacktraceLevel() <= level {
-		stack = Stack(skip + 1)
-	}
-	return l.SendLog(level, caller, strings.TrimPrefix(filename, prefix), line, msg, stack)
-}
-
-// SendLog sends a log event at the provided level with the information given
-func (l *Logger) SendLog(level Level, caller, filename string, line int, msg string, stack string) error {
-	if l.GetLevel() > level {
-		return nil
-	}
-	event := &Event{
-		level:      level,
-		caller:     caller,
-		filename:   filename,
-		line:       line,
-		msg:        msg,
-		time:       time.Now(),
-		stacktrace: stack,
-	}
-	l.LogEvent(event)
-	return nil
+// LevelLoggerLogger wraps a LevelLogger as a Logger
+type LevelLoggerLogger struct {
+	LevelLogger
 }
 
 // Trace records trace log
-func (l *Logger) Trace(format string, v ...interface{}) {
+func (l *LevelLoggerLogger) Trace(format string, v ...interface{}) {
 	l.Log(1, TRACE, format, v...)
 }
 
+// IsTrace returns true if the logger is TRACE
+func (l *LevelLoggerLogger) IsTrace() bool {
+	return l.GetLevel() <= TRACE
+}
+
 // Debug records debug log
-func (l *Logger) Debug(format string, v ...interface{}) {
+func (l *LevelLoggerLogger) Debug(format string, v ...interface{}) {
 	l.Log(1, DEBUG, format, v...)
 
 }
 
+// IsDebug returns true if the logger is DEBUG
+func (l *LevelLoggerLogger) IsDebug() bool {
+	return l.GetLevel() <= DEBUG
+}
+
 // Info records information log
-func (l *Logger) Info(format string, v ...interface{}) {
+func (l *LevelLoggerLogger) Info(format string, v ...interface{}) {
 	l.Log(1, INFO, format, v...)
 }
 
+// IsInfo returns true if the logger is INFO
+func (l *LevelLoggerLogger) IsInfo() bool {
+	return l.GetLevel() <= INFO
+}
+
 // Warn records warning log
-func (l *Logger) Warn(format string, v ...interface{}) {
+func (l *LevelLoggerLogger) Warn(format string, v ...interface{}) {
 	l.Log(1, WARN, format, v...)
 }
 
+// IsWarn returns true if the logger is WARN
+func (l *LevelLoggerLogger) IsWarn() bool {
+	return l.GetLevel() <= WARN
+}
+
 // Error records error log
-func (l *Logger) Error(format string, v ...interface{}) {
+func (l *LevelLoggerLogger) Error(format string, v ...interface{}) {
 	l.Log(1, ERROR, format, v...)
 }
 
 // ErrorWithSkip records error log from "skip" calls back from this function
-func (l *Logger) ErrorWithSkip(skip int, format string, v ...interface{}) {
+func (l *LevelLoggerLogger) ErrorWithSkip(skip int, format string, v ...interface{}) {
 	l.Log(skip+1, ERROR, format, v...)
 }
 
+// IsError returns true if the logger is ERROR
+func (l *LevelLoggerLogger) IsError() bool {
+	return l.GetLevel() <= ERROR
+}
+
 // Critical records critical log
-func (l *Logger) Critical(format string, v ...interface{}) {
+func (l *LevelLoggerLogger) Critical(format string, v ...interface{}) {
 	l.Log(1, CRITICAL, format, v...)
 }
 
 // CriticalWithSkip records critical log from "skip" calls back from this function
-func (l *Logger) CriticalWithSkip(skip int, format string, v ...interface{}) {
+func (l *LevelLoggerLogger) CriticalWithSkip(skip int, format string, v ...interface{}) {
 	l.Log(skip+1, CRITICAL, format, v...)
 }
 
+// IsCritical returns true if the logger is CRITICAL
+func (l *LevelLoggerLogger) IsCritical() bool {
+	return l.GetLevel() <= CRITICAL
+}
+
 // Fatal records fatal log and exit the process
-func (l *Logger) Fatal(format string, v ...interface{}) {
+func (l *LevelLoggerLogger) Fatal(format string, v ...interface{}) {
 	l.Log(1, FATAL, format, v...)
 	l.Close()
 	os.Exit(1)
 }
 
 // FatalWithSkip records fatal log from "skip" calls back from this function and exits the process
-func (l *Logger) FatalWithSkip(skip int, format string, v ...interface{}) {
+func (l *LevelLoggerLogger) FatalWithSkip(skip int, format string, v ...interface{}) {
 	l.Log(skip+1, FATAL, format, v...)
 	l.Close()
 	os.Exit(1)
 }
+
+// IsFatal returns true if the logger is FATAL
+func (l *LevelLoggerLogger) IsFatal() bool {
+	return l.GetLevel() <= FATAL
+}