perf(server): cache speed limit calculations

pkg/speedlimit/calculator.go

@@ -2,10 +2,13 @@ package speedlimit
 
 import (
 	"context"
+	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"time"
 
+	"github.com/redis/go-redis/v9"
 	"gorm.io/gorm"
 )
 
@@ -19,13 +22,44 @@ type TrafficLimitRule struct {
 
 // ThrottleResult contains the computed speed limit status for a user subscription.
 type ThrottleResult struct {
-	BaseSpeed      int64   `json:"base_speed"`       // Plan base speed limit (Mbps, 0=unlimited)
-	EffectiveSpeed int64   `json:"effective_speed"`  // Current effective speed limit (Mbps)
-	IsThrottled    bool    `json:"is_throttled"`     // Whether the user is currently throttled
-	ThrottleRule   string  `json:"throttle_rule"`    // Description of the matched rule (empty if not throttled)
-	UsedTrafficGB  float64 `json:"used_traffic_gb"`  // Traffic used in the matched rule's window (GB)
-	ThrottleStart  int64   `json:"throttle_start"`   // Window start Unix timestamp (seconds), 0 if not throttled
-	ThrottleEnd    int64   `json:"throttle_end"`     // Window end Unix timestamp (seconds), 0 if not throttled
+	BaseSpeed      int64   `json:"base_speed"`      // Plan base speed limit (Mbps, 0=unlimited)
+	EffectiveSpeed int64   `json:"effective_speed"` // Current effective speed limit (Mbps)
+	IsThrottled    bool    `json:"is_throttled"`    // Whether the user is currently throttled
+	ThrottleRule   string  `json:"throttle_rule"`   // Description of the matched rule (empty if not throttled)
+	UsedTrafficGB  float64 `json:"used_traffic_gb"` // Traffic used in the matched rule's window (GB)
+	ThrottleStart  int64   `json:"throttle_start"`  // Window start Unix timestamp (seconds), 0 if not throttled
+	ThrottleEnd    int64   `json:"throttle_end"`    // Window end Unix timestamp (seconds), 0 if not throttled
+}
+
+// CalculateWithCache computes the effective speed limit with a short Redis cache.
+// It is intended for hot read paths such as node user-list pulls where many nodes
+// can ask for the same subscription limits in a short period.
+func CalculateWithCache(ctx context.Context, cache *redis.Client, db *gorm.DB, userId, subscribeId, baseSpeedLimit int64, trafficLimitJSON string, ttl time.Duration) *ThrottleResult {
+	if cache == nil || ttl <= 0 || trafficLimitJSON == "" {
+		return Calculate(ctx, db, userId, subscribeId, baseSpeedLimit, trafficLimitJSON)
+	}
+
+	key := cacheKey(userId, subscribeId, baseSpeedLimit, trafficLimitJSON)
+	if cached, err := cache.Get(ctx, key).Result(); err == nil && cached != "" {
+		var result ThrottleResult
+		if err := json.Unmarshal([]byte(cached), &result); err == nil {
+			return &result
+		}
+	}
+
+	result := Calculate(ctx, db, userId, subscribeId, baseSpeedLimit, trafficLimitJSON)
+	if payload, err := json.Marshal(result); err == nil {
+		_ = cache.Set(ctx, key, string(payload), ttl).Err()
+	}
+	return result
+}
+
+// ClearCache removes a cached speed-limit calculation for a user subscription.
+func ClearCache(ctx context.Context, cache *redis.Client, userId, subscribeId, baseSpeedLimit int64, trafficLimitJSON string) error {
+	if cache == nil || trafficLimitJSON == "" {
+		return nil
+	}
+	return cache.Del(ctx, cacheKey(userId, subscribeId, baseSpeedLimit, trafficLimitJSON)).Err()
 }
 
 // Calculate computes the effective speed limit for a user subscription,
@@ -107,3 +141,8 @@ func Calculate(ctx context.Context, db *gorm.DB, userId, subscribeId, baseSpeedL
 
 	return result
 }
+
+func cacheKey(userId, subscribeId, baseSpeedLimit int64, trafficLimitJSON string) string {
+	sum := sha256.Sum256([]byte(trafficLimitJSON))
+	return fmt.Sprintf("speedlimit:%d:%d:%d:%s", userId, subscribeId, baseSpeedLimit, hex.EncodeToString(sum[:8]))
+}