設計問題: レート制限 — APIを守る仕組みの設計

# app/services/rate_limiter/token_bucket.rb
class RateLimiter::TokenBucket
  def initialize(redis, key, capacity:, refill_rate:)
    @redis       = redis
    @key         = key
    @capacity    = capacity       # バケツの最大容量（バースト上限）
    @refill_rate = refill_rate    # 1秒あたりの補充量（平均レート）
  end
 
  def allow?
    now    = Time.current.to_f
    result = @redis.eval(
      TOKEN_BUCKET_SCRIPT,
      keys: [@key],
      argv: [@capacity, @refill_rate, now, 1]
    )
    result == 1
  end
 
  # Lua スクリプトでアトミックに実行（競合状態を防ぐ）
  TOKEN_BUCKET_SCRIPT = <<~LUA
    local key         = KEYS[1]
    local capacity    = tonumber(ARGV[1])
    local refill_rate = tonumber(ARGV[2])
    local now         = tonumber(ARGV[3])
    local requested   = tonumber(ARGV[4])
 
    local last_refill = tonumber(redis.call('HGET', key, 'last_refill') or now)
    local tokens      = tonumber(redis.call('HGET', key, 'tokens')      or capacity)
 
    -- 経過時間分のトークンを補充（上限 = capacity）
    local elapsed = now - last_refill
    tokens = math.min(capacity, tokens + elapsed * refill_rate)
 
    if tokens >= requested then
      tokens = tokens - requested
      redis.call('HSET', key, 'tokens', tokens, 'last_refill', now)
      redis.call('EXPIRE', key, 3600)
      return 1  -- 許可
    else
      -- トークン不足: last_refill だけ更新（次回補充計算のため）
      redis.call('HSET', key, 'last_refill', now, 'tokens', tokens)
      redis.call('EXPIRE', key, 3600)
      return 0  -- 拒否
    end
  LUA
 
  private_constant :TOKEN_BUCKET_SCRIPT
end

# app/services/rate_limiter/leaky_bucket.rb
# キューに積んで一定速度で処理するモデル
class RateLimiter::LeakyBucket
  # leak_rate: 1秒あたりの処理数（出力が一定）
  def initialize(redis, key, capacity:, leak_rate:)
    @redis     = redis
    @key       = key
    @capacity  = capacity
    @leak_rate = leak_rate
  end
 
  def allow?
    now    = Time.current.to_f
    result = @redis.eval(LEAKY_BUCKET_SCRIPT,
      keys: [@key],
      argv: [@capacity, @leak_rate, now])
    result == 1
  end
 
  LEAKY_BUCKET_SCRIPT = <<~LUA
    local key       = KEYS[1]
    local capacity  = tonumber(ARGV[1])
    local leak_rate = tonumber(ARGV[2])
    local now       = tonumber(ARGV[3])
 
    local last_leak = tonumber(redis.call('HGET', key, 'last_leak') or now)
    local queue     = tonumber(redis.call('HGET', key, 'queue')     or 0)
 
    -- 経過時間分、キューから流出（leakage）
    local elapsed = now - last_leak
    queue = math.max(0, queue - elapsed * leak_rate)
 
    if queue < capacity then
      queue = queue + 1
      redis.call('HSET', key, 'queue', queue, 'last_leak', now)
      redis.call('EXPIRE', key, 3600)
      return 1
    else
      redis.call('HSET', key, 'last_leak', now)
      return 0
    end
  LUA
 
  private_constant :LEAKY_BUCKET_SCRIPT
end

# app/services/rate_limiter/fixed_window.rb
class RateLimiter::FixedWindow
  def initialize(redis, limit:, window:)
    @redis  = redis
    @limit  = limit
    @window = window
  end
 
  def allow?(identifier)
    # ウィンドウID = "現在時刻 ÷ ウィンドウ秒数" の整数部
    window_id = Time.current.to_i / @window
    key       = "fw:#{identifier}:#{window_id}"
 
    count = @redis.incr(key)
    @redis.expire(key, @window * 2) if count == 1
 
    count <= @limit
  end
end

