dhc 2.0.1 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14a53cb09332bb3da43ed44f070d8671b34d5881f4a4b6b44ae4403d90a95ad9
-  data.tar.gz: 1d1b3a129ad75f53cbe0c1bc03add6805c678f88eb2fc40038c21183742ef69e
+  metadata.gz: 0f70dd2da0d8ec740cf21499fc95ba815a73730c2e1c6a4b8cfef6ff18eef0ce
+  data.tar.gz: b0773620c07f30f040439d1c56c7a144ee2f144eb0d987d885aec2b940367b6a
 SHA512:
-  metadata.gz: c6beddb11566cab553e511ccc16e626ec9139a14d18ffb3ae60ea3312867e4a207c8f68c2da77494c6b72a487ea845194d4d9ef87fee11ff4aad87850397e955
-  data.tar.gz: c82721bc5c65649dc0084a739c9ec69dfab35ebb932c06ad62cfc86280dd2e38e0bd8651c74705a06ff1c7e1c9fe64aed17c41ccf747df5a178c8dbe61387915
+  metadata.gz: 3c652d89a8d1dcbeadf72472322881ce136692d1b51630c61f4cf0b058ff96d9ded1345c80238fa5d46599d494328ebaecc007a915283eae1971efe89de8cea6
+  data.tar.gz: 9f71766d909205e3771cd2cfd65130458ac6a73bf35119bd6edf83f1de1ecba418611b66544affd4572b4b275641875d6ae6507fd4a4d07ad1609ae263ff1694

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/dhc.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'prometheus-client', '~> 0.7.1'
   s.add_development_dependency 'pry'
-  s.add_development_dependency 'rails', '>= 5.2'
+  s.add_development_dependency 'rails', '>= 5.2', '< 7'
   s.add_development_dependency 'redis'
   s.add_development_dependency 'rspec-rails', '>= 3.0.0'
   s.add_development_dependency 'rubocop'

data/lib/dhc/interceptors/caching.rb

@@ -23,12 +23,12 @@ class DHC::Caching < DHC::Interceptor
     def fetch(key)
       central_response = @central[:read].fetch(key) if @central && @central[:read].present?
       if central_response
-        puts %([DHC] served from central cache: "#{key}")
+        DHC::Logger.info %([DHC] served from central cache: "#{key}")
         return central_response
       end
       local_response = @local.fetch(key) if @local
       if local_response
-        puts %([DHC] served from local cache: "#{key}")
+        DHC::Logger.info %([DHC] served from local cache: "#{key}")
         return local_response
       end
     end

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, (Rails.cache.read(CACHE_KEY) || {}).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/logger.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'forwardable'
+
+class DHC::Logger < Logger
+  include ActiveSupport::Configurable
+  include Singleton
+
+  config_accessor :logger
+
+  class << self
+    extend Forwardable
+    def_delegators :instance, :log, :info, :error, :warn, :debug
+  end
+
+  def initialize(logdev = nil)
+    super
+    if DHC::Logger.logger
+      self.logger = DHC::Logger.logger
+    elsif defined? Rails
+      self.logger = Rails.logger
+    end
+  end
+
+  def self.log(severity, message = nil, progname = nil)
+    return if logger.blank?
+    logger.log(severity, message, progname)
+  end
+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.2.1'
 end

data/lib/dhc.rb

@@ -72,6 +72,7 @@ module DHC
   autoload :Response, 'dhc/response'
   autoload :Rollbar, 'dhc/interceptors/rollbar'
   autoload :Zipkin, 'dhc/interceptors/zipkin'
+  autoload :Logger, 'dhc/logger'
 
   require 'dhc/railtie' if defined?(Rails)
 end

data/spec/interceptors/caching/multilevel_cache_spec.rb

@@ -46,8 +46,8 @@ describe DHC::Caching do
     it 'serves a response from local cache without trying the central cache' do
       expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
       expect(Rails.cache).to receive(:write).and_call_original
