feat: implement circuit breaker

Author: Bulletdev

cmd/server/main.go

@@ -28,7 +28,7 @@ func main() {
 	l1 := cache.NewMemory(60 * time.Second)
 	l2 := cache.NewRedis(cfg.RedisURL, cfg.CacheEnabled, logger)
 
-	limiter := ratelimit.NewRegionLimiter(cfg.RiotRateLimitPerSecond, cfg.RiotRateLimitBurst)
+	limiter := ratelimit.NewAppLimiter(cfg.RiotRateLimitPerSecond, cfg.RiotRateLimitBurst, cfg.RiotRateLimitPer2Min)
 	breakers := circuit.NewRegionBreakers(cfg.CBThreshold, cfg.CBTimeout, cfg.CBCooldown)
 
 	riotClient := riot.NewClient(cfg.RiotAPITimeout, cfg.RiotAPIKey, limiter, breakers, logger)

internal/config/config.go

@@ -16,6 +16,7 @@ type Config struct {
 	RiotAPITimeout         time.Duration
 	RiotRateLimitPerSecond float64
 	RiotRateLimitBurst     int
+	RiotRateLimitPer2Min   int
 	RedisURL               string
 	CacheEnabled           bool
 	CBThreshold            int
@@ -46,6 +47,7 @@ func Load() *Config {
 		RiotAPITimeout:         getDuration("RIOT_API_TIMEOUT", 5*time.Second),
 		RiotRateLimitPerSecond: getFloat("RIOT_RATE_LIMIT_PER_SECOND", 20.0),
 		RiotRateLimitBurst:     getInt("RIOT_RATE_LIMIT_BURST", 20),
+		RiotRateLimitPer2Min:   getInt("RIOT_RATE_LIMIT_PER_2MIN", 100),
 		RedisURL:               getEnv("REDIS_URL", "redis://localhost:6379/1"),
 		CacheEnabled:           getBool("CACHE_ENABLED", true),
 		CBThreshold:            getInt("CIRCUIT_BREAKER_THRESHOLD", 5),

internal/handlers/base.go

@@ -2,6 +2,7 @@ package handlers
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log/slog"
 	"net/http"
@@ -49,6 +50,10 @@ func (d *deps) fetch(
 	data, status, err := d.riot.Do(r.Context(), region, riotPath)
 	if err != nil {
 		d.logger.Warn("riot call failed", "region", region, "path", riotPath, "status", status, "error", err)
+		var rlErr *riot.RateLimitError
+		if errors.As(err, &rlErr) && rlErr.RetryAfter != "" {
+			w.Header().Set("Retry-After", rlErr.RetryAfter)
+		}
 		webutils.ErrorJSON(w, err, status)
 		return
 	}

internal/ratelimit/limiter.go

@@ -2,7 +2,6 @@ package ratelimit
 
 import (
 	"context"
-	"sync"
 
 	"golang.org/x/time/rate"
 )
@@ -41,43 +40,32 @@ var ServerToRouting = map[string]string{
 	"oc1":  "sea",
 }
 
-// RegionLimiter holds one token bucket per Riot region.
-type RegionLimiter struct {
-	mu       sync.RWMutex
-	limiters map[string]*rate.Limiter
-	rps      float64
-	burst    int
+// AppLimiter enforces the Riot app-level rate limit globally across all regions.
+// It combines two token buckets to cover both the per-second and per-2-minute windows
+// that Riot enforces on every API key.
+type AppLimiter struct {
+	perSecond *rate.Limiter
+	per2Min   *rate.Limiter
 }
 
-func NewRegionLimiter(rps float64, burst int) *RegionLimiter {
-	return &RegionLimiter{
-		limiters: make(map[string]*rate.Limiter),
-		rps:      rps,
-		burst:    burst,
+// NewAppLimiter creates an AppLimiter with independent per-second and per-2-minute buckets.
+// rps and burst configure the 1-second window; per2Min configures the 2-minute window.
+func NewAppLimiter(rps float64, burst int, per2Min int) *AppLimiter {
+	return &AppLimiter{
+		perSecond: rate.NewLimiter(rate.Limit(rps), burst),
+		// Riot's 2-min limit modelled as a token bucket: refill rate = per2Min/120s, burst = per2Min.
+		// This is a safe approximation: it prevents bursting past the 2-min cap while
+		// allowing the full burst at startup (matching Riot's sliding-window behaviour).
+		per2Min: rate.NewLimiter(rate.Limit(float64(per2Min)/120.0), per2Min),
 	}
 }
 
-// Wait blocks until a token is available for the given region, or ctx is cancelled.
-func (rl *RegionLimiter) Wait(ctx context.Context, region string) error {
-	return rl.get(region).Wait(ctx)
-}
-
-func (rl *RegionLimiter) get(region string) *rate.Limiter {
-	rl.mu.RLock()
-	l, ok := rl.limiters[region]
-	rl.mu.RUnlock()
-	if ok {
-		return l
-	}
-
-	rl.mu.Lock()
-	defer rl.mu.Unlock()
-	if l, ok = rl.limiters[region]; ok {
-		return l
+// Wait blocks until both rate windows have capacity, or ctx is cancelled.
+func (al *AppLimiter) Wait(ctx context.Context) error {
+	if err := al.perSecond.Wait(ctx); err != nil {
+		return err
 	}
-	l = rate.NewLimiter(rate.Limit(rl.rps), rl.burst)
-	rl.limiters[region] = l
-	return l
+	return al.per2Min.Wait(ctx)
 }
 
 // ValidRegion returns true if the region is in the allowed list.

internal/riot/client.go

@@ -12,19 +12,29 @@ import (
 	"prostaff-riot-gateway/internal/ratelimit"
 )
 
+// RateLimitError is returned when Riot responds with 429. It carries the Retry-After
+// value from the Riot header so callers can propagate it to their own clients.
+type RateLimitError struct {
+	RetryAfter string
+}
+
+func (e *RateLimitError) Error() string {
+	return fmt.Sprintf("riot api rate limited, retry after %s seconds", e.RetryAfter)
+}
+
 // Client calls the Riot Games API with rate limiting and circuit breaking.
 type Client struct {
 	http     *http.Client
 	apiKey   string
-	limiter  *ratelimit.RegionLimiter
+	limiter  *ratelimit.AppLimiter
 	breakers *circuit.RegionBreakers
 	logger   *slog.Logger
 }
 
 func NewClient(
 	timeout time.Duration,
 	apiKey string,
-	limiter *ratelimit.RegionLimiter,
+	limiter *ratelimit.AppLimiter,
 	breakers *circuit.RegionBreakers,
 	logger *slog.Logger,
 ) *Client {
@@ -51,7 +61,7 @@ func (c *Client) Do(ctx context.Context, region, path string) ([]byte, int, erro
 		return nil, http.StatusServiceUnavailable, fmt.Errorf("riot api circuit open for region %s", region)
 	}
 
-	if err := c.limiter.Wait(ctx, region); err != nil {
+	if err := c.limiter.Wait(ctx); err != nil {
 		return nil, http.StatusGatewayTimeout, fmt.Errorf("rate limit wait cancelled: %w", err)
 	}
 
@@ -76,12 +86,17 @@ func (c *Client) Do(ctx context.Context, region, path string) ([]byte, int, erro
 		return nil, http.StatusBadGateway, fmt.Errorf("failed to read riot response: %w", err)
 	}
 
-	status := mapRiotStatus(resp.StatusCode)
+	// 429 is a rate limit signal, not an infrastructure failure — do not trip the circuit breaker.
+	if resp.StatusCode == http.StatusTooManyRequests {
+		retryAfter := resp.Header.Get("Retry-After")
+		c.logger.Warn("riot api rate limited", "region", region, "retry_after", retryAfter)
+		return nil, http.StatusTooManyRequests, &RateLimitError{RetryAfter: retryAfter}
+	}
 
-	if resp.StatusCode >= 500 || resp.StatusCode == 429 {
+	if resp.StatusCode >= 500 {
 		breaker.RecordFailure()
-		c.logger.Warn("riot api returned error", "region", region, "riot_status", resp.StatusCode)
-		return nil, status, fmt.Errorf("riot api returned %d", resp.StatusCode)
+		c.logger.Warn("riot api server error", "region", region, "riot_status", resp.StatusCode)
+		return nil, http.StatusBadGateway, fmt.Errorf("riot api returned %d", resp.StatusCode)
 	}
 
 	if resp.StatusCode == http.StatusNotFound {
@@ -92,17 +107,3 @@ func (c *Client) Do(ctx context.Context, region, path string) ([]byte, int, erro
 	return body, http.StatusOK, nil
 }
 
-func mapRiotStatus(riotStatus int) int {
-	switch {
-	case riotStatus == http.StatusOK:
-		return http.StatusOK
-	case riotStatus == http.StatusNotFound:
-		return http.StatusNotFound
-	case riotStatus == 429:
-		return 429
-	case riotStatus >= 500:
-		return http.StatusBadGateway
-	default:
-		return riotStatus
-	}
-}