日志方法增加异步与同步的方法

logger/logger.go

@@ -6,10 +6,19 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"sync"
 
 	"git.toowon.com/jimmy/go-common/config"
 )
 
+// logMessage 异步日志消息结构
+type logMessage struct {
+	level  string // debug, info, warn, error
+	format string
+	args   []interface{}
+	fields map[string]interface{} // 用于带字段的日志
+}
+
 // Logger 日志记录器
 type Logger struct {
 	infoLog  *log.Logger
@@ -17,6 +26,14 @@ type Logger struct {
 	warnLog  *log.Logger
 	debugLog *log.Logger
 	config   *config.LoggerConfig
+
+	// 异步相关字段
+	async    bool             // 是否异步模式
+	logChan  chan *logMessage // 异步日志channel
+	done     chan struct{}    // 用于优雅关闭
+	wg       sync.WaitGroup   // 等待所有日志写入完成
+	closed   bool             // 是否已关闭
+	closeMux sync.RWMutex     // 保护closed字段
 }
 
 // NewLogger 创建日志记录器
@@ -24,9 +41,11 @@ func NewLogger(cfg *config.LoggerConfig) (*Logger, error) {
 	if cfg == nil {
 		// 使用默认配置
 		cfg = &config.LoggerConfig{
-			Level:    "info",
-			Output:   "stdout",
-			FilePath: "",
+			Level:      "info",
+			Output:     "stdout",
+			FilePath:   "",
+			Async:      false, // 默认同步
+			BufferSize: 1000,  // 默认缓冲区大小
 		}
 	}
 
@@ -37,6 +56,9 @@ func NewLogger(cfg *config.LoggerConfig) (*Logger, error) {
 	if cfg.Output == "" {
 		cfg.Output = "stdout"
 	}
+	if cfg.BufferSize <= 0 {
+		cfg.BufferSize = 1000 // 默认缓冲区大小
+	}
 
 	// 创建输出目标
 	var writers []io.Writer
@@ -89,6 +111,7 @@ func NewLogger(cfg *config.LoggerConfig) (*Logger, error) {
 	// 创建日志记录器
 	logger := &Logger{
 		config: cfg,
+		async:  cfg.Async,
 	}
 
 	// 根据日志级别创建不同的logger
@@ -106,39 +129,152 @@ func NewLogger(cfg *config.LoggerConfig) (*Logger, error) {
 		}
 	}
 
+	// 如果启用异步模式，启动goroutine处理日志
+	if cfg.Async {
+		logger.logChan = make(chan *logMessage, cfg.BufferSize)
+		logger.done = make(chan struct{})
+		logger.wg.Add(1)
+		go logger.processLogs()
+	}
+
 	return logger, nil
 }
 
+// processLogs 异步处理日志（goroutine）
+func (l *Logger) processLogs() {
+	defer l.wg.Done()
+
+	for {
+		select {
+		case msg := <-l.logChan:
+			if msg == nil {
+				// channel已关闭，退出
+				return
+			}
+			l.writeLog(msg)
+		case <-l.done:
+			// 收到关闭信号，处理完剩余日志后退出
+			for {
+				select {
+				case msg := <-l.logChan:
+					if msg == nil {
+						return
+					}
+					l.writeLog(msg)
+				default:
+					return
+				}
+			}
+		}
+	}
+}
+
+// writeLog 实际写入日志（内部方法）
+func (l *Logger) writeLog(msg *logMessage) {
+	var logger *log.Logger
+	switch msg.level {
+	case "debug":
+		logger = l.debugLog
+	case "info":
+		logger = l.infoLog
+	case "warn":
+		logger = l.warnLog
+	case "error":
+		logger = l.errorLog
+	default:
+		return
+	}
+
+	if logger == nil {
+		return
+	}
+
+	// 如果有字段，先格式化字段
+	format := msg.format
+	if len(msg.fields) > 0 {
+		fieldStr := formatFields(msg.fields)
+		format = fieldStr + format
+	}
+
+	// 写入日志
+	logger.Printf(format, msg.args...)
+}
+
+// isClosed 检查logger是否已关闭
+func (l *Logger) isClosed() bool {
+	l.closeMux.RLock()
+	defer l.closeMux.RUnlock()
+	return l.closed
+}
+
+// setClosed 设置logger为已关闭状态
+func (l *Logger) setClosed() {
+	l.closeMux.Lock()
+	defer l.closeMux.Unlock()
+	l.closed = true
+}
+
+// log 内部日志方法，根据模式选择同步或异步
+func (l *Logger) log(level string, format string, args []interface{}, fields map[string]interface{}) {
+	// 如果已关闭，直接返回
+	if l.isClosed() {
+		return
+	}
+
+	// 如果是异步模式，发送到channel
+	if l.async {
+		// 检查channel是否已关闭
+		select {
+		case l.logChan <- &logMessage{
+			level:  level,
+			format: format,
+			args:   args,
+			fields: fields,
+		}:
+			// 成功发送
+		default:
+			// channel已满或已关闭，同步写入（降级处理）
+			l.writeLog(&logMessage{
+				level:  level,
+				format: format,
+				args:   args,
+				fields: fields,
+			})
+		}
+	} else {
+		// 同步模式，直接写入
+		l.writeLog(&logMessage{
+			level:  level,
+			format: format,
+			args:   args,
+			fields: fields,
+		})
+	}
+}
+
 // Debug 记录调试日志
 func (l *Logger) Debug(format string, v ...interface{}) {
-	if l.debugLog != nil {
-		l.debugLog.Printf(format, v...)
-	}
+	l.log("debug", format, v, nil)
 }
 
 // Info 记录信息日志
 func (l *Logger) Info(format string, v ...interface{}) {
-	if l.infoLog != nil {
-		l.infoLog.Printf(format, v...)
-	}
+	l.log("info", format, v, nil)
 }
 
 // Warn 记录警告日志
 func (l *Logger) Warn(format string, v ...interface{}) {
-	if l.warnLog != nil {
-		l.warnLog.Printf(format, v...)
-	}
+	l.log("warn", format, v, nil)
 }
 
 // Error 记录错误日志
 func (l *Logger) Error(format string, v ...interface{}) {
-	if l.errorLog != nil {
-		l.errorLog.Printf(format, v...)
-	}
+	l.log("error", format, v, nil)
 }
 
-// Fatal 记录致命错误日志并退出程序
+// Fatal 记录致命错误日志并退出程序（始终同步）
 func (l *Logger) Fatal(format string, v ...interface{}) {
+	// Fatal必须同步执行，确保日志写入后再退出
 	if l.errorLog != nil {
 		l.errorLog.Fatalf(format, v...)
 	} else {
@@ -146,8 +282,9 @@ func (l *Logger) Fatal(format string, v ...interface{}) {
 	}
 }
 
-// Panic 记录恐慌日志并触发panic
+// Panic 记录恐慌日志并触发panic（始终同步）
 func (l *Logger) Panic(format string, v ...interface{}) {
+	// Panic必须同步执行，确保日志写入后再panic
 	if l.errorLog != nil {
 		l.errorLog.Panicf(format, v...)
 	} else {
@@ -175,33 +312,48 @@ func formatFields(fields map[string]interface{}) string {
 
 // Debugf 记录调试日志（带字段）
 func (l *Logger) Debugf(fields map[string]interface{}, format string, v ...interface{}) {
-	if l.debugLog != nil {
-		fieldStr := formatFields(fields)
-		l.debugLog.Printf(fieldStr+format, v...)
-	}
+	l.log("debug", format, v, fields)
 }
 
 // Infof 记录信息日志（带字段）
 func (l *Logger) Infof(fields map[string]interface{}, format string, v ...interface{}) {
-	if l.infoLog != nil {
-		fieldStr := formatFields(fields)
-		l.infoLog.Printf(fieldStr+format, v...)
-	}
+	l.log("info", format, v, fields)
 }
 
 // Warnf 记录警告日志（带字段）
 func (l *Logger) Warnf(fields map[string]interface{}, format string, v ...interface{}) {
-	if l.warnLog != nil {
-		fieldStr := formatFields(fields)
-		l.warnLog.Printf(fieldStr+format, v...)
-	}
+	l.log("warn", format, v, fields)
 }
 
 // Errorf 记录错误日志（带字段）
 func (l *Logger) Errorf(fields map[string]interface{}, format string, v ...interface{}) {
-	if l.errorLog != nil {
-		fieldStr := formatFields(fields)
-		l.errorLog.Printf(fieldStr+format, v...)
-	}
+	l.log("error", format, v, fields)
 }
 
+// Close 优雅关闭logger（仅异步模式需要）
+// 等待所有日志写入完成后再返回
+func (l *Logger) Close() error {
+	if !l.async {
+		// 同步模式不需要关闭
+		return nil
+	}
+
+	// 检查是否已关闭
+	if l.isClosed() {
+		return nil
+	}
+
+	// 设置关闭状态
+	l.setClosed()
+
+	// 发送关闭信号
+	close(l.done)
+
+	// 关闭channel（会触发processLogs退出）
+	close(l.logChan)
+
+	// 等待所有日志写入完成
+	l.wg.Wait()
+
+	return nil
+}