dhc 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14a53cb09332bb3da43ed44f070d8671b34d5881f4a4b6b44ae4403d90a95ad9
-  data.tar.gz: 1d1b3a129ad75f53cbe0c1bc03add6805c678f88eb2fc40038c21183742ef69e
+  metadata.gz: 8e8b5fcc2c830eb7bb23451c7b7063acafe94bad5cc036e9e13a306b883aea82
+  data.tar.gz: b1095ae1fc29cdb675bddf4c9b85c3456d846a1cfe63200f6bd05b6b3396644c
 SHA512:
-  metadata.gz: c6beddb11566cab553e511ccc16e626ec9139a14d18ffb3ae60ea3312867e4a207c8f68c2da77494c6b72a487ea845194d4d9ef87fee11ff4aad87850397e955
-  data.tar.gz: c82721bc5c65649dc0084a739c9ec69dfab35ebb932c06ad62cfc86280dd2e38e0bd8651c74705a06ff1c7e1c9fe64aed17c41ccf747df5a178c8dbe61387915
+  metadata.gz: 006f5af5737d3b51c724188ea676491ed13bbae2e21a252dec0f81a1f0ffa03508ce3b268539d87ea2f95465cbb9e5e634193d7669cffd59c0f2a1ae471f32ed
+  data.tar.gz: 124f5fd5cc80589323d065478f4d3d926e40c63e4e793ea20c4ade116032d095feb7b6218e76a8d617f2001a8e94674134b7c0500dd6504c3a711ea03e781c31

data/.rubocop.yml

@@ -62,6 +62,9 @@ Style/SingleArgumentDig:
 Metrics/ClassLength:
   Enabled: false
 
+Metrics/PerceivedComplexity:
+  Enabled: false
+
 Style/OptionalBooleanParameter:
   Enabled: false
 

data/README.md

@@ -854,6 +854,8 @@ If it raises, it forwards the request and response object to rollbar, which cont
 
 The throttle interceptor allows you to raise an exception if a predefined quota of a provider request limit is reached in advance.
 
