HTTP Client with Retries, Backoff, and Retry-After Support

package main

import (
	"context"
	"errors"
	"fmt"
	"io"
	"log"
	"math/rand"
	"net/http"
	"strconv"
	"time"
)

type RetryConfig struct {
	MaxAttempts       int
	BaseDelay         time.Duration
	MaxDelay          time.Duration
	RetryAfterEnabled bool
	RetryStatusCodes  map[int]bool
}

func defaultRetryConfig() RetryConfig {
	return RetryConfig{
		MaxAttempts:       5,
		BaseDelay:         250 * time.Millisecond,
		MaxDelay:          5 * time.Second,
		RetryAfterEnabled: true,
		RetryStatusCodes: map[int]bool{
			http.StatusTooManyRequests:     true,
			http.StatusBadGateway:          true,
			http.StatusServiceUnavailable:  true,
			http.StatusGatewayTimeout:      true,
			http.StatusInternalServerError: true,
		},
	}
}

func backoffDelay(rng *rand.Rand, attempt int, base, max time.Duration) time.Duration {
	if attempt <= 1 {
		return base
	}
	d := base << (attempt - 1)
	if d > max {
		d = max
	}
	jitter := time.Duration(rng.Int63n(int64(d/3) + 1))
	return d - (d / 6) + jitter
}

func parseRetryAfterSeconds(resp *http.Response) (time.Duration, bool) {
	if resp == nil {
		return 0, false
	}
	v := resp.Header.Get("Retry-After")
	if v == "" {
		return 0, false
	}
	if secs, err := strconv.Atoi(v); err == nil && secs >= 0 {
		return time.Duration(secs) * time.Second, true
	}
	if t, err := http.ParseTime(v); err == nil {
		d := time.Until(t)
		if d < 0 {
			return 0, false
		}
		return d, true
	}
	return 0, false
}

func doWithRetry(ctx context.Context, client *http.Client, req *http.Request, cfg RetryConfig) (*http.Response, error) {
	if cfg.MaxAttempts < 1 {
		return nil, fmt.Errorf("MaxAttempts must be >= 1")
	}
	if req.Body != nil {
		return nil, fmt.Errorf("this helper requires req.Body to be nil or replayable; use req.GetBody or buffer the body")
	}

	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
	var lastErr error

	for attempt := 1; attempt <= cfg.MaxAttempts; attempt++ {
		if err := ctx.Err(); err != nil {
			return nil, err
		}

		r := req.Clone(ctx)
		resp, err := client.Do(r)
		if err == nil && (resp.StatusCode < 500 && !cfg.RetryStatusCodes[resp.StatusCode]) {
			return resp, nil
		}

		if err != nil {
			lastErr = err
		} else {
			io.Copy(io.Discard, resp.Body)
			resp.Body.Close()
			lastErr = fmt.Errorf("retryable HTTP status: %s", resp.Status)
		}

		if attempt == cfg.MaxAttempts {
			break
		}

		delay := backoffDelay(rng, attempt, cfg.BaseDelay, cfg.MaxDelay)
		if cfg.RetryAfterEnabled {
			if ra, ok := parseRetryAfterSeconds(resp); ok && ra > delay {
				delay = ra
			}
		}

		timer := time.NewTimer(delay)
		select {
		case <-ctx.Done():
			timer.Stop()
			return nil, ctx.Err()
		case <-timer.C:
		}
	}

	if lastErr == nil {
		lastErr = errors.New("request failed")
	}
	return nil, lastErr
}

func main() {
	client := &http.Client{
		Timeout: 10 * time.Second,
	}

	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, "https://example.com", nil)
	if err != nil {
		log.Fatalf("build request: %v", err)
	}

	resp, err := doWithRetry(ctx, client, req, defaultRetryConfig())
	if err != nil {
		log.Fatalf("request failed: %v", err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
	log.Printf("status=%s body_prefix=%q", resp.Status, string(body))
}