# app/services/rate_limiter/sliding_window_counter.rb
class RateLimiter::SlidingWindowCounter
  def initialize(redis, limit:, window:)
    @redis  = redis
    @limit  = limit
    @window = window
  end
 
  def allow?(identifier)
    now            = Time.current.to_i
    current_window = now / @window
    prev_window    = current_window - 1
 
    current_key = "sw:#{identifier}:#{current_window}"
    prev_key    = "sw:#{identifier}:#{prev_window}"
 
    results = @redis.multi do |pipe|
      pipe.get(prev_key)
      pipe.incr(current_key)
      pipe.expire(current_key, @window * 2)
    end
 
    prev_count    = results[0].to_i
    current_count = results[1].to_i
 
    # 現ウィンドウ内の経過割合
    elapsed_ratio = (now % @window).to_f / @window
 
    # 重み付き合算
    weighted_count = prev_count * (1.0 - elapsed_ratio) + current_count
 
    if weighted_count <= @limit
      true
    else
      # ロールバック（インクリメントしたが拒否する場合）
      @redis.decr(current_key)
      false
    end
  end
 
  # レスポンスヘッダー用の残余カウントを計算
  def remaining(identifier)
    now            = Time.current.to_i
    current_window = now / @window
    prev_window    = current_window - 1
 
    prev_count    = @redis.get("sw:#{identifier}:#{prev_window}").to_i
    current_count = @redis.get("sw:#{identifier}:#{current_window}").to_i
 
    elapsed_ratio  = (now % @window).to_f / @window
    weighted_count = prev_count * (1.0 - elapsed_ratio) + current_count
 
    [@limit - weighted_count.ceil, 0].max
  end
end

# lib/middleware/rate_limiter_middleware.rb
class RateLimiterMiddleware
  RATE_LIMIT_RULES = [
    { pattern: %r{^/api/v1/auth/login}, limit: 10,   window: 60, tier_multiplier: false },
    { pattern: %r{^/api/v1/auth/},      limit: 30,   window: 60, tier_multiplier: false },
    { pattern: %r{^/api/v1/search},     limit: 100,  window: 60, tier_multiplier: true  },
    { pattern: %r{^/api/v1/},           limit: 1000, window: 60, tier_multiplier: true  },
  ].freeze
 
  DEFAULT_RULE = { limit: 100, window: 60, tier_multiplier: false }.freeze
 
  TIER_MULTIPLIERS = {
    "free"       => 1.0,
    "pro"        => 5.0,
    "enterprise" => 50.0,
  }.freeze
 
  def initialize(app)
    @app          = app
    @redis        = Redis.new(url: ENV.fetch("REDIS_URL"))
    @rules_loader = RateLimitRulesLoader.new
  end
 
  def call(env)
    request    = Rack::Request.new(env)
    rule       = find_rule(request.path)
    identifier = identify(request, env)
    limit      = effective_limit(rule, env)
 
    limiter = RateLimiter::SlidingWindowCounter.new(
      @redis, limit: limit, window: rule[:window]
    )
 
    if limiter.allow?(identifier)
      status, headers, body = @app.call(env)
      add_rate_limit_headers!(headers, limiter, identifier, limit, rule[:window])
      [status, headers, body]
    else
      reset_at = next_window_at(rule[:window])
      [
        429,
        rate_limit_exceeded_headers(limit, reset_at),
        [{ error: "Too Many Requests", retry_after: reset_at - Time.current.to_i }.to_json]
      ]
    end
  end
 
  private
 
  def identify(request, env)
    user_id = env["current_user_id"]  # 認証済みならuser_id
    user_id ? "user:#{user_id}" : "ip:#{request.ip}"
  end
 
  def find_rule(path)
    RATE_LIMIT_RULES.find { |r| path.match?(r[:pattern]) } || DEFAULT_RULE
  end
 
  def effective_limit(rule, env)
    return rule[:limit] unless rule[:tier_multiplier]
 
    tier       = env["current_user_tier"] || "free"
    multiplier = TIER_MULTIPLIERS[tier] || 1.0
    (rule[:limit] * multiplier).to_i
  end
 
  def add_rate_limit_headers!(headers, limiter, identifier, limit, window)
    remaining = limiter.remaining(identifier)
    reset_at  = next_window_at(window)
 
    headers["X-RateLimit-Limit"]     = limit.to_s
    headers["X-RateLimit-Remaining"] = remaining.to_s
    headers["X-RateLimit-Reset"]     = reset_at.to_s
    headers["X-RateLimit-Policy"]    = "sliding-window"
  end
 
  def rate_limit_exceeded_headers(limit, reset_at)
    {
      "Content-Type"          => "application/json",
      "X-RateLimit-Limit"     => limit.to_s,
      "X-RateLimit-Remaining" => "0",
      "X-RateLimit-Reset"     => reset_at.to_s,
      "Retry-After"           => (reset_at - Time.current.to_i).to_s,
    }
  end
 
  def next_window_at(window)
    now = Time.current.to_i
    ((now / window) + 1) * window
  end
