lhc 12.1.3 → 12.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1d43867c7519eb1697f118fb44668142aa46bcdfb13d725be6617c74f4ed47f
-  data.tar.gz: cdfa710bc5c7ae5297eeceec6858738ad414e828237038b92a3dcbaa9c088fed
+  metadata.gz: 1a536d04e90db04fdeca6edd06c3e88782106a660d410a1b908b94147a3e9154
+  data.tar.gz: d0d89904a00069fdd8f3ef297f296e5da9d1383a4b4239aeebf00b6869be082a
 SHA512:
-  metadata.gz: 9e11b8821556d2bb0e40b91cb080379fc82a3a90453fe36dd6127b4d26a571d065637275988ba03b46d96f6217a697022d0a6aa46532ab20a5d46e1ef5dbadfd
-  data.tar.gz: 192cabec15b2d1881a14505343f2e2f4218fad00ffaac4935dd3d1edbdc6132edb6b9ae0834f2d556dfbcacca9221f473f39dba37071ec40949e407bc953813f
+  metadata.gz: 858291c8b53ce6447df1cc23fabd7c74ca4307ff7590eaebb76f4d538b769f81d9d89055bf79bf564814cf55c6832fccee42918100433061331252c6aafd8042
+  data.tar.gz: 49356178736094b85a4d9c1eab8dcf390024df5b580cb696e7f02683cbc1f1cf4a3e5bcfc6e03f5e8b9330fed1e02b94dd8bbbe17ec3c58e14b91b7352df9030

data/README.md

@@ -94,6 +94,7 @@ use it like:
 
 
 
+
 ## Basic methods
 
 Available are `get`, `post`, `put` & `delete`.
