新增实例槽位隔离与结构化日志,多开不再共用日志与账号
This commit is contained in:
@@ -0,0 +1,94 @@
|
||||
package logger
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
)
|
||||
|
||||
// asyncBufferSize 异步写盘队列长度。队列满时丢弃日志,优先保护抢购链路。
|
||||
const asyncBufferSize = 8192
|
||||
|
||||
// AsyncWriter 异步日志写入器,队列满时丢弃日志以保护主链路。
|
||||
type AsyncWriter struct {
|
||||
mu sync.RWMutex
|
||||
dst io.Writer
|
||||
ch chan []byte
|
||||
wg sync.WaitGroup
|
||||
closed uint32
|
||||
dropped uint64
|
||||
}
|
||||
|
||||
// NewAsyncWriter 创建异步日志写入器。
|
||||
func NewAsyncWriter(dst io.Writer, buffer int) *AsyncWriter {
|
||||
if buffer <= 0 {
|
||||
buffer = 1024
|
||||
}
|
||||
w := &AsyncWriter{
|
||||
dst: dst,
|
||||
ch: make(chan []byte, buffer),
|
||||
}
|
||||
w.wg.Add(1)
|
||||
go w.run()
|
||||
return w
|
||||
}
|
||||
|
||||
// Write 异步写日志;队列满时丢弃,避免抢购请求被磁盘 I/O 阻塞。
|
||||
func (w *AsyncWriter) Write(p []byte) (int, error) {
|
||||
if w == nil {
|
||||
return len(p), nil
|
||||
}
|
||||
w.mu.RLock()
|
||||
defer w.mu.RUnlock()
|
||||
if atomic.LoadUint32(&w.closed) == 1 {
|
||||
return len(p), nil
|
||||
}
|
||||
buf := append([]byte(nil), p...)
|
||||
select {
|
||||
case w.ch <- buf:
|
||||
default:
|
||||
atomic.AddUint64(&w.dropped, 1)
|
||||
}
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
// Dropped 返回因队列满被丢弃的日志条数。
|
||||
func (w *AsyncWriter) Dropped() uint64 {
|
||||
if w == nil {
|
||||
return 0
|
||||
}
|
||||
return atomic.LoadUint64(&w.dropped)
|
||||
}
|
||||
|
||||
func (w *AsyncWriter) run() {
|
||||
defer w.wg.Done()
|
||||
for p := range w.ch {
|
||||
_, _ = w.dst.Write(p)
|
||||
}
|
||||
if dropped := atomic.LoadUint64(&w.dropped); dropped > 0 {
|
||||
notice := formatLogLine(Entry{
|
||||
Time: time.Now().Format(entryTimeLayout),
|
||||
Level: LevelWarn,
|
||||
Category: "日志",
|
||||
Message: fmt.Sprintf("日志队列已丢弃 %d 条,已优先保护抢购链路", dropped),
|
||||
at: time.Now(),
|
||||
})
|
||||
_, _ = w.dst.Write([]byte(notice))
|
||||
}
|
||||
}
|
||||
|
||||
// Close 关闭写入器,等待队列清空。
|
||||
func (w *AsyncWriter) Close() error {
|
||||
if w == nil {
|
||||
return nil
|
||||
}
|
||||
w.mu.Lock()
|
||||
defer w.mu.Unlock()
|
||||
if atomic.CompareAndSwapUint32(&w.closed, 0, 1) {
|
||||
close(w.ch)
|
||||
w.wg.Wait()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,179 @@
|
||||
// Package logger 提供全应用共用的结构化日志。
|
||||
//
|
||||
// 设计要点(多开场景下尤其重要):
|
||||
// - 每个进程启动时创建一个独占的日志文件(O_EXCL + 自增后缀),
|
||||
// 多个实例同时运行也不会写进同一个文件;
|
||||
// - 文件异步写入且队列有界,队列满时丢弃日志,避免磁盘 I/O 阻塞抢购主链路;
|
||||
// - 内存环形缓冲带自增 ID,界面可以按 ID 增量拉取;
|
||||
// - 条目带分类与账号标签,便于按账号观察抢购链路。
|
||||
package logger
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
)
|
||||
|
||||
// 日志级别。
|
||||
const (
|
||||
LevelDebug = "debug"
|
||||
LevelInfo = "info"
|
||||
LevelSuccess = "success"
|
||||
LevelWarn = "warn"
|
||||
LevelError = "error"
|
||||
)
|
||||
|
||||
const (
|
||||
entryTimeLayout = "15:04:05.000"
|
||||
lineTimeLayout = "2006-01-02 15:04:05.000"
|
||||
)
|
||||
|
||||
// Entry 是一条结构化日志。
|
||||
type Entry struct {
|
||||
ID int64 `json:"id"`
|
||||
Time string `json:"time"`
|
||||
Level string `json:"level"`
|
||||
Category string `json:"category"`
|
||||
Account string `json:"account"`
|
||||
Message string `json:"message"`
|
||||
|
||||
// at 只用于落盘,保证文件里带完整日期(不参与 JSON 序列化)。
|
||||
at time.Time
|
||||
}
|
||||
|
||||
var minLevel atomic.Int32
|
||||
|
||||
var (
|
||||
emitterMu sync.RWMutex
|
||||
emitter func(Entry)
|
||||
)
|
||||
|
||||
// SetMinLevel 设置日志最低输出等级,低于该等级的日志(例如逐条网络请求的 debug)
|
||||
// 不会进入内存缓冲,也不会落盘。
|
||||
func SetMinLevel(level string) {
|
||||
minLevel.Store(int32(levelPriority(level)))
|
||||
}
|
||||
|
||||
// MinLevel 返回当前最低输出等级名。
|
||||
func MinLevel() string {
|
||||
switch minLevel.Load() {
|
||||
case -1:
|
||||
return LevelDebug
|
||||
case 1:
|
||||
return LevelWarn
|
||||
case 2:
|
||||
return LevelError
|
||||
default:
|
||||
return LevelInfo
|
||||
}
|
||||
}
|
||||
|
||||
// SetEmitter 注册日志推送回调(界面用来实时显示日志)。传 nil 表示取消。
|
||||
func SetEmitter(fn func(Entry)) {
|
||||
emitterMu.Lock()
|
||||
emitter = fn
|
||||
emitterMu.Unlock()
|
||||
}
|
||||
|
||||
func currentEmitter() func(Entry) {
|
||||
emitterMu.RLock()
|
||||
defer emitterMu.RUnlock()
|
||||
return emitter
|
||||
}
|
||||
|
||||
func levelPriority(level string) int {
|
||||
switch strings.ToLower(strings.TrimSpace(level)) {
|
||||
case LevelDebug:
|
||||
return -1
|
||||
case LevelWarn:
|
||||
return 1
|
||||
case LevelError:
|
||||
return 2
|
||||
case "", LevelInfo, LevelSuccess:
|
||||
return 0
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
func normalizeLevel(level string) string {
|
||||
switch strings.ToLower(strings.TrimSpace(level)) {
|
||||
case LevelDebug:
|
||||
return LevelDebug
|
||||
case LevelWarn:
|
||||
return LevelWarn
|
||||
case LevelError:
|
||||
return LevelError
|
||||
case LevelSuccess:
|
||||
return LevelSuccess
|
||||
default:
|
||||
return LevelInfo
|
||||
}
|
||||
}
|
||||
|
||||
// LogEvent 输出带分类和级别的结构化日志。
|
||||
func LogEvent(category, level, format string, args ...any) {
|
||||
logEntry(category, level, "", format, args...)
|
||||
}
|
||||
|
||||
// LogAccountEvent 输出带账号标签的结构化日志,便于界面按账号观察抢购链路。
|
||||
func LogAccountEvent(category, level, account string, format string, args ...any) {
|
||||
logEntry(category, level, account, format, args...)
|
||||
}
|
||||
|
||||
func logEntry(category, level, account, format string, args ...any) {
|
||||
level = normalizeLevel(level)
|
||||
if levelPriority(level) < int(minLevel.Load()) {
|
||||
return
|
||||
}
|
||||
if category = strings.TrimSpace(category); category == "" {
|
||||
category = "系统"
|
||||
}
|
||||
now := time.Now()
|
||||
entry := Entry{
|
||||
Time: now.Format(entryTimeLayout),
|
||||
Level: level,
|
||||
Category: category,
|
||||
Account: account,
|
||||
Message: fmt.Sprintf(format, args...),
|
||||
at: now,
|
||||
}
|
||||
if current := currentSink(); current != nil {
|
||||
current.write(entry)
|
||||
}
|
||||
}
|
||||
|
||||
// formatLogLine 把条目渲染成落盘的一行文本。
|
||||
func formatLogLine(entry Entry) string {
|
||||
at := entry.at
|
||||
if at.IsZero() {
|
||||
at = time.Now()
|
||||
}
|
||||
prefix := at.Format(lineTimeLayout)
|
||||
if entry.Account != "" {
|
||||
return fmt.Sprintf("%s [%s][%s][账号:%s] %s\n", prefix, entry.Category, entry.Level, entry.Account, entry.Message)
|
||||
}
|
||||
return fmt.Sprintf("%s [%s][%s] %s\n", prefix, entry.Category, entry.Level, entry.Message)
|
||||
}
|
||||
|
||||
// logFileHeader 说明日志格式与运行上下文,多实例日志汇总后仍能分清来源。
|
||||
func logFileHeader(instanceName, instanceID, dataDir string) string {
|
||||
if instanceName == "" {
|
||||
instanceName = "未知实例"
|
||||
}
|
||||
if instanceID == "" {
|
||||
instanceID = "unknown"
|
||||
}
|
||||
var b strings.Builder
|
||||
b.WriteString("==================================================================\n")
|
||||
fmt.Fprintf(&b, "实例: %s (%s)\n", instanceName, instanceID)
|
||||
if dataDir != "" {
|
||||
fmt.Fprintf(&b, "数据目录: %s\n", dataDir)
|
||||
}
|
||||
b.WriteString("时间格式: YYYY-MM-DD HH:MM:SS.mmm [分类][级别][账号] 正文\n")
|
||||
b.WriteString("逐条网络请求为 debug 级,默认不显示;排查时把日志等级改成 debug\n")
|
||||
b.WriteString("==================================================================\n")
|
||||
return b.String()
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
package logger
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
defaultMaxFileBytes = 5 << 20 // 单个日志文件上限 5MB
|
||||
defaultBackups = 5 // 最多保留 5 个滚动文件
|
||||
)
|
||||
|
||||
// fileWriter 负责把日志追加写入实例独占的文件,超过大小上限时按 .1/.2/... 滚动。
|
||||
//
|
||||
// 文件名在创建时就用 O_EXCL 抢占,因此同一实例目录下不会出现两个进程写同一个
|
||||
// 文件的情况(多开时每个实例有各自的目录,重启则拿到新的时间戳文件)。
|
||||
type fileWriter struct {
|
||||
mu sync.Mutex
|
||||
dir string
|
||||
path string
|
||||
file *os.File
|
||||
size int64
|
||||
maxBytes int64
|
||||
backups int
|
||||
}
|
||||
|
||||
// newFileWriter 在 dir 下创建一个独占的日志文件。
|
||||
func newFileWriter(dir, instanceID string) (*fileWriter, error) {
|
||||
if dir == "" {
|
||||
return nil, errors.New("日志目录为空")
|
||||
}
|
||||
if err := os.MkdirAll(dir, 0o755); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if instanceID == "" {
|
||||
instanceID = "default"
|
||||
}
|
||||
base := filepath.Join(dir, fmt.Sprintf("huya-go_%s_%s", instanceID, time.Now().Format("20060102_150405")))
|
||||
file, path, err := createUniqueLogFile(base)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
w := &fileWriter{
|
||||
dir: dir,
|
||||
path: path,
|
||||
file: file,
|
||||
maxBytes: defaultMaxFileBytes,
|
||||
backups: defaultBackups,
|
||||
}
|
||||
if info, err := file.Stat(); err == nil {
|
||||
w.size = info.Size()
|
||||
}
|
||||
return w, nil
|
||||
}
|
||||
|
||||
// createUniqueLogFile 以 O_EXCL 递增后缀创建日志文件。
|
||||
// 秒级时间戳相同(例如重启)时自动追加 -2 / -3 后缀,避免两个进程写进同一个文件。
|
||||
func createUniqueLogFile(base string) (*os.File, string, error) {
|
||||
for i := 1; i <= 50; i++ {
|
||||
path := base + ".log"
|
||||
if i > 1 {
|
||||
path = fmt.Sprintf("%s-%d.log", base, i)
|
||||
}
|
||||
file, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o644)
|
||||
if err == nil {
|
||||
return file, path, nil
|
||||
}
|
||||
if !errors.Is(err, os.ErrExist) {
|
||||
return nil, "", err
|
||||
}
|
||||
}
|
||||
return nil, "", fmt.Errorf("日志文件名连续冲突: %s", base)
|
||||
}
|
||||
|
||||
// Dir 返回日志目录。
|
||||
func (w *fileWriter) Dir() string { return w.dir }
|
||||
|
||||
// Path 返回当前日志文件路径。
|
||||
func (w *fileWriter) Path() string {
|
||||
w.mu.Lock()
|
||||
defer w.mu.Unlock()
|
||||
return w.path
|
||||
}
|
||||
|
||||
// Write 追加一段日志,必要时先滚动。
|
||||
func (w *fileWriter) Write(p []byte) (int, error) {
|
||||
w.mu.Lock()
|
||||
defer w.mu.Unlock()
|
||||
if w.file == nil {
|
||||
return 0, errors.New("日志文件已关闭")
|
||||
}
|
||||
if w.maxBytes > 0 && w.size+int64(len(p)) > w.maxBytes {
|
||||
if err := w.rotateLocked(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
}
|
||||
n, err := w.file.Write(p)
|
||||
w.size += int64(n)
|
||||
return n, err
|
||||
}
|
||||
|
||||
// rotateLocked 关闭当前文件并重命名成 .1/.2/...,然后重新打开一个同名文件。
|
||||
// 调用方必须已持有 w.mu。
|
||||
func (w *fileWriter) rotateLocked() error {
|
||||
_ = w.file.Close()
|
||||
w.file = nil
|
||||
|
||||
for i := w.backups - 1; i >= 1; i-- {
|
||||
from := fmt.Sprintf("%s.%d", w.path, i)
|
||||
if _, err := os.Stat(from); err != nil {
|
||||
continue
|
||||
}
|
||||
_ = os.Rename(from, fmt.Sprintf("%s.%d", w.path, i+1))
|
||||
}
|
||||
if _, err := os.Stat(w.path); err == nil {
|
||||
_ = os.Rename(w.path, w.path+".1")
|
||||
}
|
||||
|
||||
file, err := os.OpenFile(w.path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
w.file = file
|
||||
w.size = 0
|
||||
return nil
|
||||
}
|
||||
|
||||
// Close 关闭当前文件。
|
||||
func (w *fileWriter) Close() error {
|
||||
if w == nil {
|
||||
return nil
|
||||
}
|
||||
w.mu.Lock()
|
||||
defer w.mu.Unlock()
|
||||
if w.file == nil {
|
||||
return nil
|
||||
}
|
||||
err := w.file.Close()
|
||||
w.file = nil
|
||||
return err
|
||||
}
|
||||
|
||||
// writeHeader 把实例信息写在文件开头,确保排在任何日志之前。
|
||||
func (w *fileWriter) writeHeader(instanceName, instanceID, dataDir string) {
|
||||
w.mu.Lock()
|
||||
defer w.mu.Unlock()
|
||||
if w.file == nil {
|
||||
return
|
||||
}
|
||||
header := logFileHeader(instanceName, instanceID, dataDir)
|
||||
if _, err := w.file.WriteString(header); err != nil {
|
||||
return
|
||||
}
|
||||
w.size += int64(len(header))
|
||||
}
|
||||
@@ -0,0 +1,156 @@
|
||||
package logger
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// sink 是日志输出汇集点,把结构化条目分发到内存缓冲、日志文件与界面回调。
|
||||
type sink struct {
|
||||
store *Store
|
||||
file *fileWriter
|
||||
async *AsyncWriter
|
||||
}
|
||||
|
||||
var (
|
||||
sinkMu sync.RWMutex
|
||||
globalSink *sink
|
||||
globalClose func()
|
||||
)
|
||||
|
||||
// Init 初始化日志输出:内存缓冲、日志文件与界面回调同时生效。
|
||||
//
|
||||
// instanceName / instanceID / dataDir 只用于写文件表头,便于把多实例日志
|
||||
// 复制或汇总后仍能看出是哪台机器的哪个实例。
|
||||
// 返回的 close 函数必须先调用(保证队列落盘),再由调用方关闭其它资源。
|
||||
func Init(store *Store, logDir, instanceName, instanceID, dataDir string) (func(), error) {
|
||||
if store == nil {
|
||||
store = NewStore(500)
|
||||
}
|
||||
if level := os.Getenv("HUYA_LOG_LEVEL"); level != "" {
|
||||
SetMinLevel(level)
|
||||
}
|
||||
|
||||
// 解析为绝对路径,避免打包后工作目录不同导致日志写到意外位置。
|
||||
logDir = resolveAbsolutePath(logDir)
|
||||
store.SetFilePath("")
|
||||
|
||||
file, err := newFileWriter(logDir, instanceID)
|
||||
if err != nil {
|
||||
// 日志文件不可用时降级为「仅内存 + 界面」,不影响主流程。
|
||||
replaceSink(&sink{store: store}, nil)
|
||||
LogEvent("日志", LevelWarn, "日志文件不可用,日志仅保留在内存: %v", err)
|
||||
return func() { closeSink() }, err
|
||||
}
|
||||
|
||||
file.writeHeader(instanceName, instanceID, dataDir)
|
||||
store.SetFilePath(file.Path())
|
||||
|
||||
replaceSink(&sink{
|
||||
store: store,
|
||||
file: file,
|
||||
async: NewAsyncWriter(file, asyncBufferSize),
|
||||
}, func() { closeSink() })
|
||||
|
||||
LogEvent("日志", LevelSuccess, "日志文件已启用: %s", file.Path())
|
||||
return func() { closeSink() }, nil
|
||||
}
|
||||
|
||||
func replaceSink(next *sink, closeFn func()) {
|
||||
sinkMu.Lock()
|
||||
previous := globalClose
|
||||
globalSink = next
|
||||
globalClose = closeFn
|
||||
sinkMu.Unlock()
|
||||
if previous != nil {
|
||||
previous()
|
||||
}
|
||||
}
|
||||
|
||||
func currentSink() *sink {
|
||||
sinkMu.RLock()
|
||||
defer sinkMu.RUnlock()
|
||||
return globalSink
|
||||
}
|
||||
|
||||
func closeSink() {
|
||||
sinkMu.Lock()
|
||||
current := globalSink
|
||||
globalSink = nil
|
||||
globalClose = nil
|
||||
sinkMu.Unlock()
|
||||
if current == nil {
|
||||
return
|
||||
}
|
||||
if current.async != nil {
|
||||
_ = current.async.Close()
|
||||
}
|
||||
if current.file != nil {
|
||||
_ = current.file.Close()
|
||||
}
|
||||
}
|
||||
|
||||
func (s *sink) write(entry Entry) {
|
||||
if s == nil {
|
||||
return
|
||||
}
|
||||
if s.store != nil {
|
||||
entry = s.store.Append(entry)
|
||||
}
|
||||
if s.async != nil {
|
||||
_, _ = s.async.Write([]byte(formatLogLine(entry)))
|
||||
} else if s.file != nil {
|
||||
_, _ = s.file.Write([]byte(formatLogLine(entry)))
|
||||
}
|
||||
if emit := currentEmitter(); emit != nil {
|
||||
emit(entry)
|
||||
}
|
||||
}
|
||||
|
||||
// Dir 返回当前日志目录(无文件日志时返回空串)。
|
||||
func Dir() string {
|
||||
current := currentSink()
|
||||
if current == nil || current.file == nil {
|
||||
return ""
|
||||
}
|
||||
return current.file.Dir()
|
||||
}
|
||||
|
||||
// FilePath 返回当前日志文件路径(无文件日志时返回空串)。
|
||||
func FilePath() string {
|
||||
current := currentSink()
|
||||
if current == nil || current.file == nil {
|
||||
return ""
|
||||
}
|
||||
return current.file.Path()
|
||||
}
|
||||
|
||||
// Dropped 返回因队列满被丢弃的日志条数。
|
||||
func Dropped() uint64 {
|
||||
current := currentSink()
|
||||
if current == nil || current.async == nil {
|
||||
return 0
|
||||
}
|
||||
return current.async.Dropped()
|
||||
}
|
||||
|
||||
// LevelFromString 把用户输入的等级名归一化,非法值回退为 info。
|
||||
func LevelFromString(level string) string {
|
||||
return normalizeLevel(strings.TrimSpace(level))
|
||||
}
|
||||
|
||||
// resolveAbsolutePath 把相对路径解析为绝对路径,便于日志里直接复制路径排查。
|
||||
func resolveAbsolutePath(path string) string {
|
||||
if path == "" || filepath.IsAbs(path) {
|
||||
return path
|
||||
}
|
||||
if abs, err := filepath.Abs(path); err == nil {
|
||||
return abs
|
||||
}
|
||||
if exe, err := os.Executable(); err == nil {
|
||||
return filepath.Join(filepath.Dir(exe), path)
|
||||
}
|
||||
return path
|
||||
}
|
||||
@@ -0,0 +1,200 @@
|
||||
package logger
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func initForTest(t *testing.T) (*Store, string, func()) {
|
||||
t.Helper()
|
||||
dir := t.TempDir()
|
||||
store := NewStore(200)
|
||||
closeLog, err := Init(store, dir, "测试实例", "test", dir)
|
||||
if err != nil {
|
||||
t.Fatalf("Init() error = %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
SetMinLevel(LevelInfo)
|
||||
SetEmitter(nil)
|
||||
})
|
||||
return store, FilePath(), closeLog
|
||||
}
|
||||
|
||||
// TestInitWritesHeaderAndStructuredLines 验证日志文件带实例表头,
|
||||
// 且每一行包含分类、级别与账号标签。
|
||||
func TestInitWritesHeaderAndStructuredLines(t *testing.T) {
|
||||
store, path, closeLog := initForTest(t)
|
||||
if path == "" {
|
||||
t.Fatal("日志文件路径为空")
|
||||
}
|
||||
|
||||
LogEvent("配置", LevelInfo, "活动 SID=%d", 2203)
|
||||
LogAccountEvent("监控", LevelSuccess, "88231", "兑换成功 pid=%d", 12889)
|
||||
closeLog()
|
||||
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatalf("读取日志文件失败: %v", err)
|
||||
}
|
||||
text := string(data)
|
||||
|
||||
for _, want := range []string{
|
||||
"实例: 测试实例 (test)",
|
||||
"数据目录:",
|
||||
"[配置][info] 活动 SID=2203",
|
||||
"[监控][success][账号:88231] 兑换成功 pid=12889",
|
||||
} {
|
||||
if !strings.Contains(text, want) {
|
||||
t.Fatalf("日志文件缺少 %q:\n%s", want, text)
|
||||
}
|
||||
}
|
||||
if store.Count() < 3 {
|
||||
t.Fatalf("内存日志条数 = %d, want >= 3", store.Count())
|
||||
}
|
||||
}
|
||||
|
||||
// TestUniqueLogFileAvoidsSameSecondCollision 同一秒内两次创建也不能拿到同一个文件:
|
||||
// 多开或快速重启时,两个进程写同一个文件会让日志互相污染。
|
||||
func TestUniqueLogFileAvoidsSameSecondCollision(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
first, err := newFileWriter(dir, "test")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer first.Close()
|
||||
second, err := newFileWriter(dir, "test")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer second.Close()
|
||||
|
||||
if first.Path() == second.Path() {
|
||||
t.Fatalf("两个进程拿到了同一个日志文件: %s", first.Path())
|
||||
}
|
||||
if filepath.Dir(first.Path()) != dir {
|
||||
t.Fatalf("日志目录 = %q, want %q", filepath.Dir(first.Path()), dir)
|
||||
}
|
||||
}
|
||||
|
||||
// TestFileWriterRotatesAndDropsOldest 验证按大小滚动并丢弃最旧的备份。
|
||||
func TestFileWriterRotatesAndDropsOldest(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
writer, err := newFileWriter(dir, "test")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer writer.Close()
|
||||
writer.maxBytes = 200
|
||||
writer.backups = 2
|
||||
|
||||
for i := 0; i < 60; i++ {
|
||||
if _, err := writer.Write([]byte(fmt.Sprintf("第 %d 条日志,用于触发滚动\n", i))); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
if _, err := os.Stat(writer.Path() + ".1"); err != nil {
|
||||
t.Fatalf("期望存在滚动文件 .1: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(writer.Path() + ".2"); err != nil {
|
||||
t.Fatalf("期望存在滚动文件 .2: %v", err)
|
||||
}
|
||||
if _, err := os.Stat(writer.Path() + ".3"); err == nil {
|
||||
t.Fatal("backups=2 时不应出现 .3")
|
||||
}
|
||||
}
|
||||
|
||||
type blockingWriter struct {
|
||||
release chan struct{}
|
||||
}
|
||||
|
||||
func (w blockingWriter) Write(p []byte) (int, error) {
|
||||
<-w.release
|
||||
return len(p), nil
|
||||
}
|
||||
|
||||
// TestAsyncWriterDropsInsteadOfBlocking 队列满时必须丢弃日志而不是阻塞调用方,
|
||||
// 否则抢购主链路会被磁盘 I/O 拖住。
|
||||
func TestAsyncWriterDropsInsteadOfBlocking(t *testing.T) {
|
||||
release := make(chan struct{})
|
||||
writer := NewAsyncWriter(blockingWriter{release: release}, 1)
|
||||
|
||||
start := time.Now()
|
||||
for i := 0; i < 100; i++ {
|
||||
if _, err := writer.Write([]byte("x\n")); err != nil {
|
||||
t.Fatalf("Write() error = %v", err)
|
||||
}
|
||||
}
|
||||
if elapsed := time.Since(start); elapsed > time.Second {
|
||||
t.Fatalf("写入被阻塞了 %s", elapsed)
|
||||
}
|
||||
if writer.Dropped() == 0 {
|
||||
t.Fatal("队列满时应记录丢弃条数")
|
||||
}
|
||||
|
||||
close(release)
|
||||
if err := writer.Close(); err != nil {
|
||||
t.Fatalf("Close() error = %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestStoreSinceIsIncremental 验证界面增量拉取语义:只返回 ID 更大的日志。
|
||||
func TestStoreSinceIsIncremental(t *testing.T) {
|
||||
store := NewStore(3)
|
||||
first := store.Append(Entry{Message: "第一条"})
|
||||
if first.ID == 0 {
|
||||
t.Fatal("Append 应分配自增 ID")
|
||||
}
|
||||
store.Append(Entry{Message: "第二条"})
|
||||
|
||||
if got := store.Since(0); len(got) != 2 {
|
||||
t.Fatalf("Since(0) 条数 = %d, want 2", len(got))
|
||||
}
|
||||
if got := store.Since(first.ID); len(got) != 1 || got[0].Message != "第二条" {
|
||||
t.Fatalf("Since(first) = %+v", got)
|
||||
}
|
||||
|
||||
// 超出容量时丢弃最旧的条目。
|
||||
store.Append(Entry{Message: "第三条"})
|
||||
store.Append(Entry{Message: "第四条"})
|
||||
if got := store.Since(0); len(got) != 3 || got[0].Message != "第二条" {
|
||||
t.Fatalf("环形缓冲 = %+v", got)
|
||||
}
|
||||
if store.Count() != 3 {
|
||||
t.Fatalf("Count() = %d, want 3", store.Count())
|
||||
}
|
||||
}
|
||||
|
||||
// TestMinLevelFiltersDebug 低等级日志不进入内存缓冲,也不落盘。
|
||||
func TestMinLevelFiltersDebug(t *testing.T) {
|
||||
store, _, closeLog := initForTest(t)
|
||||
defer func() {
|
||||
SetMinLevel(LevelInfo)
|
||||
closeLog()
|
||||
}()
|
||||
|
||||
SetMinLevel(LevelDebug)
|
||||
LogEvent("网络", LevelDebug, "debug 应保留")
|
||||
if MinLevel() != LevelDebug {
|
||||
t.Fatalf("MinLevel() = %q", MinLevel())
|
||||
}
|
||||
|
||||
SetMinLevel(LevelError)
|
||||
LogEvent("网络", LevelDebug, "debug 应被过滤")
|
||||
if MinLevel() != LevelError {
|
||||
t.Fatalf("MinLevel() = %q", MinLevel())
|
||||
}
|
||||
|
||||
for _, entry := range store.Since(0) {
|
||||
if entry.Message == "debug 应被过滤" {
|
||||
t.Fatal("低于最低等级的日志不应进入内存缓冲")
|
||||
}
|
||||
}
|
||||
if got := LevelFromString("不是等级"); got != LevelInfo {
|
||||
t.Fatalf("LevelFromString(非法) = %q, want info", got)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
package logger
|
||||
|
||||
import "sync"
|
||||
|
||||
// Store 是内存日志环形缓冲,供界面增量拉取。
|
||||
type Store struct {
|
||||
mu sync.RWMutex
|
||||
nextID int64
|
||||
max int
|
||||
filePath string
|
||||
entries []Entry
|
||||
}
|
||||
|
||||
// NewStore 创建内存日志缓冲,最多保留 max 条最新日志。
|
||||
func NewStore(max int) *Store {
|
||||
if max <= 0 {
|
||||
max = 500
|
||||
}
|
||||
return &Store{
|
||||
max: max,
|
||||
entries: make([]Entry, 0, max),
|
||||
}
|
||||
}
|
||||
|
||||
// Append 追加一条日志,由内部署分配自增 ID;超过容量时丢弃最旧的条目。
|
||||
func (s *Store) Append(entry Entry) Entry {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
s.nextID++
|
||||
entry.ID = s.nextID
|
||||
s.entries = append(s.entries, entry)
|
||||
if len(s.entries) > s.max {
|
||||
s.entries = append([]Entry(nil), s.entries[len(s.entries)-s.max:]...)
|
||||
}
|
||||
return entry
|
||||
}
|
||||
|
||||
// Since 返回 ID 大于 since 的日志,用于界面增量拉取。
|
||||
func (s *Store) Since(since int64) []Entry {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
out := make([]Entry, 0, len(s.entries))
|
||||
for _, entry := range s.entries {
|
||||
if entry.ID > since {
|
||||
out = append(out, entry)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// Count 返回当前缓冲内的日志条数。
|
||||
func (s *Store) Count() int {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
return len(s.entries)
|
||||
}
|
||||
|
||||
// SetFilePath 保存当前日志文件路径。
|
||||
func (s *Store) SetFilePath(path string) {
|
||||
s.mu.Lock()
|
||||
defer s.mu.Unlock()
|
||||
s.filePath = path
|
||||
}
|
||||
|
||||
// FilePath 返回当前日志文件路径。
|
||||
func (s *Store) FilePath() string {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
return s.filePath
|
||||
}
|
||||
Reference in New Issue
Block a user