end

# config/application.rb に追加
config.middleware.insert_before ActionDispatch::RequestId, RateLimiterMiddleware

// ratelimiter/sliding_window.go
package ratelimiter
 
import (
	"context"
	"fmt"
	"sync/atomic"
	"time"
 
	"github.com/redis/go-redis/v9"
)
 
// SlidingWindowLimiter はgoroutineセーフなスライディングウィンドウ実装
type SlidingWindowLimiter struct {
	rdb      *redis.Client
	limit    int64
	window   int64 // seconds
	fallback atomic.Bool // true = Redisが利用不可（フェイルオープン用）
}
 
func NewSlidingWindowLimiter(rdb *redis.Client, limit, windowSec int64) *SlidingWindowLimiter {
	return &SlidingWindowLimiter{
		rdb:    rdb,
		limit:  limit,
		window: windowSec,
	}
}
 
// AllowResult はレート制限チェックの結果
type AllowResult struct {
	Allowed    bool
	Remaining  int64
	ResetAt    int64 // Unix timestamp
	RetryAfter int64 // seconds（制限超過時のみ）
}
 
// Allow はidentifierのリクエストが許可されるか判定する（goroutineセーフ）
func (l *SlidingWindowLimiter) Allow(ctx context.Context, identifier string) (*AllowResult, error) {
	// Redisが利用不可の場合はフェイルオープン
	if l.fallback.Load() {
		return &AllowResult{Allowed: true, Remaining: l.limit}, nil
	}
 
	now           := time.Now().Unix()
	currentWindow := now / l.window
	prevWindow    := currentWindow - 1
	resetAt       := (currentWindow + 1) * l.window
 
	currentKey := fmt.Sprintf("sw:%s:%d", identifier, currentWindow)
	prevKey    := fmt.Sprintf("sw:%s:%d", identifier, prevWindow)
 
	// Redis Pipelineで2コマンドを1往復で送信
	pipe       := l.rdb.Pipeline()
	prevCmd    := pipe.Get(ctx, prevKey)
	currentCmd := pipe.Incr(ctx, currentKey)
	pipe.Expire(ctx, currentKey, time.Duration(l.window*2)*time.Second)
 
	if _, err := pipe.Exec(ctx); err != nil && err != redis.Nil {
		// Redis障害: フォールバックモードに切り替え
		l.fallback.Store(true)
		go l.redisHealthCheck(ctx) // バックグラウンドで回復を監視
		return &AllowResult{Allowed: true, Remaining: l.limit}, nil
	}
 
	prevCount, _    := prevCmd.Int64()
	currentCount, _ := currentCmd.Int64()
 
	elapsedRatio  := float64(now%l.window) / float64(l.window)
	weightedCount := float64(prevCount)*(1.0-elapsedRatio) + float64(currentCount)
 
	if weightedCount <= float64(l.limit) {
		remaining := l.limit - int64(weightedCount)
		return &AllowResult{
			Allowed:   true,
			Remaining: remaining,
			ResetAt:   resetAt,
		}, nil
	}
 
	// 制限超過: インクリメントをロールバック
	l.rdb.Decr(ctx, currentKey)
 
	return &AllowResult{
		Allowed:    false,
		Remaining:  0,
		ResetAt:    resetAt,
		RetryAfter: resetAt - now,
	}, nil
}
 
// redisHealthCheck はRedis回復を定期確認し、フォールバックを解除する
func (l *SlidingWindowLimiter) redisHealthCheck(ctx context.Context) {
	ticker := time.NewTicker(5 * time.Second)
	defer ticker.Stop()
	for range ticker.C {
		if err := l.rdb.Ping(ctx).Err(); err == nil {
			l.fallback.Store(false)
			return
		}
	}
}

