Golang高效O(1)多输出源日志记录插件库log的使用

在Go语言中，标准库log提供了基本的日志功能，但对于需要高性能、多输出源(如同时输出到控制台、文件、网络等)的场景，我们需要更强大的解决方案。下面我将介绍如何实现一个高效O(1)的多输出源日志系统。

核心设计思路

1. O(1)时间复杂度：通过channel实现异步日志处理
2. 多输出源：使用io.MultiWriter支持多个输出目标
3. 日志级别：支持不同级别的日志过滤
4. 插件化：可以轻松添加新的输出源

实现代码示例

package multilog

import (
	"fmt"
	"io"
	"log"
	"os"
	"sync"
)

// 日志级别
type LogLevel int

const (
	LevelDebug LogLevel = iota
	LevelInfo
	LevelWarn
	LevelError
	LevelFatal
)

var levelNames = []string{
	"DEBUG",
	"INFO",
	"WARN",
	"ERROR",
	"FATAL",
}

// Logger 多输出源日志记录器
type Logger struct {
	level     LogLevel
	logChan   chan *logEntry
	writers   []io.Writer
	closeChan chan struct{}
	wg        sync.WaitGroup
}

type logEntry struct {
	level   LogLevel
	message string
}

// NewLogger 创建新的日志记录器
func NewLogger(level LogLevel, bufferSize int) *Logger {
	l := &Logger{
		level:     level,
		logChan:   make(chan *logEntry, bufferSize),
		closeChan: make(chan struct{}),
	}

	l.wg.Add(1)
	go l.processLogs()

	return l
}

// AddWriter 添加输出源
func (l *Logger) AddWriter(w io.Writer) {
	l.writers = append(l.writers, w)
}

// processLogs 处理日志的核心goroutine
func (l *Logger) processLogs() {
	defer l.wg.Done()

	// 创建组合writer
	multiWriter := io.MultiWriter(l.writers...)
	logger := log.New(multiWriter, "", log.LstdFlags|log.Lmicroseconds)

	for {
		select {
		case entry := <-l.logChan:
			if entry.level >= l.level {
				logger.Printf("[%s] %s", levelNames[entry.level], entry.message)
			}
		case <-l.closeChan:
			// 处理剩余日志
			for {
				select {
				case entry := <-l.logChan:
					if entry.level >= l.level {
						logger.Printf("[%s] %s", levelNames[entry.level], entry.message)
					}
				default:
					return
				}
			}
		}
	}
}

// 通用日志记录方法
func (l *Logger) log(level LogLevel, format string, args ...interface{}) {
	select {
	case l.logChan <- &logEntry{
		level:   level,
		message: fmt.Sprintf(format, args...),
	}:
	default:
		// 通道满时丢弃日志(可根据需求改为阻塞或其他处理方式)
	}
}

// 各级别日志方法
func (l *Logger) Debug(format string, args ...interface{}) {
	l.log(LevelDebug, format, args...)
}

func (l *Logger) Info(format string, args ...interface{}) {
	l.log(LevelInfo, format, args...)
}

func (l *Logger) Warn(format string, args ...interface{}) {
	l.log(LevelWarn, format, args...)
}

func (l *Logger) Error(format string, args ...interface{}) {
	l.log(LevelError, format, args...)
}

func (l *Logger) Fatal(format string, args ...interface{}) {
	l.log(LevelFatal, format, args...)
	os.Exit(1)
}

// Close 关闭日志记录器
func (l *Logger) Close() {
	close(l.closeChan)
	l.wg.Wait()
}

使用示例

package main

import (
	"os"
	"path/filepath"
	"time"

	"./multilog" // 替换为你的实际模块路径
)

func main() {
	// 创建日志记录器
	logger := multilog.NewLogger(multilog.LevelDebug, 1000)

	// 添加控制台输出
	logger.AddWriter(os.Stdout)

	// 添加文件输出
	file, err := os.OpenFile(
		filepath.Join("logs", "app.log"),
		os.O_CREATE|os.O_WRONLY|os.O_APPEND,
		0666,
	)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	logger.AddWriter(file)

	// 使用日志记录器
	logger.Debug("这是一条调试信息")
	logger.Info("程序启动，时间: %s", time.Now().Format("2006-01-02 15:04:05"))
	logger.Warn("警告: 磁盘空间不足")
	logger.Error("发生错误: %v", "文件读取失败")

	// 模拟并发日志写入
	for i := 0; i < 100; i++ {
		go func(n int) {
			logger.Info("并发日志 %d", n)
		}(i)
	}

	// 关闭日志记录器(在实际应用中通常在程序退出时调用)
	logger.Close()
}

性能优化说明

1. 异步处理：日志写入通过channel异步处理，调用日志方法的goroutine不会被阻塞
2. 缓冲channel：通过合理设置bufferSize可以减少goroutine切换
3. 无锁设计：主要操作都在单个goroutine中完成，避免了锁竞争
4. 快速失败：当channel满时丢弃日志(可根据需求修改)

扩展建议

1. 日志轮转：可以集成lumberjack等库实现日志文件轮转
2. 网络输出：实现io.Writer接口支持远程日志服务器
3. 结构化日志：支持JSON等结构化日志格式
4. 上下文信息：添加请求ID等上下文信息

这个实现提供了高性能、多输出源的日志记录功能，核心日志记录操作时间复杂度为O(1)，适合高并发场景使用。