rito 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b7b56e2ebcc806ea4e657c2eaf6de65fbf5e2abcb6447a2543c9c7f88fb053f
-  data.tar.gz: a33ab0b69073f9864d843c857b1dd1ff47664f1ea682e75f4feaa9171f00229c
+  metadata.gz: 5ad417d4efb4e93230ccc8e4aba43faaf13b6a6e9f39894e8a0e60ef0666e8ec
+  data.tar.gz: f508bc188dbda8b54f8159b9a3382c00cc93145b7188054558a4c9da377ec244
 SHA512:
-  metadata.gz: 423b3499635cb2c42180112e470ea0dad001b38c91d35ea28cc33ef58e59ad513abb4751f4c5b39a226ed49041fff64affc5b98e689aec2cc9a60aaad4225c8e
-  data.tar.gz: 89c6a06c5aabad571775d23faf15dc5c316ec0cf8e8d67b3f294217fd4249c337867e833524a0953002d34b45a93948b65c175184a6c09e108895681c8cfe18b
+  metadata.gz: d8dde9a5eac05156304fd1fe8d43e4b9463982eef6e9926b366fb589a17447217b744e19e22dca69151ff268a41f967d1e6e767514cdf08b0a060a46686a4638
+  data.tar.gz: cf3993148793c8b5f81b89e27eba30704d63ab74eea357d6ea99ce93eb6a244db483f09ed4b1429f774ec81e969cd5665beffacd32b3d493ddf07257fa32b819

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.4.0 (2026-09-05)
+
+- **Breaking:** LoL `leagues.entries` now requires `queue` before `tier` and
+  `division`, matching the live API path.
+- Tournament and tournament-stub requests route to `americas`; `na1` escalates
+  automatically, and unsupported clusters are rejected.
+- Account routing normalizes SEA platform values (including `sg2`) to `asia`.
+  VALORANT routing values work as client defaults.
+- **Breaking:** Explicit API-key or bearer credentials no longer inherit the other global
+  credential. Explicit `nil` clears credentials; mixed credentials are rejected.
+- Transport failures retry before conversion to Rito errors. Non-JSON HTTP
+  error bodies preserve the HTTP error class; 403 hints include routing and access.
+  Retried 429 POSTs preserve their original request body.
+- Rate-limit buckets isolate API families. Headerless 429 backoff grows
+  exponentially, learned windows survive expiry, deadlines do not slide with
+  responses, and older counts do not erase in-flight reservations. Application
+  and method quota are acquired together.
+- Redis quota checks reserve all windows atomically, preserve counter TTLs,
+  accept zero Retry-After, retain longer blocks, and back off across workers.
+- Request instrumentation emits one completion event for successes and errors,
+  including bearer requests, with total network attempts and elapsed time.
+- Model fields and raw payloads are recursively frozen. Documentation identifies
+  endpoints returning parsed JSON and replaces removed method examples.
+- Added a schema snapshot contract test, live-path regressions, retry and
+  instrumentation tests, and Redis concurrency coverage. Explicitly configured
+  Redis must be available for tests.
+
 ## 0.3.1 (2026-09-05)
 
 Fixed endpoint diffs against the current riotapi-schema (last generated

data/README.md

@@ -4,7 +4,7 @@ A modern, production-ready Ruby client for the Riot Games API: League of
 Legends, TFT, VALORANT, Legends of Runeterra, Riftbound, and the Riot Account API.
 
 Full routing-value handling, header-driven adaptive rate limiting, frozen
-`Data` models, and a single runtime dependency (Faraday).
+`Data` models, and Faraday transport with faraday-retry.
 
 ## Installation
 
@@ -42,8 +42,14 @@ Rito.rate_limiter   # rate limit strategy (default: AdaptiveLimiter)
 
 # per-client, for multi-key apps:
 client = Rito::Client.new(api_key: "RGAPI-...", region: :kr)
+rso_client = Rito::Client.new(bearer_token: access_token, region: :americas)
 ```
 
+Explicit credentials select API-key or bearer authentication without inheriting
+the other credential from global config. Use separate clients for API-key and
+RSO requests; configuring both credentials on one client raises `ConfigError`.
+Explicit `nil` clears a credential.
+
 ## Queues
 
 `Rito::Queues` is a frozen, built-in reference for League queue ids as
@@ -178,9 +184,10 @@ limiter = Rito::RateLimiting::RedisLimiter.new(redis: Redis.new)
 client = Rito::Client.new(rate_limiter: limiter)
 ```
 
-Note: `acquire!` blocks the calling thread while throttled — fine in
-background jobs; in web requests prefer jobs or `max_retries: 0` with
-explicit `Rito::RateLimited` handling.
+`acquire!` blocks the calling thread while throttled, so use background jobs
+for work that must not block a web request. `max_retries: 0` disables retries;
+it does not disable pre-emptive waiting. `NullLimiter` disables limiter-based
+waiting entirely.
 
 ### Multi-process (Redis)
 
@@ -207,16 +214,25 @@ URL, and Riot's error detail.
 
 ## Models
 
-Responses are frozen `Data` objects. Documented fields are typed accessors;
-unknown fields Riot adds later are preserved in `.raw`:
+Account, summoner, LoL match, mastery, rotation, and league responses have
+`Data` models. Their mapped fields and `.raw` payloads are recursively frozen;
+unknown fields Riot adds later are preserved in `.raw`. Other endpoints return
+parsed JSON hashes, arrays, or scalar values, including timelines, status,
+Clash, challenges, tournaments, and most TFT, VALORANT, and LoR responses:
 
 ```ruby
-entry = client.leagues.entries_by_summoner_id(summoner_id).first
+entry = client.leagues.entries_by_puuid(puuid).first
 entry.tier      # => "DIAMOND"
 entry.winrate   # => 57.14
 entry.raw       # => full payload hash
 ```
 
+League listings require a queue, tier, and division:
+
+```ruby
+client.leagues.entries("RANKED_SOLO_5x5", "DIAMOND", "I", page: 1)
+```
+
 ## Coverage
 
 | Accessor | API |
@@ -244,7 +260,7 @@ against the right set per product. `esports` is a valid platform for
 VALORANT content/match and a valid regional for tft-match-v1 (with
 `esportseu`); `apac` is a valid regional for lor-match-v1. The
 tournament endpoints only exist on the `americas`
-platform — pass `region: :na1` or `:americas`.
+host — pass `region: :na1` or `:americas`. Other regional clusters are rejected.
 
 ## Testing your own app
 
@@ -257,8 +273,11 @@ bundle exec rake test
 
 ## Instrumentation
 
-If ActiveSupport is present (e.g. in a Rails app), every request emits a
-`request.rito` notification:
+If ActiveSupport is present (e.g. in a Rails app), each `Rito::Client` request
+emits one `request.rito` notification after it completes, including failures
+and bearer requests. `attempts` counts network attempts across transport and
+429 retries; `duration_ms` includes retry and limiter waits. Configuration and
+routing errors that prevent a request do not emit an event:
 
 ```ruby
 ActiveSupport::Notifications.subscribe("request.rito") do |*, payload|
@@ -275,10 +294,24 @@ Without ActiveSupport, instrumentation is a no-op.
 
 ```
 bundle install
+bundle exec rake lint
 bundle exec rake test
 ```
 
-Ruby 3.2+ required (`Data.define`).
+Ruby 3.2+ required (`Data.define`). Redis tests use `REDIS_URL` when set and
+fail if that configured Redis is unavailable; otherwise they try localhost
+and skip if it is unavailable.
+
+The endpoint contract test uses a checked-in snapshot of riotapi-schema
+(paths, routing hosts, and query parameters). Refresh it with
+`bundle exec rake api_routes`, review the diff, and run the suite.
+
+Live read-only checks use `bundle exec ruby scripts/live_matrix.rb` with
+`RIOT_API_KEY_TEST` and `RIOT_API_KEY_PROD` in `.env`. Access varies by key and
+product: a 403 can indicate missing product access or an incorrect path/host,
+as well as an expired key. API keys cannot validate RSO-only endpoints;
+those need an RSO access token. Synthetic-id 404s establish no successful
+payload coverage.
 
 ## License
 

data/lib/rito/client.rb

@@ -5,10 +5,13 @@ module Rito
     attr_reader :api_key, :bearer_token, :region, :limiter, :max_retries,
                 :open_timeout, :timeout, :adapter
 
-    def initialize(api_key: nil, bearer_token: nil, region: nil, rate_limiter: nil,
+    UNSET = Object.new.freeze
+    private_constant :UNSET
+
+    def initialize(api_key: UNSET, bearer_token: UNSET, region: nil, rate_limiter: nil,
                    max_retries: nil, open_timeout: nil, timeout: nil, adapter: nil)
-      @api_key = api_key || Rito.api_key
-      @bearer_token = bearer_token || Rito.bearer_token
+      @api_key = api_key.equal?(UNSET) ? (Rito.api_key if bearer_token.equal?(UNSET)) : api_key
+      @bearer_token = bearer_token.equal?(UNSET) ? (Rito.bearer_token if api_key.equal?(UNSET)) : bearer_token
       @region = region || Rito.region
       @limiter = rate_limiter || Rito.rate_limiter || RateLimiting::AdaptiveLimiter.new
       @max_retries = max_retries || Rito.max_retries
@@ -92,16 +95,38 @@ module Rito
       Endpoints::Riftbound.new(self)
     end
 
-    def request(method, path, routing_kind:, routing_value: nil, params: {}, body: nil)
+    def request(method, path, routing_kind:, routing_value: nil, regions: nil, params: {}, body: nil)
       region = Routing.resolve(routing_kind, routing_value || @region)
+      raise ArgumentError, "#{region.inspect} is not supported by this endpoint" if regions && !regions.include?(region)
+
       connection = @connection.for_host(Routing.host_for(region))
+      context = { attempts: 0 }
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      url = connection.build_url(path, params).to_s
       response = connection.run_request(method, path, body, {}) do |req|
+        req.options.context = context
         req.params.update(params) unless params.empty?
       end
-      # 5xx responses reaching here are final: faraday-retry has exhausted
-      # its retries (or the status was not retryable).
+      # Transport errors and final 5xx must be converted after Faraday's retries.
       raise_server_error!(response) if response.status >= 500
       response
+    rescue Faraday::ConnectionFailed => e
+      raise ConnectionError.new('Connection failed', wrapped: e)
+    rescue Faraday::TimeoutError, ::Timeout::Error => e
+      raise TimeoutError.new('Request timed out', wrapped: e)
+    rescue Faraday::SSLError => e
+      raise SSLError.new('TLS connection failed', wrapped: e)
+    ensure
+      if context && context[:attempts].positive?
+        error = $ERROR_INFO
+        Instrumentation.emit(
+          http_method: method, url: url,
+          status: response&.status || (error.status if error.respond_to?(:status)),
+          attempts: context[:attempts],
+          duration_ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round(2),
+          error: error&.class&.name
+        )
+      end
     end
 
     private
@@ -114,7 +139,11 @@ module Rito
 
     def validate!
       raise ConfigError, 'api_key or bearer_token is required' if @api_key.to_s.empty? && @bearer_token.to_s.empty?
-      return if Routing.platform?(@region) || Routing.regional?(@region)
+      if @api_key && @bearer_token
+        raise ConfigError, 'configure either api_key or bearer_token; use separate clients for API and RSO requests'
+      end
+      return if Routing.platform?(@region) || Routing.regional?(@region) ||
+                Routing::VALORANT_PLATFORMS.include?(Routing.normalize(@region))
 
       raise ConfigError, "unknown region: #{@region.inspect}"
     end

data/lib/rito/endpoints/base.rb

@@ -10,19 +10,24 @@ module Rito
       private
 
       def get(path, region = nil, params: {})
-        @client.request(:get, path, routing_kind: routing_kind, routing_value: region, params: params).body
+        @client.request(:get, path, routing_kind: routing_kind, routing_value: region, regions: regions,
+                                    params: params).body
       end
 
       def post(path, region = nil, params: {}, body: nil)
-        @client.request(:post, path, routing_kind: routing_kind, routing_value: region,
+        @client.request(:post, path, routing_kind: routing_kind, routing_value: region, regions: regions,
                                      params: params, body: body).body
       end
 
       def put(path, region = nil, params: {}, body: nil)
-        @client.request(:put, path, routing_kind: routing_kind, routing_value: region,
+        @client.request(:put, path, routing_kind: routing_kind, routing_value: region, regions: regions,
                                     params: params, body: body).body
       end
 
+      def regions
+        self.class::REGIONS if self.class.const_defined?(:REGIONS)
+      end
+
       def routing_kind
         self.class::ROUTING
       end

data/lib/rito/endpoints/lol/league_v4.rb

@@ -29,10 +29,10 @@ module Rito
             .map { |hash| Models::LeagueEntry.from_api(hash) }
         end
 
-        def entries(tier, division, page: nil, region: nil)
+        def entries(queue, tier, division, page: nil, region: nil)
           params = {}
           params['page'] = page if page
-          get("/lol/league/v4/entries/#{escape(tier)}/#{escape(division)}", region, params: params)
+          get("/lol/league/v4/entries/#{escape(queue)}/#{escape(tier)}/#{escape(division)}", region, params: params)
             .map { |hash| Models::LeagueEntry.from_api(hash) }
         end
       end

data/lib/rito/endpoints/lol/tournament_v5.rb

@@ -4,7 +4,8 @@ module Rito
   module Endpoints
     module Lol
       class TournamentV5 < Base
-        ROUTING = :platform
+        ROUTING = :regional
+        REGIONS = %w[americas].freeze
         PREFIX = '/lol/tournament/v5'
 
         def code(tournament_code, region: nil)
@@ -39,7 +40,8 @@ module Rito
       end
 
       class TournamentStubV5 < Base
-        ROUTING = :platform
+        ROUTING = :regional
+        REGIONS = %w[americas].freeze
         PREFIX = '/lol/tournament-stub/v5'
 
         def code(tournament_code, region: nil)

data/lib/rito/middleware/rate_limit_observe.rb

@@ -12,10 +12,10 @@ module Rito
 
       def on_complete(env)
         limiter = @client.limiter
-        return if limiter.nil? || @client.api_key.nil?
+        key = @client.api_key || @client.bearer_token
+        return if limiter.nil? || key.nil?
 
-        limiter.observe!(Faraday::Response.new(env), key: @client.api_key,
-                                                     region: region_from(env), bucket: bucket_from(env))
+        limiter.observe!(Faraday::Response.new(env), key: key, region: region_from(env), bucket: bucket_from(env))
       end
 
       private
@@ -25,7 +25,7 @@ module Rito
       end
 
       def bucket_from(env)
-        env.url.path.split('/').first(2).join('/')
+        env.url.path.split('/').reject(&:empty?).first(2).join('/')
       end
     end
   end

data/lib/rito/middleware/rate_limit_throttle.rb

@@ -15,43 +15,29 @@ module Rito
 
       def call(env)
         limiter = @client.limiter
-        key = @client.api_key
-        return @app.call(env) if limiter.nil? || key.nil?
-
-        attempts = 0
-        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        key = @client.api_key || @client.bearer_token
+        retries = 0
+        request_body = env.body
         begin
-          limiter.acquire!(key: key, region: region_from(env), bucket: bucket_from(env))
-          response = @app.call(env)
-          emit(env, response.status, started, attempts)
-          response
-        rescue Rito::RateLimited => e
-          emit(env, e.status, started, attempts, error: e.class.name)
-          attempts += 1
-          retry if attempts <= @client.max_retries
+          limiter&.acquire!(key: key, region: region_from(env), bucket: bucket_from(env))
+          env.body = request_body
+          env.request.context[:attempts] += 1 if env.request.context
+          @app.call(env)
+        rescue Rito::RateLimited
+          retries += 1
+          retry if retries <= @client.max_retries
           raise
         end
       end
 
       private
 
-      def emit(env, status, started, attempts, error: nil)
-        Instrumentation.emit(
-          http_method: env.method,
-          url: env.url.to_s,
-          status: status,
-          attempts: attempts,
-          duration_ms: ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round(2),
-          error: error
-        )
-      end
-
       def region_from(env)
         env.url.host.to_s.split('.').first
       end
 
       def bucket_from(env)
-        env.url.path.split('/').first(2).join('/')
+        env.url.path.split('/').reject(&:empty?).first(2).join('/')
       end
     end
   end

data/lib/rito/middleware/riot_errors.rb

@@ -14,31 +14,13 @@ module Rito
         415 => Rito::UnsupportedMediaType
       }.freeze
 
-      # 403 from Riot almost always means the key is bad, and dev keys
-      # expire every 24h — users never guess this from a bare "Forbidden".
-      KEY_STALENESS_HINT = ' (check the API key: dev keys expire every 24h)'
+      FORBIDDEN_HINT = ' (check routing, product access, and the API key: dev keys expire every 24h)'
 
       def initialize(app, client:)
         super(app)
         @client = client
       end
 
-      def call(env)
-        @app.call(env).on_complete { |completed| on_complete(completed) }
-      rescue Faraday::RetriableResponse => e
-        response = e.response
-        raise error_class_for(response.status).new(
-          "#{response.status} (after transport retries)",
-          response: response
-        )
-      rescue Faraday::ConnectionFailed => e
-        raise Rito::ConnectionError.new("#{e.class}: #{e.message}", wrapped: e)
-      rescue Faraday::TimeoutError, Timeout::Error => e
-        raise Rito::TimeoutError.new("#{e.class}: #{e.message}", wrapped: e)
-      rescue Faraday::SSLError => e
-        raise Rito::SSLError.new("#{e.class}: #{e.message}", wrapped: e)
-      end
-
       def on_complete(env)
         return if env.status.between?(200, 299)
         # 5xx are retried by faraday-retry (registered above this middleware);
@@ -72,14 +54,21 @@ module Rito
         end
       end
 
+      def parse_body(body)
+        body = JSON.parse(body) if body.is_a?(String) && !body.empty?
+        body.is_a?(Hash) ? body : {}
+      rescue JSON::ParserError
+        {}
+      end
+
       def message(env)
-        parsed = env.response_body
-        parsed = JSON.parse(parsed) if parsed.is_a?(String) && !parsed.empty?
-        detail = parsed.is_a?(Hash) ? (parsed['message'] || parsed.dig('status', 'message')) : nil
+        parsed = parse_body(env.response_body)
+        status = parsed['status']
+        detail = parsed['message'] || (status['message'] if status.is_a?(Hash))
 
         base = "#{env.status} #{env.method.to_s.upcase} #{env.url}"
         text = detail ? "#{base}: #{detail}" : base
-        text += KEY_STALENESS_HINT if env.status == 403
+        text += FORBIDDEN_HINT if env.status == 403
         text
       end
     end

data/lib/rito/models/account.rb

@@ -8,7 +8,7 @@ module Rito
           puuid: hash['puuid'],
           game_name: hash['gameName'],
           tag_line: hash['tagLine'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end
@@ -19,7 +19,7 @@ module Rito
           puuid: hash['puuid'],
           game: hash['game'],
           active_shard: hash['activeShard'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end
@@ -30,7 +30,7 @@ module Rito
           puuid: hash['puuid'],
           game: hash['game'],
           region: hash['region'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end

data/lib/rito/models/lol.rb

@@ -17,7 +17,7 @@ module Rito
           champion_points_since_last_level: hash['championPointsSinceLastLevel'],
           last_play_time: hash['lastPlayTime'],
           tokens_earned: hash['tokensEarned'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end
@@ -27,7 +27,7 @@ module Rito
         new(
           sr: hash['sr'],
           newplayer: hash['newplayer'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end
@@ -52,7 +52,7 @@ module Rito
           fresh_blood: hash['freshBlood'],
           hot_streak: hash['hotStreak'],
           inactive: hash['inactive'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
 
@@ -72,7 +72,7 @@ module Rito
           name: hash['name'],
           queue: hash['queue'],
           entries: hash['entries'].to_a.freeze,
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end

data/lib/rito/models/match.rb

@@ -11,7 +11,7 @@ module Rito
         new(
           metadata: MatchMetadata.from_api(hash['metadata']),
           info: MatchInfo.from_api(hash['info']),
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end
@@ -23,7 +23,7 @@ module Rito
         new(
           match_id: hash['matchId'],
           participants: hash['participants'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end
@@ -48,9 +48,9 @@ module Rito
           game_type: hash['gameType'],
           game_version: hash['gameVersion'],
           map_id: hash['mapId'],
-          participants: hash['participants']&.map { |p| MatchParticipant.from_api(p) },
+          participants: hash['participants']&.map { |p| MatchParticipant.from_api(p) }&.freeze,
           queue_id: hash['queueId'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end
@@ -67,7 +67,7 @@ module Rito
           summoner_name: hash['summonerName'],
           team_id: hash['teamId'],
           win: hash['win'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end
@@ -77,7 +77,7 @@ module Rito
         new(
           total: hash['total'],
           match_file_urls: hash['matchFileURLs'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end

data/lib/rito/models/summoner.rb

@@ -15,7 +15,7 @@ module Rito
           profile_icon_id: hash['profileIconId'],
           revision_date: hash['revisionDate'],
           summoner_level: hash['summonerLevel'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
     end

data/lib/rito/models.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Rito
+  module Models
+    def self.deep_freeze(value)
+      case value
+      when Hash
+        value.each do |key, item|
+          deep_freeze(key)
+          deep_freeze(item)
+        end
+      when Array
+        value.each { |item| deep_freeze(item) }
+      end
+      value.freeze
+    end
+  end
+end

data/lib/rito/rate_limiting/adaptive_limiter.rb

@@ -15,8 +15,21 @@ module Rito
       end
 
       def acquire!(key:, region:, bucket:)
-        app_bucket(key, region).wait_until_allowed!
-        method_bucket(key, region, bucket).wait_until_allowed!
+        app = app_bucket(key, region)
+        method = method_bucket(key, region, bucket)
+        loop do
+          delay = @mutex.synchronize do
+            [app.delay, method.delay].max.tap do |wait|
+              if wait.zero?
+                app.consume!
+                method.consume!
+              end
+            end
+          end
+          return if delay.zero?
+
+          @sleeper.call(delay + 0.001)
+        end
       end
 
       def observe!(response, key:, region:, bucket:)
@@ -26,19 +39,15 @@ module Rito
         app = app_bucket(key, region)
         method = method_bucket(key, region, bucket)
 
-        app.apply!(limits: HeaderParser.app_limits(headers), counts: HeaderParser.app_counts(headers))
-        method.apply!(limits: HeaderParser.method_limits(headers), counts: HeaderParser.method_counts(headers))
-
-        return unless status == 429
-
-        retry_after = HeaderParser.retry_after(headers)
-        case HeaderParser.limit_type(headers)
-        when :application
-          app.limit_block!(retry_after)
-        when :method, :service
-          method.limit_block!(retry_after)
-        else
-          method.limit_block!(retry_after)
+        @mutex.synchronize do
+          app.apply!(limits: HeaderParser.app_limits(headers), counts: HeaderParser.app_counts(headers),
+                     limited: status == 429)
+          method.apply!(limits: HeaderParser.method_limits(headers), counts: HeaderParser.method_counts(headers),
+                        limited: status == 429)
+          if status == 429
+            target = HeaderParser.limit_type(headers) == :application ? app : method
+            target.limit_block!(HeaderParser.retry_after(headers))
+          end
         end
       end
 

data/lib/rito/rate_limiting/bucket.rb

@@ -18,7 +18,7 @@ module Rito
         @limited_streak = 0
       end
 
-      def apply!(limits:, counts:)
+      def apply!(limits:, counts:, limited: false)
         @mutex.synchronize do
           now = @clock.call
           if limits.any?
@@ -28,12 +28,12 @@ module Rito
               {
                 limit: limit,
                 window: window,
-                reset_at: now + window,
-                count: counts_by_window.fetch(window) { previous&.fetch(:count) || 0 }
+                reset_at: previous&.fetch(:reset_at) || now + window,
+                count: [counts_by_window.fetch(window, 0), previous&.fetch(:count) || 0].max
               }
             end
           end
-          @limited_streak = 0
+          @limited_streak = 0 unless limited
         end
       end
 
@@ -43,33 +43,32 @@ module Rito
       def limit_block!(retry_after)
         @mutex.synchronize do
           now = @clock.call
-          @limited_streak += 1
-          delay = retry_after || [@limited_streak * DEFAULT_BACKOFF, MAX_BACKOFF].min
-          delay += rand * JITTER
+          @limited_streak = [@limited_streak + 1, 6].min
+          delay = retry_after || [2**(@limited_streak - 1) * DEFAULT_BACKOFF, MAX_BACKOFF].min
+          delay += rand * JITTER unless retry_after
           until_time = now + delay
           @blocked_until = until_time if @blocked_until.nil? || @blocked_until < until_time
         end
       end
 
+      def delay
+        @mutex.synchronize { delay_unlocked }
+      end
+
+      def consume!
+        @mutex.synchronize { @windows.each { |window| window[:count] += 1 } }
+      end
+
       def wait_until_allowed!
         loop do
-          delay = nil
-          @mutex.synchronize do
-            now = @clock.call
-            if @blocked_until && @blocked_until > now
-              delay = @blocked_until - now
-            else
-              @windows.reject! { |w| w[:reset_at] <= now }
-              violating = @windows.find { |w| w[:count] >= w[:limit] }
-              if violating
-                delay = violating[:reset_at] - now
-              else
-                @windows.each { |w| w[:count] += 1 }
-                return
-              end
+          wait = @mutex.synchronize do
+            delay_unlocked.tap do |value|
+              @windows.each { |window| window[:count] += 1 } if value.zero?
             end
           end
-          @sleeper.call(delay + 0.001)
+          return if wait.zero?
+
+          @sleeper.call(wait + 0.001)
         end
       end
 
@@ -78,6 +77,22 @@ module Rito
           @blocked_until && @blocked_until > @clock.call
         end
       end
+
+      private
+
+      def delay_unlocked
+        now = @clock.call
+        @windows.each do |window|
+          next if window[:reset_at] > now
+
+          window[:count] = 0
+          window[:reset_at] = now + window[:window]
+        end
+        delays = @windows.filter_map do |window|
+          window[:reset_at] - now if window[:count] >= window[:limit]
+        end
+        [0, (@blocked_until || now) - now, *delays].max
+      end
     end
   end
 end

data/lib/rito/rate_limiting/header_parser.rb

@@ -12,7 +12,9 @@ module Rito
           limit, window = part.strip.split(':', 2)
           next if limit.nil? || window.nil?
 
-          [Integer(limit), Integer(window)]
+          limit = Integer(limit)
+          window = Integer(window)
+          [limit, window] if limit >= 0 && window.positive?
         rescue ArgumentError
           next
         end

data/lib/rito/rate_limiting/redis_limiter.rb

@@ -24,23 +24,47 @@ module Rito
           end
         end
         for i = 3, #KEYS do
-          local idx = i - 3
-          local limit = tonumber(ARGV[idx * 2 + 1])
-          local window = tonumber(ARGV[idx * 2 + 2])
-          if limit then
-            local count = redis.call('INCR', KEYS[i])
-            if count == 1 then
-              redis.call('EXPIRE', KEYS[i], window)
-            end
-            if count > limit then
-              redis.call('DECR', KEYS[i])
-              return 0
-            end
+          local limit = tonumber(ARGV[(i - 3) * 2 + 1])
+          if tonumber(redis.call('GET', KEYS[i]) or '0') >= limit then
+            return 0
+          end
+        end
+        for i = 3, #KEYS do
+          redis.call('INCR', KEYS[i])
+          if redis.call('PTTL', KEYS[i]) < 0 then
+            redis.call('EXPIRE', KEYS[i], ARGV[(i - 3) * 2 + 2])
           end
         end
         return 1
       LUA
 
+      BLOCK_SCRIPT = <<~LUA
+        local streak = math.min(redis.call('INCR', KEYS[2]), 6)
+        redis.call('EXPIRE', KEYS[2], 600)
+        local delay = tonumber(ARGV[1])
+        if delay < 0 then
+          delay = math.min(2 ^ (streak - 1), 32) * 1000 + tonumber(ARGV[2])
+        end
+        if delay > 0 and redis.call('PTTL', KEYS[1]) < delay then
+          redis.call('SET', KEYS[1], '1', 'PX', delay)
+        end
+      LUA
+
+      SYNC_COUNT_SCRIPT = <<~LUA
+        local current = redis.call('GET', KEYS[1])
+        local count = tonumber(ARGV[1])
+        if not current then
+          redis.call('SET', KEYS[1], count, 'EX', ARGV[2])
+        elseif count > tonumber(current) then
+          local ttl = redis.call('PTTL', KEYS[1])
+          if ttl > 0 then
+            redis.call('SET', KEYS[1], count, 'PX', ttl)
+          else
+            redis.call('SET', KEYS[1], count, 'EX', ARGV[2])
+          end
+        end
+      LUA
+
       def initialize(redis:, sleeper: Kernel.method(:sleep))
         raise DependencyMissing, 'Add the `redis` gem to your Gemfile to use RedisLimiter' unless defined?(::Redis)
 
@@ -61,11 +85,12 @@ module Rito
         status = response.status
         prefix = prefix_for(key, region)
 
+        sync_limits!(prefix, bucket, headers)
+        sync_counts!(prefix, bucket, headers)
         if status == 429
           block!(prefix, bucket, headers)
         else
-          sync_limits!(prefix, bucket, headers)
-          sync_counts!(prefix, bucket, headers)
+          @redis.del("#{prefix}:block:streak", "#{prefix}:m:#{bucket}:block:streak")
         end
       end
 
@@ -99,15 +124,14 @@ module Rito
       end
 
       def block!(prefix, bucket, headers)
-        retry_after = HeaderParser.retry_after(headers) || 2
-        case HeaderParser.limit_type(headers)
-        when :application
-          @redis.set("#{prefix}:block", '1', ex: retry_after)
-        when :method, :service
-          @redis.set("#{prefix}:m:#{bucket}:block", '1', ex: retry_after)
-        else
-          @redis.set("#{prefix}:m:#{bucket}:block", '1', ex: retry_after)
-        end
+        retry_after = HeaderParser.retry_after(headers)
+        block_key = if HeaderParser.limit_type(headers) == :application
+                      "#{prefix}:block"
+                    else
+                      "#{prefix}:m:#{bucket}:block"
+                    end
+        @redis.eval(BLOCK_SCRIPT, keys: [block_key, "#{block_key}:streak"],
+                                  argv: [retry_after ? retry_after * 1000 : -1, rand(500)])
       end
 
       def sync_limits!(prefix, bucket, headers)
@@ -123,13 +147,13 @@ module Rito
       end
 
       def sync_counts!(prefix, bucket, headers)
-        sync_scope_counts!(prefix, HeaderParser.app_counts(headers), "#{prefix}:app")
-        sync_scope_counts!(prefix, HeaderParser.method_counts(headers), "#{prefix}:m:#{bucket}")
+        sync_scope_counts!(HeaderParser.app_counts(headers), "#{prefix}:app")
+        sync_scope_counts!(HeaderParser.method_counts(headers), "#{prefix}:m:#{bucket}")
       end
 
-      def sync_scope_counts!(_prefix, counts, counter_prefix)
+      def sync_scope_counts!(counts, counter_prefix)
         counts.each do |count, window|
-          @redis.set("#{counter_prefix}:#{window}", count.to_s, ex: window)
+          @redis.eval(SYNC_COUNT_SCRIPT, keys: ["#{counter_prefix}:#{window}"], argv: [count, window])
         end
       end
 

data/lib/rito/routing.rb

@@ -71,11 +71,11 @@ module Rito
       end
 
       def regional_for_account(value)
-        v = normalize(value)
+        v = resolve(:regional, value)
+        v = 'asia' if v == 'sea'
         return v if ACCOUNT_REGIONALS.include?(v)
-        return 'asia' if v == 'sea'
 
-        resolve(:regional, v)
+        raise ArgumentError, "#{value.inspect} is not usable as an account routing value"
       end
     end
   end

data/lib/rito/rso/models.rb

@@ -15,7 +15,7 @@ module Rito
           scope: hash['scope'],
           expires_in: hash['expires_in'],
           sub_sid: hash['sub_sid'],
-          raw: hash.freeze
+          raw: Models.deep_freeze(hash)
         )
       end
 
@@ -30,7 +30,7 @@ module Rito
 
     Userinfo = Data.define(:sub, :cpid, :raw) do
       def self.from_api(hash)
-        new(sub: hash['sub'], cpid: hash['cpid'], raw: hash.freeze)
+        new(sub: hash['sub'], cpid: hash['cpid'], raw: Models.deep_freeze(hash))
       end
     end
 

data/lib/rito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rito
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/lib/rito.rb

@@ -2,6 +2,7 @@
 
 # stdlib
 require 'json'
+require 'English'
 require 'uri'
 require 'erb/util'
 
@@ -25,6 +26,7 @@ require_relative 'rito/middleware/riot_errors'
 require_relative 'rito/connection'
 require_relative 'rito/instrumentation'
 require_relative 'rito/client'
+require_relative 'rito/models'
 require_relative 'rito/rso'
 require_relative 'rito/models/account'
 require_relative 'rito/models/summoner'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rito
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - kodbilenadam
@@ -74,6 +74,7 @@ files:
 - lib/rito/middleware/rate_limit_observe.rb
 - lib/rito/middleware/rate_limit_throttle.rb
 - lib/rito/middleware/riot_errors.rb
+- lib/rito/models.rb
 - lib/rito/models/account.rb
 - lib/rito/models/lol.rb
 - lib/rito/models/match.rb