// ratelimiter/middleware.go
package ratelimiter
 
import (
	"net/http"
	"strconv"
)
 
// HTTPMiddleware はGo HTTPハンドラへのレート制限ミドルウェア
func HTTPMiddleware(limiter *SlidingWindowLimiter) func(http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			identifier := extractIdentifier(r)
			result, err := limiter.Allow(r.Context(), identifier)
			if err != nil {
				// エラー時はフェイルオープン
				next.ServeHTTP(w, r)
				return
			}
 
			// 常にレート制限ヘッダーを付与
			w.Header().Set("X-RateLimit-Limit",     strconv.FormatInt(limiter.limit, 10))
			w.Header().Set("X-RateLimit-Remaining", strconv.FormatInt(result.Remaining, 10))
			w.Header().Set("X-RateLimit-Reset",     strconv.FormatInt(result.ResetAt, 10))
 
			if !result.Allowed {
				w.Header().Set("Retry-After", strconv.FormatInt(result.RetryAfter, 10))
				w.Header().Set("Content-Type", "application/json")
				w.WriteHeader(http.StatusTooManyRequests)
				w.Write([]byte(`{"error":"Too Many Requests"}`))
				return
			}
 
			next.ServeHTTP(w, r)
		})
	}
}
 
func extractIdentifier(r *http.Request) string {
	// JWTからuser_idを取得（認証済みの場合）
	if userID := r.Header.Get("X-User-ID"); userID != "" {
		return "user:" + userID
	}
	// X-Forwarded-For でロードバランサー越しのIPを取得
	if ip := r.Header.Get("X-Forwarded-For"); ip != "" {
		return "ip:" + ip
	}
	return "ip:" + r.RemoteAddr
}

# config/rate_limits.yml
version: "2"
updated_at: "2025-01-15T00:00:00Z"
 
tiers:
  free:       { multiplier: 1.0 }
  pro:        { multiplier: 5.0 }
  enterprise: { multiplier: 50.0 }
 
rules:
  - name: login_endpoint
    pattern: "^/api/v1/auth/login"
    limit: 10
    window: 60
    identifier: ip           # IPアドレス単位（ユーザー認証前なのでuser_idなし）
    tier_multiplier: false   # Free でも攻撃は防ぐ
    note: "ブルートフォース攻撃対策。絶対に緩めてはいけない"
 
  - name: search_api
    pattern: "^/api/v1/search"
    limit: 100
    window: 60
    identifier: user
    tier_multiplier: true
    note: "全文検索はDBに高負荷"
 
  - name: webhook_endpoint
    pattern: "^/api/v1/webhooks"
    limit: 5000
    window: 60
    identifier: ip
    tier_multiplier: false
    ip_allowlist:
      - "34.210.0.0/16"   # 外部サービスAのIP範囲
      - "52.15.0.0/16"    # 外部サービスBのIP範囲
 
security:
  block_user_agents:
    - "sqlmap"
    - "nikto"
    - "masscan"
  trusted_proxy_ips:
    - "10.0.0.0/8"
    - "172.16.0.0/12"

# app/services/rate_limit_rules_loader.rb
class RateLimitRulesLoader
  RULES_FILE      = Rails.root.join("config/rate_limits.yml")
  RELOAD_INTERVAL = 30.seconds
 
  def initialize
    @rules     = nil
    @loaded_at = nil
    @mutex     = Mutex.new
  end
 
  def rules
    @mutex.synchronize do
      reload_if_needed!
      @rules
    end
  end
 
  private
 
  def reload_if_needed!
    if @rules.nil? || @loaded_at.nil? || Time.current - @loaded_at > RELOAD_INTERVAL
      new_rules = YAML.load_file(RULES_FILE).deep_symbolize_keys
      validate!(new_rules)
      @rules     = new_rules
      @loaded_at = Time.current
      Rails.logger.info "[RateLimiter] Rules reloaded (version: #{@rules[:version]})"
    end
  rescue => e
    # 読み込み失敗時は既存ルールを維持（古いルールの方が無制限より安全）
    Rails.logger.error "[RateLimiter] Failed to reload rules: #{e.message}"
  end
 
  def validate!(rules)
    raise "version required"      unless rules[:version]
    raise "rules must be array"   unless rules[:rules].is_a?(Array)
    rules[:rules].each do |rule|
      raise "rule missing limit: #{rule}" unless rule[:limit]
    end
  end
