From 56466188ec7d193ec0681d167a3aff46f9fb1536 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=20Jurmanovi=C4=87?= Date: Tue, 1 Jul 2025 00:21:27 +0200 Subject: [PATCH] logging to independent files --- local/utl/logging/base.go | 18 +++++------------- local/utl/logging/debug.go | 13 +++++++++---- local/utl/logging/error.go | 13 +++++++++---- local/utl/logging/info.go | 13 +++++++++---- local/utl/logging/logger.go | 23 ++++++++++++----------- local/utl/logging/warn.go | 13 +++++++++---- 6 files changed, 53 insertions(+), 40 deletions(-) diff --git a/local/utl/logging/base.go b/local/utl/logging/base.go index 92a8e73..03ef1fa 100644 --- a/local/utl/logging/base.go +++ b/local/utl/logging/base.go @@ -13,8 +13,6 @@ import ( var ( timeFormat = "2006-01-02 15:04:05.000" - baseOnce sync.Once - baseLogger *BaseLogger ) // BaseLogger provides the core logging functionality @@ -36,13 +34,9 @@ const ( LogLevelPanic LogLevel = "PANIC" ) -// Initialize creates or gets the singleton base logger instance +// Initialize creates a new base logger instance func InitializeBase(tp string) (*BaseLogger, error) { - var err error - baseOnce.Do(func() { - baseLogger, err = newBaseLogger(tp) - }) - return baseLogger, err + return newBaseLogger(tp) } func newBaseLogger(tp string) (*BaseLogger, error) { @@ -71,11 +65,9 @@ func newBaseLogger(tp string) (*BaseLogger, error) { return logger, nil } -// GetBaseLogger returns the singleton base logger instance +// GetBaseLogger creates and returns a new base logger instance func GetBaseLogger(tp string) *BaseLogger { - if baseLogger == nil { - baseLogger, _ = InitializeBase(tp) - } + baseLogger, _ := InitializeBase(tp) return baseLogger } @@ -158,7 +150,7 @@ func (bl *BaseLogger) IsInitialized() bool { // RecoverAndLog recovers from panics and logs them func RecoverAndLog() { - baseLogger := GetBaseLogger("log") + baseLogger := GetBaseLogger("panic") if baseLogger != nil && baseLogger.IsInitialized() { if r := recover(); r != nil { // Get stack trace diff --git a/local/utl/logging/debug.go b/local/utl/logging/debug.go index 2188ff1..0422ad6 100644 --- a/local/utl/logging/debug.go +++ b/local/utl/logging/debug.go @@ -3,6 +3,7 @@ package logging import ( "fmt" "runtime" + "sync" ) // DebugLogger handles debug-level logging @@ -12,8 +13,9 @@ type DebugLogger struct { // NewDebugLogger creates a new debug logger instance func NewDebugLogger() *DebugLogger { + base, _ := InitializeBase("debug") return &DebugLogger{ - base: GetBaseLogger("debug"), + base: base, } } @@ -98,13 +100,16 @@ func bToKb(b uint64) uint64 { } // Global debug logger instance -var debugLogger *DebugLogger +var ( + debugLogger *DebugLogger + debugOnce sync.Once +) // GetDebugLogger returns the global debug logger instance func GetDebugLogger() *DebugLogger { - if debugLogger == nil { + debugOnce.Do(func() { debugLogger = NewDebugLogger() - } + }) return debugLogger } diff --git a/local/utl/logging/error.go b/local/utl/logging/error.go index 99fe672..d347bbd 100644 --- a/local/utl/logging/error.go +++ b/local/utl/logging/error.go @@ -3,6 +3,7 @@ package logging import ( "fmt" "runtime" + "sync" ) // ErrorLogger handles error-level logging @@ -12,8 +13,9 @@ type ErrorLogger struct { // NewErrorLogger creates a new error logger instance func NewErrorLogger() *ErrorLogger { + base, _ := InitializeBase("error") return &ErrorLogger{ - base: GetBaseLogger("error"), + base: base, } } @@ -65,13 +67,16 @@ func (el *ErrorLogger) LogFatal(format string, v ...interface{}) { } // Global error logger instance -var errorLogger *ErrorLogger +var ( + errorLogger *ErrorLogger + errorOnce sync.Once +) // GetErrorLogger returns the global error logger instance func GetErrorLogger() *ErrorLogger { - if errorLogger == nil { + errorOnce.Do(func() { errorLogger = NewErrorLogger() - } + }) return errorLogger } diff --git a/local/utl/logging/info.go b/local/utl/logging/info.go index 1abda76..17553f0 100644 --- a/local/utl/logging/info.go +++ b/local/utl/logging/info.go @@ -2,6 +2,7 @@ package logging import ( "fmt" + "sync" ) // InfoLogger handles info-level logging @@ -11,8 +12,9 @@ type InfoLogger struct { // NewInfoLogger creates a new info logger instance func NewInfoLogger() *InfoLogger { + base, _ := InitializeBase("info") return &InfoLogger{ - base: GetBaseLogger("info"), + base: base, } } @@ -74,13 +76,16 @@ func (il *InfoLogger) LogResponse(method string, path string, statusCode int, du } // Global info logger instance -var infoLogger *InfoLogger +var ( + infoLogger *InfoLogger + infoOnce sync.Once +) // GetInfoLogger returns the global info logger instance func GetInfoLogger() *InfoLogger { - if infoLogger == nil { + infoOnce.Do(func() { infoLogger = NewInfoLogger() - } + }) return infoLogger } diff --git a/local/utl/logging/logger.go b/local/utl/logging/logger.go index 0e8b174..12c059a 100644 --- a/local/utl/logging/logger.go +++ b/local/utl/logging/logger.go @@ -40,10 +40,10 @@ func newLogger() (*Logger, error) { // Create the legacy logger wrapper logger := &Logger{ base: baseLogger, - errorLogger: NewErrorLogger(), - warnLogger: NewWarnLogger(), - infoLogger: NewInfoLogger(), - debugLogger: NewDebugLogger(), + errorLogger: GetErrorLogger(), + warnLogger: GetWarnLogger(), + infoLogger: GetInfoLogger(), + debugLogger: GetDebugLogger(), } return logger, nil @@ -194,18 +194,19 @@ func GetLegacyLogger() *Logger { // InitializeLogging initializes all logging components func InitializeLogging() error { - // Initialize base logger - _, err := InitializeBase("log") - if err != nil { - return fmt.Errorf("failed to initialize base logger: %v", err) - } - // Initialize legacy logger for backward compatibility - _, err = Initialize() + _, err := Initialize() if err != nil { return fmt.Errorf("failed to initialize legacy logger: %v", err) } + // Pre-initialize all logger types to ensure separate log files + GetErrorLogger() + GetWarnLogger() + GetInfoLogger() + GetDebugLogger() + GetPerformanceLogger() + // Log successful initialization Info("Logging system initialized successfully") diff --git a/local/utl/logging/warn.go b/local/utl/logging/warn.go index f9b07a9..376d0ea 100644 --- a/local/utl/logging/warn.go +++ b/local/utl/logging/warn.go @@ -2,6 +2,7 @@ package logging import ( "fmt" + "sync" ) // WarnLogger handles warn-level logging @@ -11,8 +12,9 @@ type WarnLogger struct { // NewWarnLogger creates a new warn logger instance func NewWarnLogger() *WarnLogger { + base, _ := InitializeBase("warn") return &WarnLogger{ - base: GetBaseLogger("warn"), + base: base, } } @@ -57,13 +59,16 @@ func (wl *WarnLogger) LogPerformance(operation string, threshold string, actual } // Global warn logger instance -var warnLogger *WarnLogger +var ( + warnLogger *WarnLogger + warnOnce sync.Once +) // GetWarnLogger returns the global warn logger instance func GetWarnLogger() *WarnLogger { - if warnLogger == nil { + warnOnce.Do(func() { warnLogger = NewWarnLogger() - } + }) return warnLogger }