Bug fix.

Author: xOS

db/badger.go

@@ -170,9 +170,9 @@ func (b *BadgerDB) startMaintenance() {
 		for {
 			select {
 			case <-ticker.C:
-				// 值日志GC - 智能阈值
-				err := b.db.RunValueLogGC(0.7)
-				if err != nil && err != badger.ErrNoRewrite {
+				// 值日志GC - 单次周期内尝试多轮回收，提升清理效果
+				_, _, err := b.RunValueLogGCWithStats(0.7, 3)
+				if err != nil {
 					log.Printf("Value log GC failed: %v", err)
 				}
 
@@ -188,6 +188,28 @@ func (b *BadgerDB) startMaintenance() {
 	}()
 }
 
+// RunValueLogGCWithStats runs bounded ValueLog GC rounds and returns execution stats.
+func (b *BadgerDB) RunValueLogGCWithStats(discardRatio float64, maxRounds int) (int, bool, error) {
+	if maxRounds <= 0 {
+		maxRounds = 1
+	}
+
+	rounds := 0
+	for i := 0; i < maxRounds; i++ {
+		err := b.db.RunValueLogGC(discardRatio)
+		if err == nil {
+			rounds++
+			continue
+		}
+		if err == badger.ErrNoRewrite {
+			return rounds, true, nil
+		}
+		return rounds, false, err
+	}
+
+	return rounds, false, nil
+}
+
 // SaveModel saves a model to the database
 func (b *BadgerDB) SaveModel(modelType string, id uint64, model interface{}) error {
 	key := fmt.Sprintf("%s:%d", modelType, id)

db/model_ops.go

@@ -6,6 +6,7 @@ import (
 	"log"
 	"sort"
 	"strconv"
+	"strings"
 	"sync"
 	"time"
 
@@ -371,24 +372,48 @@ func (o *MonitorHistoryOps) GetMonitorHistoriesByServerAndMonitorRangeReverseLim
 
 // CleanupOldMonitorHistories removes monitor histories older than maxAge
 func (o *MonitorHistoryOps) CleanupOldMonitorHistories(maxAge time.Duration) (int, error) {
-	// Get all monitor IDs
-	serverOps := NewServerOps(o.db)
-	servers, err := serverOps.GetAllServers()
+	cutoffNano := time.Now().Add(-maxAge).UnixNano()
+	keys, err := o.db.GetKeysWithPrefix("monitor_history:")
 	if err != nil {
 		return 0, err
 	}
 
-	totalDeleted := 0
-	for _, server := range servers {
-		prefix := fmt.Sprintf("monitor_history:%d", server.ID)
-		deleted, err := o.db.CleanupExpiredData(prefix, maxAge)
-		if err != nil {
-			return totalDeleted, err
+	keysToDelete := make([]string, 0, len(keys)/2)
+	for _, key := range keys {
+		idx := strings.LastIndexByte(key, ':')
+		if idx <= 0 || idx+1 >= len(key) {
+			continue
+		}
+
+		ts, parseErr := strconv.ParseInt(key[idx+1:], 10, 64)
+		if parseErr != nil {
+			continue
+		}
+
+		if ts <= cutoffNano {
+			keysToDelete = append(keysToDelete, key)
 		}
-		totalDeleted += deleted
 	}
 
-	return totalDeleted, nil
+	if len(keysToDelete) == 0 {
+		return 0, nil
+	}
+
+	// Batch delete in one write transaction to reduce lock and txn overhead.
+	o.db.rwMutex.Lock()
+	defer o.db.rwMutex.Unlock()
+	if err := o.db.db.Update(func(txn *badger.Txn) error {
+		for _, key := range keysToDelete {
+			if delErr := txn.Delete([]byte(key)); delErr != nil {
+				return delErr
+			}
+		}
+		return nil
+	}); err != nil {
+		return 0, err
+	}
+
+	return len(keysToDelete), nil
 }
 
 // UserOps provides specialized operations for users

service/singleton/crontask.go

@@ -72,6 +72,13 @@ func InitCronTask() {
 		}
 	} else {
 		log.Println("BadgerDB模式：跳过注册GORM相关的定时任务")
+
+		// 每天凌晨 4:15 执行一次深度 value log GC，作为低峰期空间回收补充
+		if _, err := Cron.AddFunc("0 15 4 * * *", func() {
+			runBadgerValueLogGC("nightly-deep", 0.55, 20)
+		}); err != nil {
+			panic(err)
+		}
 	}
 }
 

service/singleton/singleton.go

@@ -721,6 +721,7 @@ func CleanMonitorHistory() (int64, error) {
 				// 只在清理了记录时才输出日志
 				if count > 0 {
 					log.Printf("BadgerDB监控历史清理完成，清理了%d条记录", count)
+					runBadgerValueLogGC("post-cleanup", 0.65, 10)
 				}
 				return int64(count), nil
 			}
@@ -951,6 +952,28 @@ func CleanMonitorHistory() (int64, error) {
 	return totalCleaned, nil
 }
 
+func runBadgerValueLogGC(trigger string, discardRatio float64, maxRounds int) {
+	if Conf == nil || Conf.DatabaseType != "badger" || db.DB == nil {
+		return
+	}
+
+	if isSystemBusy() {
+		log.Printf("系统繁忙，跳过BadgerDB ValueLog GC(%s)", trigger)
+		return
+	}
+
+	start := time.Now()
+	rounds, noRewrite, err := db.DB.RunValueLogGCWithStats(discardRatio, maxRounds)
+	if err != nil {
+		log.Printf("BadgerDB ValueLog GC失败(%s, ratio=%.2f, rounds=%d): %v", trigger, discardRatio, maxRounds, err)
+		return
+	}
+
+	if rounds > 0 || noRewrite {
+		log.Printf("BadgerDB ValueLog GC完成(%s): ratio=%.2f, rounds=%d, noRewrite=%t, cost=%s", trigger, discardRatio, rounds, noRewrite, time.Since(start))
+	}
+}
+
 // CleanCumulativeTransferData 清理累计流量数据
 func CleanCumulativeTransferData(days int) {
 	// 废弃TrafficManager, 仅保留函数框架
@@ -2363,6 +2386,10 @@ var (
 	monitorHistoryBatchBufferLock sync.Mutex
 	monitorHistoryBatchSize       = 100              // 默认批量大小，从50增加到100
 	monitorHistoryBatchInterval   = 10 * time.Second // 从3秒增加到10秒，降低处理频率
+
+	dbMaintenanceSchedulerStarted int32
+	dbOptimizeRunning             int32
+	dbWALCheckpointRunning        int32
 )
 
 // StartDBWriteWorker 启动数据库写入工作器
@@ -2953,45 +2980,85 @@ func StartDatabaseMaintenanceScheduler() {
 		return
 	}
 
+	// 避免重复启动维护调度器导致多个ticker并发执行
+	if !atomic.CompareAndSwapInt32(&dbMaintenanceSchedulerStarted, 0, 1) {
+		log.Println("数据库维护计划已启动，跳过重复启动")
+		return
+	}
+
 	log.Println("启动数据库维护计划...")
 
 	// 每6小时执行一次数据库优化
 	go func() {
-		// 启动时延迟30分钟再执行第一次优化，避免与启动时的其他操作冲突
-		time.Sleep(30 * time.Minute)
+		// 启动时延迟15分钟执行第一次优化，减少长期运行前的碎片积累
+		time.Sleep(15 * time.Minute)
+		runSQLiteMaintenanceCycle("startup")
 
 		ticker := time.NewTicker(6 * time.Hour)
 		defer ticker.Stop()
 
 		for range ticker.C {
-			if !isSystemBusy() {
-				OptimizeDatabase()
-			} else {
-				log.Println("系统繁忙，跳过定期数据库优化")
-			}
+			runSQLiteMaintenanceCycle("periodic")
 		}
 	}()
 
 	// 安排更频繁的WAL检查点（每小时）
 	go func() {
 		// 启动时延迟5分钟
 		time.Sleep(5 * time.Minute)
+		runSQLiteWALCheckpoint("startup")
 
 		ticker := time.NewTicker(1 * time.Hour)
 		defer ticker.Stop()
 
 		for range ticker.C {
-			if !isSystemBusy() {
-				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-				if err := DB.WithContext(ctx).Exec("PRAGMA wal_checkpoint(PASSIVE)").Error; err != nil {
-					log.Printf("执行WAL检查点失败: %v", err)
-				}
-				cancel()
-			}
+			runSQLiteWALCheckpoint("periodic")
 		}
 	}()
 }
 
+func runSQLiteMaintenanceCycle(trigger string) {
+	if Conf.DatabaseType == "badger" || DB == nil {
+		return
+	}
+
+	if !atomic.CompareAndSwapInt32(&dbOptimizeRunning, 0, 1) {
+		log.Printf("数据库优化任务仍在执行，跳过本次(%s)", trigger)
+		return
+	}
+	defer atomic.StoreInt32(&dbOptimizeRunning, 0)
+
+	if isSystemBusy() {
+		log.Printf("系统繁忙，跳过定期数据库优化(%s)", trigger)
+		return
+	}
+
+	OptimizeDatabase()
+}
+
+func runSQLiteWALCheckpoint(trigger string) {
+	if Conf.DatabaseType == "badger" || DB == nil {
+		return
+	}
+
+	if !atomic.CompareAndSwapInt32(&dbWALCheckpointRunning, 0, 1) {
+		log.Printf("WAL检查点任务仍在执行，跳过本次(%s)", trigger)
+		return
+	}
+	defer atomic.StoreInt32(&dbWALCheckpointRunning, 0)
+
+	if isSystemBusy() {
+		log.Printf("系统繁忙，跳过WAL检查点(%s)", trigger)
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	if err := DB.WithContext(ctx).Exec("PRAGMA wal_checkpoint(PASSIVE)").Error; err != nil {
+		log.Printf("执行WAL检查点失败(%s): %v", trigger, err)
+	}
+}
+
 // SafeUpdateServerStatus 使用无事务模式更新服务器状态，避免锁竞争
 func SafeUpdateServerStatus(serverID uint64, updates map[string]interface{}) error {
 	// 检查是否使用 BadgerDB