-      expect(-> { response_has_been_cached_and_served_from_cache! })
-        .to output(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+      expect(DHC::Logger).to receive(:info).with(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"}).and_call_original
+      response_has_been_cached_and_served_from_cache!
     end
   end
 
@@ -67,8 +67,8 @@ describe DHC::Caching do
         expect(redis_cache).to receive(:write).and_return(true)
         expect(Rails.cache).to receive(:fetch).and_call_original
         expect(Rails.cache).to receive(:write).and_call_original
-        expect(-> { response_has_been_cached_and_served_from_cache! })
-          .to output(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+        expect(DHC::Logger).to receive(:info).with(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"}).and_call_original
+        response_has_been_cached_and_served_from_cache!
       end
     end
 
@@ -78,8 +78,8 @@ describe DHC::Caching do
         expect(redis_cache).to receive(:write).and_return(true)
         expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
         expect(Rails.cache).to receive(:write).and_call_original
-        expect(-> { response_has_been_cached_and_served_from_cache! })
-          .to output(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+        expect(DHC::Logger).to receive(:info).with(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"}).and_call_original
+        response_has_been_cached_and_served_from_cache!
       end
     end
   end
@@ -97,8 +97,8 @@ describe DHC::Caching do
       expect(redis_cache).not_to receive(:write)
       expect(Rails.cache).to receive(:fetch).and_call_original
       expect(Rails.cache).to receive(:write).and_call_original
-      expect(-> { response_has_been_cached_and_served_from_cache! })
-        .to output(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+      expect(DHC::Logger).to receive(:info).with(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"}).and_call_original
+      response_has_been_cached_and_served_from_cache!
     end
   end
 
@@ -115,8 +115,8 @@ describe DHC::Caching do
       expect(redis_cache).to receive(:write).and_return(true)
       expect(Rails.cache).to receive(:fetch).at_least(:once).and_call_original
       expect(Rails.cache).to receive(:write).and_call_original
-      expect(-> { response_has_been_cached_and_served_from_cache! })
-        .to output(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+      expect(DHC::Logger).to receive(:info).with(%{[DHC] served from local cache: "DHC_CACHE(v1): GET http://depay.fi"}).and_call_original
+      response_has_been_cached_and_served_from_cache!
     end
   end
 
@@ -132,8 +132,8 @@ describe DHC::Caching do
     it 'does not inquire the local cache for information neither to write them' do
       expect(redis_cache).to receive(:fetch).and_return(nil, body: '<h1>Hi there</h1>', code: 200, headers: nil, return_code: nil, mock: :webmock)
       expect(redis_cache).to receive(:write).and_return(true)
-      expect(-> { response_has_been_cached_and_served_from_cache! })
-        .to output(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"\n}).to_stdout
+      expect(DHC::Logger).to receive(:info).with(%{[DHC] served from central cache: "DHC_CACHE(v1): GET http://depay.fi"}).and_call_original
+      response_has_been_cached_and_served_from_cache!
     end
   end
 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,110 @@
+# 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) { 100 }
+    let(:break_after) { '79%' }
+
+    it 'hit the breaks if throttling quota is reached' do
+      79.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
+        80.times do
+          DHC.get('http://depay.fi', options)
+        end
+      end
+
+      it 'does hit the breaks surpassing quota' do
+        80.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
+
+  context 'expires' do
+    let(:break_after) { '80%' }
+    let(:quota_limit) { 100 }
+
+    it 'attempts another request if the quota expired' do
+      80.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)
+      80.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
+
+  context 'multiple provider' do
+    it 'tracks multiple providers without a problem' do
+      DHC.get('http://depay.fi', options)
+      stub_request(:get, 'http://depay.app').to_return(status: 200)
+      DHC.get('http://depay.app', {
+                throttle: {
+                  provider: 'depay.app',
+                  track: true,
+                  limit: quota_limit,
+                  expires: 1.minute,
+                  break: break_after
+                }
+              })
+      expect(Rails.cache.read('DHC/throttle/tracker/v1')['depay.fi']).to be_present
+      expect(Rails.cache.read('DHC/throttle/tracker/v1')['depay.app']).to be_present
+    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.2.1
 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-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -87,6 +87,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -94,6 +97,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -231,6 +237,7 @@ files:
 - lib/dhc/interceptors/rollbar.rb
 - lib/dhc/interceptors/throttle.rb
 - lib/dhc/interceptors/zipkin.rb
+- lib/dhc/logger.rb
 - lib/dhc/railtie.rb
 - lib/dhc/request.rb
 - lib/dhc/response.rb
@@ -338,6 +345,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 +500,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