+The throttle state (tracker) is stored in Rails.cache.
+
 ```ruby
   DHC.configure do |c|
     c.interceptors = [DHC::Throttle]
@@ -889,10 +891,33 @@ DHC.get('http://depay.fi', options)
 * `remaining`:
   * a hash pointing at the response header containing the current amount of remaining requests
   * a proc that receives the response as argument and returns the current amount of remaining requests
+  * not set: will track remaining by counting down limit until `expires`
 * `expires`:
   * a hash pointing at the response header containing the timestamp when the quota will reset
   * a proc that receives the response as argument and returns the timestamp when the quota will reset
+  * an ActiveSupport::Duration e.g. 1.minute
+
+Example for throttling manually without relating to any information in the response:
 
+```ruby
+options = {
+  throttle: {
+    track: true,
+    break: '80%',
+    provider: 'depay.fi',
+    limit: 100,
+    expires: 1.minute
+  }
+}
+
+DHC.get('http://depay.fi', options)
+```
+
+Will reset every minute, and will allow up to 80 requests per minute. The 81st request attempt within a minute will raise:
+
+```ruby
+DHC::Throttle::OutOfQuota: Reached predefined quota for depay.fi
+```
 
 #### Zipkin
 

data/lib/dhc/interceptors/throttle.rb

@@ -6,80 +6,117 @@ class DHC::Throttle < DHC::Interceptor
   class OutOfQuota < StandardError
   end
 
+  CACHE_KEY = 'DHC/throttle/tracker/v1'
+
   class << self
-    attr_accessor :track
+
+    def tracker(provider)
+      (Rails.cache.read(CACHE_KEY) || {})[provider] || {}
+    end
+
+    def tracker=(track)
+      Rails.cache.write(CACHE_KEY, tracker(track[:provider]).merge({ track[:provider] => track }))
+    end
   end
 
   def before_request
-    options = request.options.dig(:throttle)
     return unless options
-    break_options = options.dig(:break)
-    return unless break_options
-    break_when_quota_reached! if break_options.match('%')
+    break! if break?
   end
 
   def after_response
-    options = response.request.options.dig(:throttle)
-    return unless throttle?(options)
-    self.class.track ||= {}
-    self.class.track[options.dig(:provider)] = {
-      limit: limit(options: options[:limit], response: response),
-      remaining: remaining(options: options[:remaining], response: response),
-      expires: expires(options: options[:expires], response: response)
+    return unless track?
+    self.class.tracker = {
+      provider: options.dig(:provider),
+      limit: limit,
+      remaining: remaining,
+      expires: expires
     }
   end
 
   private
 
-  def throttle?(options)
-    [options&.dig(:track), response.headers].none?(&:blank?)
+  def options
+    @options ||= request.options.dig(:throttle) || {}
+  end
+
+  def provider
+    @provider ||= request.options.dig(:throttle, :provider)
+  end
+
+  def track?
+    (options.dig(:remaining) && [options.dig(:track), response.headers].none?(&:blank?) ||
+      options.dig(:track).present?
+    )
+  end
+
+  def break?
+    @do_break ||= begin
+      return if options.dig(:break) && !options.dig(:break).match('%')
+      tracker = self.class.tracker(options[:provider])
+      return if tracker.blank? || tracker[:remaining].blank? || tracker[:limit].blank? || tracker[:expires].blank?
+      return if Time.zone.now > tracker[:expires]
+      remaining = tracker[:remaining] * 100
+      limit = tracker[:limit]
+      remaining_quota = 100 - options[:break].to_i
+      remaining < remaining_quota * limit
+    end
   end
 
-  def break_when_quota_reached!
-    options = request.options.dig(:throttle)
-    track = (self.class.track || {}).dig(options[:provider])
-    return if track.blank? || track[:remaining].blank? || track[:limit].blank? || track[:expires].blank?
-    return if Time.zone.now > track[:expires]
-    # avoid floats by multiplying with 100
-    remaining = track[:remaining] * 100
-    limit = track[:limit]
-    quota = 100 - options[:break].to_i
-    raise(OutOfQuota, "Reached predefined quota for #{options[:provider]}") if remaining < quota * limit
+  def break!
+    raise(OutOfQuota, "Reached predefined quota for #{provider}")
   end
 
-  def limit(options:, response:)
+  def limit
     @limit ||=
-      if options.is_a?(Proc)
-        options.call(response)
-      elsif options.is_a?(Integer)
-        options
-      elsif options.is_a?(Hash) && options[:header]
-        response.headers[options[:header]]&.to_i
+      if options.dig(:limit).is_a?(Proc)
+        options.dig(:limit).call(response)
+      elsif options.dig(:limit).is_a?(Integer)
+        options.dig(:limit)
+      elsif options.dig(:limit).is_a?(Hash) && options.dig(:limit, :header) && response.headers
+        response.headers[options.dig(:limit, :header)]&.to_i
       end
   end
 
-  def remaining(options:, response:)
-    @remaining ||=
-      begin
-        if options.is_a?(Proc)
-          options.call(response)
-        elsif options.is_a?(Hash) && options[:header]
-          response.headers[options[:header]]&.to_i
+  def remaining
+    @remaining ||= begin
+      if options.dig(:remaining).is_a?(Proc)
+        options.dig(:remaining).call(response)
+      elsif options.dig(:remaining).is_a?(Hash) && options.dig(:remaining, :header) && response.headers
+        response.headers[options.dig(:remaining, :header)]&.to_i
+      elsif options.dig(:remaining).blank?
+        remaining_before = self.class.tracker(provider).dig(:remaining) || request.options.dig(:throttle, :limit)
+        expires = self.class.tracker(provider).dig(:expires)
+        if expires && expires > DateTime.now
+          remaining_before - 1
+        else
+          request.options.dig(:throttle, :limit) - 1
         end
       end
+    end
   end
 
-  def expires(options:, response:)
-    @expires ||= convert_expires(read_expire_option(options, response))
-  end
+  def expires
+    @expires ||= begin
+      if options.dig(:expires).is_a?(ActiveSupport::Duration) && self.class.tracker(provider).dig(:expires).present?
+        if self.class.tracker(provider)[:expires] > DateTime.now
+          self.class.tracker(provider)[:expires]
+        else
+          DateTime.now + options.dig(:expires)
+        end
+      elsif options.dig(:expires).is_a?(Hash) && options.dig(:expires, :header)
 
-  def read_expire_option(options, response)
-    (options.is_a?(Hash) && options[:header]) ? response.headers[options[:header]] : options
+        convert_expire_value(response.headers[options.dig(:expires, :header)]) if response.headers
+      else
+        convert_expire_value(options.dig(:expires))
+      end
+    end
   end
 
-  def convert_expires(value)
+  def convert_expire_value(value)
     return if value.blank?
     return value.call(response) if value.is_a?(Proc)
+    return DateTime.now + value if value.is_a?(ActiveSupport::Duration)
     return Time.parse(value) if value.match(/GMT/)
     Time.zone.at(value.to_i).to_datetime
   end

data/lib/dhc/rspec.rb

@@ -6,6 +6,6 @@ RSpec.configure do |config|
   config.before(:each) do
     DHC::Caching.cache = ActiveSupport::Cache::MemoryStore.new
     DHC::Caching.cache.clear
-    DHC::Throttle.track = nil
+    Rails.cache.write(DHC::Throttle::CACHE_KEY, nil) if defined? Rails
   end
 end

data/lib/dhc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DHC
-  VERSION ||= '2.0.1'
+  VERSION ||= '2.1.0'
 end

data/spec/interceptors/throttle/main_spec.rb

@@ -25,8 +25,8 @@ describe DHC::Throttle do
   end
 
   before(:each) do
-    DHC::Throttle.track = nil
     DHC.config.interceptors = [DHC::Throttle]
+    Rails.cache.write(DHC::Throttle::CACHE_KEY, nil)
 
     stub_request(:get, 'http://depay.fi').to_return(
       headers: { 'limit' => quota_limit, 'remaining' => quota_remaining, 'reset' => quota_reset }
@@ -35,8 +35,8 @@ describe DHC::Throttle do
 
   it 'tracks the request limits based on response data' do
     DHC.get('http://depay.fi', options)
-    expect(DHC::Throttle.track[provider][:limit]).to eq quota_limit
-    expect(DHC::Throttle.track[provider][:remaining]).to eq quota_remaining
+    expect(Rails.cache.read('DHC/throttle/tracker/v1')[provider][:limit]).to eq quota_limit
+    expect(Rails.cache.read('DHC/throttle/tracker/v1')[provider][:remaining]).to eq quota_remaining
   end
 
   context 'fix predefined integer for limit' do
@@ -44,7 +44,7 @@ describe DHC::Throttle do
 
     it 'tracks the limit based on initialy provided data' do
       DHC.get('http://depay.fi', options)
-      expect(DHC::Throttle.track[provider][:limit]).to eq options_limit
+      expect(Rails.cache.read('DHC/throttle/tracker/v1')[provider][:limit]).to eq options_limit
     end
   end
 

data/spec/interceptors/throttle/manually_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Throttle do
+  let(:options) do
+    {
+      throttle: {
+        provider: provider,
+        track: true,
+        limit: quota_limit,
+        expires: 1.minute,
+        break: break_after
+      }
+    }
+  end
+
+  let(:provider) { 'depay.fi' }
+  let(:quota_limit) { 100 }
+  let(:break_after) { '80%' }
+
+  before(:each) do
+    DHC.config.interceptors = [DHC::Throttle]
+    Rails.cache.write(DHC::Throttle::CACHE_KEY, nil)
+
+    stub_request(:get, 'http://depay.fi').to_return(status: 200)
+  end
+
+  it 'tracks the request limits based on response data' do
+    DHC.get('http://depay.fi', options)
+    expect(Rails.cache.read('DHC/throttle/tracker/v1')[provider][:limit]).to eq 100
+    expect(Rails.cache.read('DHC/throttle/tracker/v1')[provider][:remaining]).to eq quota_limit - 1
+  end
+
+  context 'breaks' do
+    let(:quota_limit) { 10 }
+    let(:break_after) { '79%' }
+
+    it 'hit the breaks if throttling quota is reached' do
+      8.times do
+        DHC.get('http://depay.fi', options)
+      end
+      expect { DHC.get('http://depay.fi', options) }.to raise_error(
+        DHC::Throttle::OutOfQuota,
+        'Reached predefined quota for depay.fi'
+      )
+    end
+
+    context 'still within quota' do
+      let(:break_after) { '80%' }
+
+      it 'does not hit the breaks' do
+        9.times do
+          DHC.get('http://depay.fi', options)
+        end
+      end
+    end
+  end
+
+  context 'expires' do
+    let(:break_after) { '80%' }
+    let(:quota_limit) { 10 }
+
+    it 'attempts another request if the quota expired' do
+      9.times do
+        DHC.get('http://depay.fi', options)
+      end
+      expect { DHC.get('http://depay.fi', options) }.to raise_error(
+        DHC::Throttle::OutOfQuota,
+        'Reached predefined quota for depay.fi'
+      )
+      Timecop.travel(Time.zone.now + 1.minute)
+      9.times do
+        DHC.get('http://depay.fi', options)
+      end
+      expect { DHC.get('http://depay.fi', options) }.to raise_error(
+        DHC::Throttle::OutOfQuota,
+        'Reached predefined quota for depay.fi'
+      )
+    end
+  end
+end

data/spec/interceptors/throttle/reset_track_spec.rb

@@ -23,7 +23,6 @@ describe DHC::Throttle do
   let(:expires_in) { (Time.zone.now + 1.hour).to_i }
 
   before(:each) do
-    DHC::Throttle.track = nil
     DHC.config.interceptors = [DHC::Throttle]
 
     stub_request(:get, 'http://depay.fi')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dhc
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - https://github.com/DePayFi/dhc/contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-14 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -338,6 +338,7 @@ files:
 - spec/interceptors/rollbar/invalid_encoding_spec.rb
 - spec/interceptors/rollbar/main_spec.rb
 - spec/interceptors/throttle/main_spec.rb
+- spec/interceptors/throttle/manually_spec.rb
 - spec/interceptors/throttle/reset_track_spec.rb
 - spec/interceptors/zipkin/distributed_tracing_spec.rb
 - spec/rails_helper.rb
@@ -492,6 +493,7 @@ test_files:
 - spec/interceptors/rollbar/invalid_encoding_spec.rb
 - spec/interceptors/rollbar/main_spec.rb
 - spec/interceptors/throttle/main_spec.rb
+- spec/interceptors/throttle/manually_spec.rb
 - spec/interceptors/throttle/reset_track_spec.rb
 - spec/interceptors/zipkin/distributed_tracing_spec.rb
 - spec/rails_helper.rb