logging to independent files

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

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
 }
 

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
 }
 

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
 }
 

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")
 

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
 }