end

# Hash Tags を使った実装
def window_key(identifier, window_id)
  # {identifier} でハッシュタグを作成 → 同じシャードに配置される
  "sw:{#{identifier}}:#{window_id}"
end

# terraform/modules/api_gateway/main.tf
resource "aws_api_gateway_stage" "api" {
  rest_api_id = aws_api_gateway_rest_api.main.id
  stage_name  = var.env
 
  default_route_settings {
    throttling_burst_limit = 5000
    throttling_rate_limit  = 10000
  }
}
 
# AWS WAF: IPレート制限ルール（5分間で2000リクエスト/IP）
resource "aws_wafv2_web_acl" "main" {
  name  = "rate-limit-acl"
  scope = "REGIONAL"
 
  default_action { allow {} }
 
  rule {
    name     = "IPRateLimitRule"
    priority = 1
    action { block {} }
 
    statement {
      rate_based_statement {
        limit              = 2000
        aggregate_key_type = "IP"
      }
    }
 
    visibility_config {
      cloudwatch_metrics_enabled = true
      metric_name                = "IPRateLimit"
      sampled_requests_enabled   = true
    }
  }
 
  visibility_config {
    cloudwatch_metrics_enabled = true
    metric_name                = "RateLimitACL"
    sampled_requests_enabled   = true
  }
}

# app/middleware/security_filter_middleware.rb
class SecurityFilterMiddleware
  BLOCKED_USER_AGENTS = %w[sqlmap nikto masscan zgrab dirbuster hydra].freeze
 
  def initialize(app, config: RateLimitRulesLoader.new)
    @app    = app
    @config = config
  end
 
  def call(env)
    request = Rack::Request.new(env)
 
    # 1. ブロック対象 User-Agent
    ua = request.user_agent.to_s.downcase
    if BLOCKED_USER_AGENTS.any? { |bad| ua.include?(bad) }
      return [403, { "Content-Type" => "text/plain" }, ["Forbidden"]]
    end
 
    # 2. Webhook エンドポイントは許可IPのみ
    if webhook_path?(request.path) && !allowed_webhook_ip?(request.ip)
      return [403, { "Content-Type" => "application/json" },
              [{ error: "IP not allowed" }.to_json]]
    end
 
    @app.call(env)
  end
 
  private
 
  def webhook_path?(path)
    path.match?(%r{^/api/v1/webhooks})
  end
 
  def allowed_webhook_ip?(ip)
    allowlist = @config.rules.dig(:security, :trusted_proxy_ips) || []
    allowlist.any? { |cidr| IPAddr.new(cidr).include?(IPAddr.new(ip)) }
  end
end

# app/models/concerns/rate_limitable.rb
module RateLimitable
  PLANS = {
    free: {
      api_calls_per_minute: 100,
      api_calls_per_day:    10_000,
      search_per_minute:    10,
    },
    pro: {
      api_calls_per_minute: 500,
      api_calls_per_day:    100_000,
      search_per_minute:    50,
    },
    enterprise: {
      api_calls_per_minute: 5_000,
      api_calls_per_day:    :unlimited,
      search_per_minute:    500,
    },
  }.freeze
 
  def rate_limit_config
    PLANS[subscription_tier.to_sym] || PLANS[:free]
  end
 
  def rate_limit_exceeded?(metric, redis)
    config = rate_limit_config
    limit  = config[metric]
    return false if limit == :unlimited
 
    window  = metric.to_s.include?("day") ? 86_400 : 60
    limiter = RateLimiter::SlidingWindowCounter.new(redis, limit: limit, window: window)
    !limiter.allow?("user:#{id}:#{metric}")
  end
end
 
# 使用例（コントローラー）
class Api::V1::SearchController < ApplicationController
  before_action :check_search_rate_limit
 
  def index
    # 検索処理
  end
 
  private
 
  def check_search_rate_limit
    return unless current_user.rate_limit_exceeded?(:search_per_minute, Redis.current)
 
    render json: {
      error:   "Search rate limit exceeded",
      plan:    current_user.subscription_tier,
      upgrade: "https://example.com/pricing",
    }, status: :too_many_requests
  end
