Go语言日志系统详解：从标准库实现到文件切割与分级管理

标准 Logger 的基础配置

Go语言内置的 log 包提供了开箱即用的基础日志服务。它预定义了“标准”logger，通过 Print、Fatal（调用后程序终止）和 Panic 系列函数直接输出日志，适用于简单的开发调试场景。

第1步：设置标准Logger格式

默认情况下，标准Logger仅输出时间和消息。如需包含更多上下文信息，需通过 SetFlags 函数进行配置。常用的标志位常量如下：

• Ldate：输出日期（如 2009/01/23）。
• Ltime：输出时间（如 01:23:23）。
• Lmicroseconds：高精度时间，增强 Ltime。
• Llongfile：完整文件路径名和行号（如 /a/b/c/d.go:23）。
• Lshortfile：仅文件名和行号（会覆盖 Llongfile）。
• LUTC：强制使用UTC时区。

以下代码演示了如何开启微秒级时间与文件定位功能，以便精准追溯日志来源：

package main

import (
	"log"
)

func main() {
	// 配置输出格式：日期 + 微秒时间 + 长文件名/行号
	log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
	v := "测试"
	log.Println("这是一条", v, "日志。")
	log.Printf("这是一条%s日志。\n", v)
}

第2步：添加日志前缀与修改输出目的地

在实际应用中，通常需要对不同模块或环境的日志进行区分。可以使用 SetPrefix 在每行日志开头添加统一标识，或使用 SetOutput 将日志重定向至指定文件而非屏幕。

func init() {
	// 创建并打开日志文件
	logFile, err := os.OpenFile("./xx.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		fmt.Println("open log file failed, err:", err)
		return
	}
	// 将标准日志输出重定向到文件
	log.SetOutput(logFile)
	// 恢复详细的格式标志
	log.SetFlags(log.Llongfile | log.Lmicroseconds | log.Ldate)
}

创建独立的 Logger 实例

标准Logger是全进程共享的，如果存在并发操作，其输出可能会相互交错。对于更复杂的业务需求，可以使用 log.New 构造函数创建私有的Logger对象。这使得我们能为不同的功能模块分配独立的Writer、前缀和格式标志，互不干扰。

func main() {
	// 创建一个指向标准输出的独立Logger
	// 前缀为 "<New>"，格式包含短文件名、日期和时间
	logger := log.New(os.Stdout, "<New>", log.Lshortfile|log.Ldate|log.Ltime)
	logger.Println("这是自定义的logger记录的日志。")
}

上图展示了通过 runtime.Caller 可以获取当前调用的文件名、函数名和行号信息，结合此能力可开发出更具表现力的定制化日志工具。

进阶：实现自定义多级日志系统

标准库的 log 包不支持日志分级（Debug, Info, Warn, Error等），且格式化能力较弱。下面提供一个轻量级的多级日志实现方案，具备级别控制、文件定位和可变参数支持。

第3步：定义日志结构体与级别过滤

通过定义 LogLevel 枚举和结构体，并在打印方法中判断当前日志级别是否高于设定阈值，从而实现按需输出。同时引入 runtime.Caller 捕获调用栈信息，使日志具备自我描述性。

package log

import (
	"errors"
	"fmt"
	"strings"
	"time"
	"runtime"
)

type LogLevel uint16

const (
	UNKNOW LogLevel = iota
	DEBUG
	INFO
	WARN
	ERROR
	FATAL
)

// Logger 自定义日志结构体
type Logger struct {
	Level LogLevel
	prefix string
}

// enable 判断是否可以输出特定级别的日志
func (l Logger) enable(logLevel LogLevel) bool {
	return l.Level >= logLevel
}

// 内部辅助方法：获取调用源位置 (文件名:行号)
func getCallerInfo() string {
	_, file, line, ok := runtime.Caller(2)
	if !ok {
		return "???:?"
	}
	return fmt.Sprintf("%s:%d", file, line)
}

func (l *Logger) Debug(format string, args ...interface{}) {
	if l.enable(DEBUG) {
		caller := getCallerInfo()
		ts := time.Now().Format("2006-01-02 15:04:05")
		msg := fmt.Sprintf(format, args...)
		fmt.Printf("[%s] [DEBUG] [%s] %s: %s\n", ts, caller, l.prefix, msg)
	}
}

func (l *Logger) Info(format string, args ...interface{}) {
	if l.enable(INFO) {
		caller := getCallerInfo()
		ts := time.Now().Format("2006-01-02 15:04:05")
		msg := fmt.Sprintf(format, args...)
		fmt.Printf("[%s] [INFO] [%s] %s: %s\n", ts, caller, l.prefix, msg)
	}
}

func (l *Logger) Error(format string, args ...interface{}) {
	if l.enable(ERROR) {
		caller := getCallerInfo()
		ts := time.Now().Format("2006-01-02 15:04:05")
		msg := fmt.Sprintf(format, args...)
		fmt.Printf("[%s] [ERROR] [%s] %s: %s\n", ts, caller, l.prefix, msg)
	}
}

日志写入文件与持久化

将日志输出保存到磁盘文件是生产环境的基本要求。这涉及到文件的创建、追加模式打开以及必要的资源释放。为了保证安全性，建议先评估磁盘空间。

type FileLogger struct {
	*Logger
	fileObj *os.File
}

func NewFileLogger(level LogLevel, fp, fn string) (*FileLogger, error) {
	ll := &Logger{Level: level}
	f1 := &FileLogger{Logger: ll}
	
	// 拼接完整路径
	join := path.Join(fp, fn)
	// 以追加、创建方式打开文件
	fileObj, err := os.OpenFile(join, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		return nil, err
	}
	f1.fileObj = fileObj
	return f1, nil
}

// 覆写输出方法以写入文件
func (f *FileLogger) Info(format string, args ...interface{}) {
	// 复用父类Logger的逻辑，但将最终输出改为写入 f.fileObj
	if f.enable(INFO) {
		caller := getCallerInfo()
		ts := time.Now().Format("2006-01-02 15:04:05")
		msg := fmt.Sprintf(format, args...)
		output := fmt.Sprintf("[%s] [INFO] [%s] : %s\n", ts, caller, msg)
		f.fileObj.WriteString(output)
	}
}

日志切割策略

随着时间推移，日志文件体积可能变得巨大，影响读取性能并占用存储。通常采用两种维度进行切割：按文件大小（如超过100MB分割）和按时间周期（如每天生成一个新文件）。

按文件大小切割

在每次写入前检查文件状态。如果当前文件大小超过了预设阈值，则关闭旧文件句柄，并将后缀加上日期或序列号创建新文件。

stat, _ := f.fileObj.Stat()
if stat.Size() > maxSizeBytes { 
    // 执行切割逻辑：重命名旧文件 -> 创建新文件
}

按日期切割

核心思路是检查当天是否已存在日志文件。若不存在（或跨天了），则切换到新日期的文件名下继续写入。这样可以保持每天的错误排查更加清晰明了。

总结

以上就是Go语言日志实现详解，涵盖了从内置基础包到自定义文件切割的全过程。更多关于Go语言高性能日志库（如Zap、Logrus）的资料请关注本站其它相关文章！