What is Go and graceful degradation with rate limiting?

Question

Accepted Answer

Graceful degradation with rate limiting is a **resilience pattern** with request frequency limiting.

```go
import "golang.org/x/time/rate"

type DegradedService struct {
    primary   Service
    fallback  Service
    limiter   *rate.Limiter
    degraded  atomic.Bool
}

func (s *DegradedService) Handle(ctx context.Context, req Request) (Response, error) {
    // Check rate limit
    if !s.limiter.Allow() {
        return Response{}, ErrRateLimited
    }

// If in degraded mode — use fallback
    if s.degraded.Load() {
        return s.fallback.Process(ctx, req)
    }

// Try primary with timeout
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

resp, err := s.primary.Process(ctx, req)
    if err != nil {
        // Switch to degraded mode
        s.degraded.Store(true)
        go s.recoveryCheck()

// Fallback
        return s.fallback.Process(ctx, req)
    }

return resp, nil
}

func (s *DegradedService) recoveryCheck() {
    ticker := time.NewTicker(30 * time.Second)
    defer ticker.Stop()

for range ticker.C {
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        err := s.primary.HealthCheck(ctx)
        cancel()

if err == nil {
            s.degraded.Store(false)
            return
        }
    }
}

// Rate limiter per IP
type IPRateLimiter struct {
    mu       sync.Mutex
    limiters map[string]*rate.Limiter
    rate     rate.Limit
    burst    int
}

func (rl *IPRateLimiter) GetLimiter(ip string) *rate.Limiter {
    rl.mu.Lock()
    defer rl.mu.Unlock()

limiter, exists := rl.limiters[ip]
    if !exists {
        limiter = rate.NewLimiter(rl.rate, rl.burst)
        rl.limiters[ip] = limiter
    }
    return limiter
}

// Middleware
func RateLimitMiddleware(rl *IPRateLimiter) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            limiter := rl.GetLimiter(r.RemoteAddr)
            if !limiter.Allow() {
                http.Error(w, "Rate limited", http.StatusTooManyRequests)
                return
            }
            next.ServeHTTP(w, r)
        })
    }
}
```

**Strategies:**
- Token bucket rate limiting.
- Circuit breaker + fallback.
- Exponential backoff.
- Health checks for recovery.

Go: What is Go and graceful degradation with rate limiting?