Files
go-sms-V2/internal/service/channel/log.go
T

241 lines
6.0 KiB
Go

// log.go Day 40(A-3.14):通道日志异步落库器。
// 设计要点(遵循 Day 39.6 容量规划,MySQL 严禁阻塞发送主链路):
// - 提交/回执海量事件 → 内存队列(非阻塞投递,满则丢弃计数)+ 单 writer 批量落库;
// - submit/deliver 成功事件按 10s 窗口聚合成行(count/latency 均值),失败类逐条(量低+排障价值);
// - connect/disconnect/stop/alert 逐条。
package channel
import (
"sync"
"sync/atomic"
"time"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/logger"
"go-sms/internal/service/channel/pool"
"go.uber.org/zap"
"gorm.io/gorm"
)
// 日志 kind 常量:定义随链路域移驻 pool 子包(S1-B P2),此处经 pool.LogKind* 引用。
const (
logQueueCap = 2048 // 内存队列容量(满则丢弃,绝不阻塞提交)
logFlushBatch = 200 // 批量落库条数
logFlushEvery = 2 * time.Second // 刷库周期
logAggWindow = 10 * time.Second // submit/deliver 聚合窗口
)
// logEvent 单条内存事件(聚合前)。
type logEvent struct {
ChannelID int64
Kind string
Level int8
MsgID string
Detail string
LatencyMs int
At time.Time
}
// aggKey 聚合桶键。
type aggKey struct {
ChannelID int64
Kind string
Bucket int64 // logAggWindow 对齐的窗口起点 unix 秒
}
// aggVal 聚合累计值。
type aggVal struct {
count int
latSum int
firstAt time.Time
}
// ChannelLogger 通道日志落库器(nil 安全:未注入时全部 no-op)。
type ChannelLogger struct {
db *gorm.DB
ch chan logEvent
done chan struct{}
wg sync.WaitGroup
dropped atomic.Int64
mu sync.Mutex
agg map[aggKey]*aggVal
}
// NewChannelLogger 构造并启动后台 writer goroutine。
func NewChannelLogger(db *gorm.DB) *ChannelLogger {
l := &ChannelLogger{
db: db, ch: make(chan logEvent, logQueueCap),
done: make(chan struct{}), agg: map[aggKey]*aggVal{},
}
l.wg.Add(1)
go l.run()
return l
}
// Log 非阻塞投递(nil 安全;队列满丢弃计数——监控链路不背发送链路的锅)。
func (l *ChannelLogger) Log(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) {
if l == nil {
return
}
select {
case l.ch <- logEvent{ChannelID: channelID, Kind: kind, Level: level, MsgID: msgID,
Detail: detail, LatencyMs: latencyMs, At: time.Now()}:
default:
n := l.dropped.Add(1)
if n%1000 == 1 { // 限频告警:首个与每千次
logger.L().Warn("channel_log_dropped", zap.Int64("dropped", n))
}
}
}
// FlushNow 立即冲刷聚合桶与队列(测试/优雅停机用)。
func (l *ChannelLogger) FlushNow() {
if l == nil {
return
}
// 排空队列:直写行先收集,聚合事件进桶。
var direct []entity.ChannelLog
for {
select {
case e := <-l.ch:
direct = append(direct, l.ingest(e)...)
continue
default:
}
break
}
l.writeRows(direct)
l.flushAgg(time.Now())
}
// Close 冲刷并停止(幂等)。
func (l *ChannelLogger) Close() {
if l == nil {
return
}
select {
case <-l.done:
return // 已关闭
default:
close(l.done)
}
l.wg.Wait()
}
// run 后台循环:收事件→聚合/缓冲→周期批量落库。
func (l *ChannelLogger) run() {
defer l.wg.Done()
tick := time.NewTicker(logFlushEvery)
defer tick.Stop()
var aggBuf []entity.ChannelLog
for {
select {
case e := <-l.ch:
l.writeRows(l.ingest(e)) // 直写行(连接事件/失败)即时落库(低频,时序确定);submit/deliver 只进聚合桶
case <-tick.C:
aggBuf = l.flushAggTo(aggBuf, time.Now())
if len(aggBuf) > 0 {
aggBuf = l.writeRows(aggBuf)
}
case <-l.done:
// 终态冲刷:排空队列+聚合桶后退出。
for {
select {
case e := <-l.ch:
l.writeRows(l.ingest(e))
continue
default:
}
break
}
l.flushAgg(time.Now())
return
}
}
}
// ingest 单事件处理:可聚合 kind 进桶(返回空),其余返回待写行。
func (l *ChannelLogger) ingest(e logEvent) []entity.ChannelLog {
switch e.Kind {
case pool.LogKindSubmit, pool.LogKindDeliver:
k := aggKey{ChannelID: e.ChannelID, Kind: e.Kind, Bucket: e.At.Unix() / int64(logAggWindow/time.Second)}
l.mu.Lock()
v, ok := l.agg[k]
if !ok {
v = &aggVal{firstAt: e.At}
l.agg[k] = v
}
v.count++
v.latSum += e.LatencyMs
l.mu.Unlock()
return nil
default:
return []entity.ChannelLog{e.row()}
}
}
// flushAgg 冲刷全部聚合桶(当前窗口一并落库,快照语义;now 预留快照时刻)。
func (l *ChannelLogger) flushAgg(_ time.Time) {
l.mu.Lock()
rows := make([]entity.ChannelLog, 0, len(l.agg))
for k, v := range l.agg {
rows = append(rows, entity.ChannelLog{
ChannelID: k.ChannelID, Kind: k.Kind,
Detail: "窗口聚合",
Count: v.count,
LatencyMs: avgLat(v.latSum, v.count),
})
delete(l.agg, k)
}
l.mu.Unlock()
l.writeRows(rows)
}
// flushAggTo 把过期聚合桶(窗口已闭合)转为待写行,追加到 buf。
func (l *ChannelLogger) flushAggTo(buf []entity.ChannelLog, now time.Time) []entity.ChannelLog {
cur := now.Unix() / int64(logAggWindow/time.Second)
l.mu.Lock()
for k, v := range l.agg {
if k.Bucket >= cur {
continue // 当前窗口未闭合
}
buf = append(buf, entity.ChannelLog{
ChannelID: k.ChannelID, Kind: k.Kind,
Detail: "窗口聚合", Count: v.count, LatencyMs: avgLat(v.latSum, v.count),
})
delete(l.agg, k)
}
l.mu.Unlock()
return buf
}
// writeRows 批量落库(失败仅告警,不中断 writer)。
func (l *ChannelLogger) writeRows(rows []entity.ChannelLog) []entity.ChannelLog {
if len(rows) == 0 {
return rows[:0]
}
if err := l.db.CreateInBatches(rows, logFlushBatch).Error; err != nil {
logger.L().Warn("channel_log_write_failed", zap.Int64("rows", int64(len(rows))))
}
return rows[:0]
}
// row 内存事件转实体行。
func (e logEvent) row() entity.ChannelLog {
return entity.ChannelLog{
ChannelID: e.ChannelID, Kind: e.Kind, Level: e.Level,
MsgID: e.MsgID, Detail: e.Detail, Count: 1, LatencyMs: e.LatencyMs,
}
}
func avgLat(sum, n int) int {
if n == 0 {
return 0
}
return sum / n
}