What is Go and graceful degradation?

Question

Accepted Answer

Graceful degradation is a **resilience pattern** where the system continues to work when dependencies fail.

```go
// Circuit breaker + fallback
import "github.com/sony/gobreaker"

type UserService struct {
    db     *sql.DB
    cache  *redis.Client
    cb     *gobreaker.CircuitBreaker
}

func (s *UserService) GetUser(id int) (*User, error) {
    // 1. Try from cache
    if user, err := s.cacheGet(id); err == nil {
        return user, nil
    }

// 2. Try from DB via circuit breaker
    result, err := s.cb.Execute(func() (interface{}, error) {
        return s.dbGet(id)
    })

if err != nil {
        // 3. Fallback: stale data from cache
        if user, err := s.cacheGetStale(id); err == nil {
            return user, nil
        }

// 4. Ultimate fallback: default data
        return &User{ID: id, Name: "Unknown"}, nil
    }

user := result.(*User)
    s.cacheSet(id, user)  // Cache it
    return user, nil
}

// Retry with exponential backoff
import "github.com/cenkalti/backoff"

func callWithRetry(fn func() error) error {
    expBackoff := backoff.NewExponentialBackOff()
    expBackoff.MaxElapsedTime = 30 * time.Second

return backoff.Retry(fn, expBackoff)
}

// Timeout for each service
func fetchWithTimeout(url string, timeout time.Duration) ([]byte, error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return io.ReadAll(resp.Body)
}
```

**Strategies:**
- Circuit breaker: disabling the failed service.
- Fallback: alternative data source.
- Retry: repeated attempts.
- Timeout: wait time limit.

Go: What is Go and graceful degradation?