end

# クライアント側（Ruby）でのリトライ実装例
def api_request_with_retry(path, max_retries: 3)
  retries = 0
  begin
    response = http_client.get(path)
    response
  rescue RateLimitExceeded => e
    retry_after = e.response.headers["Retry-After"].to_i
    retries += 1
    raise if retries >= max_retries
 
    sleep(retry_after + 1)  # +1秒のバッファ
    retry
  end
end

# app/services/rate_limit_metrics.rb
class RateLimitMetrics
  def self.record_block(identifier:, endpoint:, rule_name:)
    cloudwatch = Aws::CloudWatch::Client.new
    cloudwatch.put_metric_data(
      namespace:   "RateLimiter",
      metric_data: [
        {
          metric_name: "BlockedRequests",
          value:       1,
          unit:        "Count",
          dimensions:  [
            { name: "Endpoint", value: endpoint },
            { name: "RuleName", value: rule_name },
          ],
        },
      ]
    )
 
    # Datadog APM にも送信
    StatsD.increment("rate_limiter.blocked",
      tags: ["endpoint:#{endpoint}", "rule:#{rule_name}"])
  end
end

# CloudWatch アラーム設定
Alarms:
  HighBlockRate:
    MetricName: BlockedRequests
    Namespace: RateLimiter
    Period: 60
    Threshold: 1000          # 1分間で1000件ブロックされたらアラート
    ComparisonOperator: GreaterThanThreshold
    AlarmActions:
      - !Ref PagerDutySnsTopic
 
  SuspiciousIP:
    MetricName: BlockedRequests
    Dimensions:
      IdentifierType: ip
    Period: 300
    Threshold: 500
    AlarmActions:
      - !Ref SecurityTeamTopic

# spec/services/rate_limiter/sliding_window_counter_spec.rb
RSpec.describe RateLimiter::SlidingWindowCounter do
  let(:redis)   { MockRedis.new }
  let(:limiter) { described_class.new(redis, limit: 5, window: 60) }
  let(:id)      { "user:test_123" }
 
  describe "#allow?" do
    context "制限値以内のリクエスト" do
      it "5回まで許可する" do
        5.times { expect(limiter.allow?(id)).to be true }
      end
    end
 
    context "制限値を超えたリクエスト" do
      before { 5.times { limiter.allow?(id) } }
 
      it "6回目を拒否する" do
        expect(limiter.allow?(id)).to be false
      end
    end
 
    context "ウィンドウ境界付近（境界値テスト）" do
      it "前ウィンドウのカウントを加重して判定する" do
        prev_window = Time.current.to_i / 60 - 1
        redis.set("sw:#{id}:#{prev_window}", 4)
 
        # 現在ウィンドウ開始から30秒経過（50%）
        travel_to(Time.zone.at((Time.current.to_i / 60) * 60 + 30)) do
          # 重み付きカウント: 4 × 0.5 + 0 = 2.0 → 制限5に対して余裕あり
          expect(limiter.allow?(id)).to be true
        end
      end
    end
  end
end

# spec/requests/rate_limiting_spec.rb
RSpec.describe "Rate Limiting Integration", type: :request do
  it "Free プランは1分間に100リクエストまで許可する" do
    user  = create(:user, :free_plan)
    token = JwtService.encode(user_id: user.id, tier: "free")
 
    100.times do |i|
      get "/api/v1/products", headers: { "Authorization" => "Bearer #{token}" }
      expect(response).to have_http_status(:ok), "#{i + 1}回目が失敗"
      expect(response.headers["X-RateLimit-Remaining"]).to eq((99 - i).to_s)
    end
 
    get "/api/v1/products", headers: { "Authorization" => "Bearer #{token}" }
    expect(response).to have_http_status(429)
    expect(response.headers["Retry-After"]).to be_present
  end
 
  it "429 レスポンスには必要なヘッダーが揃っている" do
    user  = create(:user, :free_plan)
    token = JwtService.encode(user_id: user.id, tier: "free")
    101.times { get "/api/v1/products", headers: { "Authorization" => "Bearer #{token}" } }
 
    expect(response.headers.keys).to include(
      "X-RateLimit-Limit",
      "X-RateLimit-Remaining",
      "X-RateLimit-Reset",
      "Retry-After"
    )
  end
end