新增实例槽位隔离与结构化日志,多开不再共用日志与账号

This commit is contained in:
yml2213
2026-10-14 21:32:49 +08:00
parent f96fa7d858
commit 8c4b15066f
27 changed files with 2011 additions and 468 deletions
+94
View File
@@ -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
}
+179
View File
@@ -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()
}
+159
View File
@@ -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))
}
+156
View File
@@ -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
}
+200
View File
@@ -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)
}
}
+70
View File
@@ -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
}