183 lines
3.4 KiB
Go
183 lines
3.4 KiB
Go
package logging
|
|
|
|
import (
|
|
"fmt"
|
|
"sync"
|
|
)
|
|
|
|
var (
|
|
logger *Logger
|
|
once sync.Once
|
|
)
|
|
|
|
type Logger struct {
|
|
base *BaseLogger
|
|
errorLogger *ErrorLogger
|
|
warnLogger *WarnLogger
|
|
infoLogger *InfoLogger
|
|
debugLogger *DebugLogger
|
|
}
|
|
|
|
func Initialize() (*Logger, error) {
|
|
var err error
|
|
once.Do(func() {
|
|
logger, err = newLogger()
|
|
})
|
|
return logger, err
|
|
}
|
|
|
|
func newLogger() (*Logger, error) {
|
|
baseLogger, err := InitializeBase("log")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
logger := &Logger{
|
|
base: baseLogger,
|
|
errorLogger: GetErrorLogger(),
|
|
warnLogger: GetWarnLogger(),
|
|
infoLogger: GetInfoLogger(),
|
|
debugLogger: GetDebugLogger(),
|
|
}
|
|
|
|
return logger, nil
|
|
}
|
|
|
|
func (l *Logger) Close() error {
|
|
if l.base != nil {
|
|
return l.base.Close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (l *Logger) log(level, format string, v ...interface{}) {
|
|
if l.base != nil {
|
|
l.base.LogWithCaller(LogLevel(level), 3, format, v...)
|
|
}
|
|
}
|
|
|
|
func (l *Logger) Info(format string, v ...interface{}) {
|
|
if l.infoLogger != nil {
|
|
l.infoLogger.Log(format, v...)
|
|
}
|
|
}
|
|
|
|
func (l *Logger) Error(format string, v ...interface{}) {
|
|
if l.errorLogger != nil {
|
|
l.errorLogger.Log(format, v...)
|
|
}
|
|
}
|
|
|
|
func (l *Logger) Warn(format string, v ...interface{}) {
|
|
if l.warnLogger != nil {
|
|
l.warnLogger.Log(format, v...)
|
|
}
|
|
}
|
|
|
|
func (l *Logger) Debug(format string, v ...interface{}) {
|
|
if l.debugLogger != nil {
|
|
l.debugLogger.Log(format, v...)
|
|
}
|
|
}
|
|
|
|
func (l *Logger) Panic(format string) {
|
|
if l.errorLogger != nil {
|
|
l.errorLogger.LogFatal(format)
|
|
}
|
|
}
|
|
|
|
func LegacyInfo(format string, v ...interface{}) {
|
|
if logger != nil {
|
|
logger.Info(format, v...)
|
|
} else {
|
|
GetInfoLogger().Log(format, v...)
|
|
}
|
|
}
|
|
|
|
func LegacyError(format string, v ...interface{}) {
|
|
if logger != nil {
|
|
logger.Error(format, v...)
|
|
} else {
|
|
GetErrorLogger().Log(format, v...)
|
|
}
|
|
}
|
|
|
|
func LegacyWarn(format string, v ...interface{}) {
|
|
if logger != nil {
|
|
logger.Warn(format, v...)
|
|
} else {
|
|
GetWarnLogger().Log(format, v...)
|
|
}
|
|
}
|
|
|
|
func LegacyDebug(format string, v ...interface{}) {
|
|
if logger != nil {
|
|
logger.Debug(format, v...)
|
|
} else {
|
|
GetDebugLogger().Log(format, v...)
|
|
}
|
|
}
|
|
|
|
func Panic(format string) {
|
|
if logger != nil {
|
|
logger.Panic(format)
|
|
} else {
|
|
GetErrorLogger().LogFatal(format)
|
|
}
|
|
}
|
|
|
|
func LogStartup(component string, message string) {
|
|
GetInfoLogger().LogStartup(component, message)
|
|
}
|
|
|
|
func LogShutdown(component string, message string) {
|
|
GetInfoLogger().LogShutdown(component, message)
|
|
}
|
|
|
|
func LogOperation(operation string, details string) {
|
|
GetInfoLogger().LogOperation(operation, details)
|
|
}
|
|
|
|
func LogRequest(method string, path string, userAgent string) {
|
|
GetInfoLogger().LogRequest(method, path, userAgent)
|
|
}
|
|
|
|
func LogResponse(method string, path string, statusCode int, duration string) {
|
|
GetInfoLogger().LogResponse(method, path, statusCode, duration)
|
|
}
|
|
|
|
func LogSQL(query string, args ...interface{}) {
|
|
GetDebugLogger().LogSQL(query, args...)
|
|
}
|
|
|
|
func LogMemory() {
|
|
GetDebugLogger().LogMemory()
|
|
}
|
|
|
|
func LogTiming(operation string, duration interface{}) {
|
|
GetDebugLogger().LogTiming(operation, duration)
|
|
}
|
|
|
|
func GetLegacyLogger() *Logger {
|
|
if logger == nil {
|
|
logger, _ = Initialize()
|
|
}
|
|
return logger
|
|
}
|
|
|
|
func InitializeLogging() error {
|
|
_, err := Initialize()
|
|
if err != nil {
|
|
return fmt.Errorf("failed to initialize legacy logger: %v", err)
|
|
}
|
|
|
|
GetErrorLogger()
|
|
GetWarnLogger()
|
|
GetInfoLogger()
|
|
GetDebugLogger()
|
|
|
|
Info("Logging system initialized successfully")
|
|
|
|
return nil
|
|
}
|