Hanikamu::RateLimit

# Gemfile
gem "hanikamu-rate-limit", "~> 0.4"

# config/initializers/hanikamu_rate_limit.rb
Hanikamu::RateLimit.configure do |config|
  config.redis_url = ENV.fetch("REDIS_URL")
end

class MyService
  extend Hanikamu::RateLimit::Mixin

  # Allow at most 5 calls per second
  limit_method :execute, rate: 5, interval: 1.0

  def execute
    # work
  end
end

MyService.new.execute # waits automatically if the limit is reached

Hanikamu::RateLimit.configure do |config|
  # Required
  config.redis_url = ENV.fetch("REDIS_URL")

  # Optional — tune how the limiter waits when a limit is reached
  config.check_interval  = 0.25   # how often to retry (seconds)
  config.max_wait_time   = 1.5    # give up and raise after this many seconds
  config.wait_strategy   = :sleep # :sleep (block the thread) or :raise (raise immediately)
  config.jitter          = 0.15   # add up to 15 % random spread to prevent thundering herds
  config.metrics_enabled = true   # required if you want the UI dashboard

  # Named limits — share one quota across multiple classes
  config.register_limit(:external_api,
    rate: 20, interval: 1.0,            # 20 requests per second
    check_interval: 0.1, max_wait_time: 5
  )
end

class MyService
  extend Hanikamu::RateLimit::Mixin

  # 5 requests per second
  limit_method :execute, rate: 5, interval: 1.0

  # 10 requests per minute, with custom wait settings and metrics disabled
  limit_method :fetch, rate: 10, interval: 60, check_interval: 0.1, max_wait_time: 3.0, metrics: false

  def execute = "done"
  def fetch   = "fetched"
end

# config/initializers/hanikamu_rate_limit.rb
Hanikamu::RateLimit.configure do |config|
  config.redis_url = ENV.fetch("REDIS_URL")
  config.register_limit(:external_api, rate: 20, interval: 1.0)
end

class ServiceA
  extend Hanikamu::RateLimit::Mixin
  limit_method :call, registry: :external_api
  def call = "a"
end

class ServiceB
  extend Hanikamu::RateLimit::Mixin
  limit_method :call, registry: :external_api
  def call = "b"
end

Hanikamu::RateLimit.register_temporary_limit(
  :external_api,
  remaining: response.headers["X-RateLimit-Remaining"],
  reset:     response.headers["X-RateLimit-Reset"],
  reset_kind: :unix
)

class ExternalApiClient
  extend Hanikamu::RateLimit::Mixin
  limit_method :call, registry: :external_api

  def call
    response = http_client.get("/endpoint")

    if response.headers["X-RateLimit-Remaining"]
      Hanikamu::RateLimit.register_temporary_limit(
        :external_api,
        remaining: response.headers["X-RateLimit-Remaining"],
        reset:     response.headers["X-RateLimit-Reset"],
        reset_kind: :unix  # or :seconds depending on the API
      )
    end

    response
  end
end

class MyService
  class << self
    extend Hanikamu::RateLimit::Mixin
    limit_method :call, registry: :external_api
    def call = "work"
  end
end

limit_method :execute, rate: 5, interval: 1.0 do |sleep_time|
  Rails.logger.info("Rate limited, waiting #{sleep_time}s")
end

Hanikamu::RateLimit.reset_limit!(:external_api)
# => true   (clears the counter and any active temporary override)

MyService.reset_execute_limit!

class RateLimitedJob < ApplicationJob
  extend Hanikamu::RateLimit::JobRetry
  rate_limit_retry

  def perform
    MyService.new.execute
  end
end

class RateLimitedWorker
  include Sidekiq::Worker
  extend Hanikamu::RateLimit::JobRetry
  rate_limit_retry worker: :sidekiq

  def perform
    MyService.new.execute
  end
end

extend Hanikamu::RateLimit::JobRetry
rate_limit_retry attempts: 20, fallback_wait: 10, worker: :sidekiq

Hanikamu::RateLimit.configure do |config|
  config.jitter = 0.15 # adds 0–15 % random spread to each wait
end

Hanikamu::RateLimit.with_wait_strategy(:raise) do
  MyService.new.execute  # raises RateLimitError instead of sleeping
end

Hanikamu::RateLimit.configure do |config|
  config.metrics_enabled = true
end

# config/routes.rb
require "hanikamu/rate_limit/ui"

Rails.application.routes.draw do
  mount Hanikamu::RateLimit::UI::Engine => "/rate-limits"
end

Hanikamu::RateLimit.configure do |config|
  # Local requests only
  config.ui_auth = ->(controller) { controller.request.local? }

  # Devise / Warden
  config.ui_auth = ->(controller) { controller.request.env["warden"]&.user&.admin? }

  # Session-based
  config.ui_auth = ->(controller) { controller.session[:admin] == true }

  # Always allow (development only)
  config.ui_auth = -> { Rails.env.development? }
end

config.ui_max_sse_connections = 5   # conservative (default: 10)
config.ui_max_sse_connections = nil  # no limit (not recommended)

begin
  service.execute
rescue Hanikamu::RateLimit::RateLimitError => e
  e.retry_after # => 0.42 (seconds until a slot opens)
end

around do |example|
  Hanikamu::RateLimit.with_wait_strategy(:raise) { example.run }
end