Golang如何实现日志文件滚动

在Golang项目中，日志文件滚动是日志管理的基础需求，主要解决单个日志文件过大、历史日志难以归档的问题，避免磁盘空间被日志占满影响服务运行。实现日志滚动的核心思路是监控日志文件的写入情况，当满足预设条件时触发文件切割，将旧日志归档，同时创建新的日志文件继续写入。

日志文件滚动的常见触发条件

通常日志滚动会基于以下两种条件触发，也可以组合使用：

• 文件大小触发：当当前日志文件的大小达到预设阈值（比如100MB）时，执行滚动操作
• 时间触发：按照固定的时间周期（比如每天零点、每小时）执行滚动操作

方式一：使用第三方库lumberjack实现

lumberjack是Golang生态中常用的日志滚动库，已经封装好了完整的滚动逻辑，使用起来非常简单，不需要自己处理文件切割的细节。

首先需要安装依赖：

go get gopkg.in/natefinch/lumberjack.v2

下面是结合标准库log使用lumberjack的示例：

package main

import (
	"log"
	"gopkg.in/natefinch/lumberjack.v2"
)

func main() {
	// 配置日志滚动参数
	log.SetOutput(&lumberjack.Logger{
		Filename:   "./app.log", // 日志文件路径
		MaxSize:    100,         // 单个日志文件最大大小，单位MB
		MaxBackups: 3,           // 最多保留的旧日志文件数量
		MaxAge:     7,           // 旧日志文件最多保留的天数
		Compress:   true,        // 是否压缩旧日志文件
	})

	// 写入测试日志
	for i := 0; i < 1000; i++ {
		log.Printf("这是第%d条测试日志，用于验证日志滚动功能是否正常", i)
	}
}

上述代码中，lumberjack会自动监控日志文件的大小，当文件大小超过100MB时，会自动将当前日志文件重命名归档，然后创建新的app.log继续写入。同时会根据配置保留最多3个备份文件，超过7天的旧文件会被自动删除，归档的文件会被压缩节省空间。

方式二：自定义实现日志滚动逻辑

如果不想依赖第三方库，也可以自己实现简单的日志滚动逻辑，核心步骤包括：封装日志写入方法、每次写入前检查文件状态、满足条件时执行切割。

下面是自定义实现的简单示例，基于文件大小触发滚动：

package main

import (
	"fmt"
	"io"
	"os"
	"path/filepath"
	"time"
)

// 自定义日志写入结构体
type RotateLog struct {
	filePath    string       // 日志文件路径
	maxSize     int64        // 单个文件最大大小，单位字节
	file        *os.File     // 当前打开的日志文件
	fileSize    int64        // 当前文件大小
}

// 创建新的RotateLog实例
func NewRotateLog(filePath string, maxSize int64) (*RotateLog, error) {
	rl := &RotateLog{
		filePath: filePath,
		maxSize:  maxSize,
	}
	// 打开或创建日志文件
	err := rl.openFile()
	if err != nil {
		return nil, err
	}
	return rl, nil
}

// 打开日志文件，获取当前文件大小
func (rl *RotateLog) openFile() error {
	file, err := os.OpenFile(rl.filePath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		return err
	}
	// 获取当前文件信息
	info, err := file.Stat()
	if err != nil {
		file.Close()
		return err
	}
	rl.file = file
	rl.fileSize = info.Size()
	return nil
}

// 写入日志内容
func (rl *RotateLog) Write(p []byte) (n int, err error) {
	// 检查当前文件大小是否超过阈值
	if rl.fileSize+int64(len(p)) > rl.maxSize {
		// 执行滚动操作
		err = rl.rotate()
		if err != nil {
			return 0, err
		}
	}
	// 写入日志
	n, err = rl.file.Write(p)
	rl.fileSize += int64(n)
	return n, err
}

// 执行日志滚动
func (rl *RotateLog) rotate() error {
	// 关闭当前文件
	rl.file.Close()
	// 生成归档文件名，格式为原文件名+时间
	dir := filepath.Dir(rl.filePath)
	fileName := filepath.Base(rl.filePath)
	ext := filepath.Ext(fileName)
	name := fileName[:len(fileName)-len(ext)]
	backupName := fmt.Sprintf("%s/%s_%s%s", dir, name, time.Now().Format("20060102_150405"), ext)
	// 重命名当前日志文件为归档文件
	err := os.Rename(rl.filePath, backupName)
	if err != nil {
		return err
	}
	// 重新打开新的日志文件
	return rl.openFile()
}

// 关闭日志文件
func (rl *RotateLog) Close() error {
	return rl.file.Close()
}

func main() {
	// 创建日志实例，设置单个文件最大1MB
	rl, err := NewRotateLog("./custom_app.log", 1024*1024)
	if err != nil {
		fmt.Printf("创建日志实例失败：%v\n", err)
		return
	}
	defer rl.Close()

	// 写入测试日志
	for i := 0; i < 5000; i++ {
		content := fmt.Sprintf("自定义日志滚动测试，第%d条日志\n", i)
		_, err := rl.Write([]byte(content))
		if err != nil {
			fmt.Printf("写入日志失败：%v\n", err)
			return
		}
	}
}

这个自定义实现中，每次写入日志前都会检查当前文件大小，当加上本次写入内容后超过预设的1MB阈值时，就会执行滚动操作：先关闭当前文件，将当前日志文件重命名为带时间戳的归档文件，然后重新创建新的日志文件继续写入。如果需要基于时间触发滚动，可以在Write方法中增加时间判断逻辑，比如判断当前时间是否超过预设的滚动时间点。

两种方式的对比

可以通过下面的表格对比两种实现方式的特点：

注意事项

在实际使用日志滚动功能时，需要注意以下几点：

• 如果是多协程写入日志，需要保证日志写入的线程安全，避免多个协程同时触发滚动操作导致文件异常，可以在Write方法加锁
• 滚动时重命名文件的操作需要确保文件没有被其他进程占用，否则可能会失败
• 如果服务重启，需要正确读取已有日志文件的大小，避免重启后日志文件大小统计错误
• 历史日志的清理策略需要根据实际需求设置，避免保留过多旧日志占用磁盘空间

Golang日志文件滚动log_rotate文件切割日志管理修改时间：2026-06-05 22:41:58