@@ -263,7 +264,7 @@ You can also use URL templates, when [configuring endpoints](#configuring-endpoi
   LHC.configure do |c|
     c.endpoint(:find_feedback, 'http://datastore/v2/feedbacks/{id}')
   end
-  
+
   LHC.get(:find_feedback, params:{ id: 123 }) # GET http://datastore/v2/feedbacks/123
 ```
 
@@ -276,7 +277,7 @@ Working and configuring timeouts is important, to ensure your app stays alive wh
 LHC forwards two timeout options directly to typhoeus:
 
 `timeout` (in seconds) - The maximum time in seconds that you allow the libcurl transfer operation to take. Normally, name lookups can take a considerable time and limiting operations to less than a few seconds risk aborting perfectly normal operations. This option may cause libcurl to use the SIGALRM signal to timeout system calls.
-`connecttimeout` (in seconds) - It should contain the maximum time in seconds that you allow the connection phase to the server to take. This only limits the connection phase, it has no impact once it has connected. Set to zero to switch to the default built-in connection timeout - 300 seconds. 
+`connecttimeout` (in seconds) - It should contain the maximum time in seconds that you allow the connection phase to the server to take. This only limits the connection phase, it has no impact once it has connected. Set to zero to switch to the default built-in connection timeout - 300 seconds.
 
 ```ruby
 LHC.get('http://local.ch', timeout: 5, connecttimeout: 1)
@@ -481,7 +482,7 @@ You can configure global placeholders, that are used when generating urls from u
     c.placeholder(:datastore, 'http://datastore')
     c.endpoint(:feedbacks, '{+datastore}/feedbacks', { params: { has_reviews: true } })
   end
-  
+
   LHC.get(:feedbacks) # http://datastore/v2/feedbacks
 ```
 
@@ -729,7 +730,7 @@ LHC::Monitoring.env = ENV['DEPLOYMENT_TYPE'] || Rails.env
 
 It tracks request attempts with `before_request` and `after_request` (counts).
 
-In case your workers/processes are getting killed due limited time constraints, 
+In case your workers/processes are getting killed due limited time constraints,
 you are able to detect deltas with relying on "before_request", and "after_request" counts:
 
 ```ruby
@@ -780,7 +781,7 @@ Logs basic request/response information to prometheus.
   LHC.configure do |c|
     c.interceptors = [LHC::Prometheus]
   end
-    
+
   LHC::Prometheus.client = Prometheus::Client
   LHC::Prometheus.namespace = 'web_location_app'
 ```
@@ -802,7 +803,7 @@ If you enable the retry interceptor, you can have LHC retry requests for you:
   LHC.configure do |c|
     c.interceptors = [LHC::Retry]
   end
-  
+
   response = LHC.get('http://local.ch', retry: true)
 ```
 
@@ -877,15 +878,15 @@ The throttle interceptor allows you to raise an exception if a predefined quota
   end
 ```
 ```ruby
-options = { 
+options = {
   throttle: {
-    track: true, # enables tracking of current limit/remaining requests of rate-limiting
-    break: '80%', # quota in percent after which errors are raised. Percentage symbol is optional, values will be converted to integer (e.g. '23.5' will become 23)
-    provider: 'local.ch', # name of the provider under which throttling tracking is aggregated,
-    limit: { header: 'Rate-Limit-Limit' }, # either a hard-coded integer, or a hash pointing at the response header containing the limit value
-    remaining: { header: 'Rate-Limit-Remaining' }, # a hash pointing at the response header containing the current amount of remaining requests
-    expires: { header: 'Rate-Limit-Reset' } # a hash pointing at the response header containing the timestamp when the quota will reset
-  } 
+    track: true,
+    break: '80%',
+    provider: 'local.ch',
+    limit: { header: 'Rate-Limit-Limit' },
+    remaining: { header: 'Rate-Limit-Remaining' },
+    expires: { header: 'Rate-Limit-Reset' }
+  }
 }
 
 LHC.get('http://local.ch', options)
@@ -894,6 +895,16 @@ LHC.get('http://local.ch', options)
 LHC.get('http://local.ch', options)
 # raises LHC::Throttle::OutOfQuota: Reached predefined quota for local.ch
 ```
+**Options Description**
+* `track`: enables tracking of current limit/remaining requests of rate-limiting
+* `break`: quota in percent after which errors are raised. Percentage symbol is optional, values will be converted to integer (e.g. '23.5' will become 23)
+* `provider`: name of the provider under which throttling tracking is aggregated,
+* `limit`: either a hard-coded integer, or a hash pointing at the response header containing the limit value
+* `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
+* `expires`: a hash pointing at the response header containing the timestamp when the quota will reset
 
 #### Zipkin
 

data/lib/lhc/interceptors/throttle.rb

@@ -21,8 +21,7 @@ class LHC::Throttle < LHC::Interceptor
 
   def after_response
     options = response.request.options.dig(:throttle)
-    return unless options
-    return unless options.dig(:track)
+    return unless throttle?(options)
     self.class.track ||= {}
     self.class.track[options.dig(:provider)] = {
       limit: limit(options: options[:limit], response: response),
@@ -33,6 +32,10 @@ class LHC::Throttle < LHC::Interceptor
 
   private
 
+  def throttle?(options)
+    [options&.dig(:track), response.headers].none?(&:blank?)
+  end
+
   def break_when_quota_reached!
     options = request.options.dig(:throttle)
     track = (self.class.track || {}).dig(options[:provider])
@@ -46,36 +49,37 @@ class LHC::Throttle < LHC::Interceptor
   end
 
   def limit(options:, response:)
-    @limit ||= begin
-      if options.is_a?(Integer)
-        options
-      elsif options.is_a?(Hash) && options[:header] && response.headers.present?
-        response.headers[options[:header]]&.to_i
+    @limit ||=
+      begin
+        if options.is_a?(Integer)
+          options
+        elsif options.is_a?(Hash) && options[:header]
+          response.headers[options[:header]]&.to_i
+        end
       end
-    end
   end
 
   def remaining(options:, response:)
-    @remaining ||= begin
-      if options.is_a?(Hash) && options[:header] && response.headers.present?
-        response.headers[options[:header]]&.to_i
+    @remaining ||=
+      begin
+        if options.is_a?(Proc)
+          options.call(response)
+        elsif options.is_a?(Hash) && options[:header]
+          response.headers[options[:header]]&.to_i
+        end
       end
-    end
   end
 
   def expires(options:, response:)
-    @expires ||= begin
-      if options.is_a?(Hash) && options[:header] && response.headers.present?
-        convert_expires(response.headers[options[:header]]&.to_i)
-      else
-        convert_expires(options)
-      end
-    end
+    @expires ||= convert_expires(read_expire_option(options, response))
+  end
+
+  def read_expire_option(options, response)
+    (options.is_a?(Hash) && options[:header]) ? response.headers[options[:header]] : options
   end
 
   def convert_expires(value)
-    if value.is_a?(Integer)
-      Time.zone.at(value).to_datetime
-    end
+    return Time.parse(value) if value.match(/GMT/)
+    Time.zone.at(value.to_i).to_datetime if value.present?
   end
 end

data/lib/lhc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LHC
-  VERSION ||= '12.1.3'
+  VERSION ||= '12.2.0'
 end

data/spec/interceptors/throttle/main_spec.rb

@@ -3,66 +3,64 @@
 require 'rails_helper'
 
 describe LHC::Throttle do
+  let(:options_break) { false }
+  let(:options_expires) { { header: 'reset' } }
+  let(:options_limit) { { header: 'limit' } }
+  let(:options_remaining) { { header: 'remaining' } }
   let(:provider) { 'local.ch' }
-  let(:limit) { 10000 }
-  let(:remaining) { 1900 }
+  let(:quota_limit) { 10_000 }
+  let(:quota_remaining) { 1900 }
+  let(:quota_reset) { (Time.zone.now + 1.hour).to_i }
   let(:options) do
     {
       throttle: {
         provider: provider,
         track: true,
-        limit: limit_options,
-        remaining: { header: 'Rate-Limit-Remaining' },
-        expires: { header: 'Rate-Limit-Reset' },
-        break: break_option
+        limit: options_limit,
+        remaining: options_remaining,
+        expires: options_expires,
+        break: options_break
       }
     }
   end
-  let(:limit_options) { { header: 'Rate-Limit-Limit' } }
-  let(:break_option) { false }
-  let(:expires_in) { (Time.zone.now + 1.hour).to_i }
 
   before(:each) do
     LHC::Throttle.track = nil
     LHC.config.interceptors = [LHC::Throttle]
 
-    stub_request(:get, 'http://local.ch')
-      .to_return(
-        headers: {
-          'Rate-Limit-Limit' => limit,
-          'Rate-Limit-Remaining' => remaining,
-          'Rate-Limit-Reset' => expires_in
-        }
-      )
+    stub_request(:get, 'http://local.ch').to_return(
+      headers: { 'limit' => quota_limit, 'remaining' => quota_remaining, 'reset' => quota_reset }
+    )
   end
 
   it 'tracks the request limits based on response data' do
     LHC.get('http://local.ch', options)
-    expect(LHC::Throttle.track[provider][:limit]).to eq limit
-    expect(LHC::Throttle.track[provider][:remaining]).to eq remaining
+    expect(LHC::Throttle.track[provider][:limit]).to eq quota_limit
+    expect(LHC::Throttle.track[provider][:remaining]).to eq quota_remaining
   end
 
   context 'fix predefined integer for limit' do
-    let(:limit_options) { 1000 }
+    let(:options_limit) { 1000 }
 
     it 'tracks the limit based on initialy provided data' do
       LHC.get('http://local.ch', options)
-      expect(LHC::Throttle.track[provider][:limit]).to eq limit_options
+      expect(LHC::Throttle.track[provider][:limit]).to eq options_limit
     end
   end
 
   context 'breaks' do
-    let(:break_option) { '80%' }
+    let(:options_break) { '80%' }
 
     it 'hit the breaks if throttling quota is reached' do
       LHC.get('http://local.ch', options)
-      expect(-> {
-        LHC.get('http://local.ch', options)
-      }).to raise_error(LHC::Throttle::OutOfQuota, 'Reached predefined quota for local.ch')
+      expect { LHC.get('http://local.ch', options) }.to raise_error(
+        LHC::Throttle::OutOfQuota,
+        'Reached predefined quota for local.ch'
+      )
     end
 
     context 'still within quota' do
-      let(:break_option) { '90%' }
+      let(:options_break) { '90%' }
 
       it 'does not hit the breaks' do
         LHC.get('http://local.ch', options)
@@ -72,17 +70,14 @@ describe LHC::Throttle do
   end
 
   context 'no response headers' do
-    before do
-      stub_request(:get, 'http://local.ch')
-        .to_return(status: 200)
-    end
+    before { stub_request(:get, 'http://local.ch').to_return(status: 200) }
 
     it 'does not raise an exception' do
       LHC.get('http://local.ch', options)
     end
 
     context 'no remaining tracked, but break enabled' do
-      let(:break_option) { '90%' }
+      let(:options_break) { '90%' }
 
       it 'does not fail if a remaining was not tracked yet' do
         LHC.get('http://local.ch', options)
@@ -92,15 +87,76 @@ describe LHC::Throttle do
   end
 
   context 'expires' do
-    let(:break_option) { '80%' }
+    let(:options_break) { '80%' }
 
     it 'attempts another request if the quota expired' do
       LHC.get('http://local.ch', options)
-      expect(-> {
-        LHC.get('http://local.ch', options)
-      }).to raise_error(LHC::Throttle::OutOfQuota, 'Reached predefined quota for local.ch')
+      expect { LHC.get('http://local.ch', options) }.to raise_error(
+        LHC::Throttle::OutOfQuota,
+        'Reached predefined quota for local.ch'
+      )
       Timecop.travel(Time.zone.now + 2.hours)
       LHC.get('http://local.ch', options)
     end
   end
+
+  describe 'calculate "remaining" in proc' do
+    let(:quota_current) { 8100 }
+    let(:options_remaining) do
+      ->(response) { (response.headers['limit']).to_i - (response.headers['current']).to_i }
+    end
+
+    before(:each) do
+      stub_request(:get, 'http://local.ch').to_return(
+        headers: { 'limit' => quota_limit, 'current' => quota_current, 'reset' => quota_reset }
+      )
+      LHC.get('http://local.ch', options)
+    end
+
+    context 'breaks' do
+      let(:options_break) { '80%' }
+
+      it 'hit the breaks if throttling quota is reached' do
+        expect { LHC.get('http://local.ch', options) }.to raise_error(
+          LHC::Throttle::OutOfQuota,
+          'Reached predefined quota for local.ch'
+        )
+      end
+
+      context 'still within quota' do
+        let(:options_break) { '90%' }
+
+        it 'does not hit the breaks' do
+          LHC.get('http://local.ch', options)
+          LHC.get('http://local.ch', options)
+        end
+      end
+    end
+  end
+
+  describe 'parsing reset time given in prose' do
+    let(:quota_reset) { (Time.zone.now + 1.day).strftime('%A, %B %d, %Y 12:00:00 AM GMT').to_s }
+
+    before { LHC.get('http://local.ch', options) }
+
+    context 'breaks' do
+      let(:options_break) { '80%' }
+
+      it 'hit the breaks if throttling quota is reached' do
+        expect { LHC.get('http://local.ch', options) }.to raise_error(
+          LHC::Throttle::OutOfQuota,
+          'Reached predefined quota for local.ch'
+        )
+      end
+
+      context 'still within quota' do
+        let(:options_break) { '90%' }
+
+        it 'does not hit the breaks' do
+          LHC.get('http://local.ch', options)
+          LHC.get('http://local.ch', options)
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhc
 version: !ruby/object:Gem::Version
-  version: 12.1.3
+  version: 12.2.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhc/contributors
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-20 00:00:00.000000000 Z
+date: 2020-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -389,7 +389,7 @@ homepage: https://github.com/local-ch/lhc
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -405,8 +405,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - Ruby >= 2.0.0
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Advanced HTTP Client for Ruby, fueled with interceptors
 test_files: