lhc 12.1.1 → 12.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8c1cf6d1d9237c3cad231ae1fca7cadfcaaf6283eb429544945715235172b61
-  data.tar.gz: 9945fabdbdd44fbef2fd472f0e4f7a37f347393b92fda1918abda13d6b65d195
+  metadata.gz: edceeb5ec4bd94dd580a56ed8a0ed0a71a31a8bd5c0b1f08dc96c7f8614d42b3
+  data.tar.gz: 183c118e2861b420877c37dfc8f86643d8fd410f8c2abbb8d681cdd168956108
 SHA512:
-  metadata.gz: d208eca04aac94eb7f93b3053590df5c0626165cddf479ca3b1ea94907a71ee530df9de76f86f6b6492f14936a77d06f3ae296c9a854c8f1262866fdc4bad3bf
-  data.tar.gz: eaa8166c752a295b34a2b6e0c3406bee09f771a77f2f17ba39b509396fa264ce9387ea5f2dc507fa50f51c2287c0d4fe57bc9849dfdada0a7fc2572aaf5527bf
+  metadata.gz: 92bd31139ebf0bc508e0681c99c5f35b8b9c93b0a6f56fdf2fcdbfb1faa1c3fa80c2894d48ebc31ad8c4138af5df9548b3f65f87a33bb5ebbf5a873a8d696585
+  data.tar.gz: 5b4f2fee1a99c4823ad1d0231624d6bf62794bff60bc27379c180b676439b88f89242813a2b306e44dde1946985114fa1190b1e67a22befdc089f41af520f759

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)
@@ -895,6 +896,22 @@ 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`:
+  * a hard-coded integer
+  * a hash pointing at the response header containing the limit value
+  * a proc that receives the response as argument and returns 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
+  * a proc that receives the response as argument and returns the timestamp when the quota will reset
+
+
 #### Zipkin
 
 ** Zipkin 0.33 breaks our current implementation of the Zipkin interceptor **

data/lib/lhc/interceptors/throttle.rb

@@ -3,7 +3,6 @@
 require 'active_support/duration'
 
 class LHC::Throttle < LHC::Interceptor
-
   class OutOfQuota < StandardError
   end
 
@@ -21,8 +20,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 +31,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 +48,39 @@ class LHC::Throttle < LHC::Interceptor
   end
 
   def limit(options:, response:)
-    @limit ||= begin
-      if options.is_a?(Integer)
+    @limit ||=
+      if options.is_a?(Proc)
+        options.call(response)
+      elsif options.is_a?(Integer)
         options
-      elsif options.is_a?(Hash) && options[:header] && response.headers.present?
+      elsif options.is_a?(Hash) && options[:header]
         response.headers[options[:header]]&.to_i
       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 if value.blank?
+    return value.call(response) if value.is_a?(Proc)
+    return Time.parse(value) if value.match(/GMT/)
+    Time.zone.at(value.to_i).to_datetime
   end
 end

data/lib/lhc/response/data.rb

@@ -12,9 +12,9 @@ class LHC::Response::Data
     @data = data
 
     if as_json.is_a?(Hash)
-      @base = LHC::Response::Data::Item.new(response, data: data)
+      @base = LHC::Response::Data::Item.new(@response, data: data)
     elsif as_json.is_a?(Array)
-      @base = LHC::Response::Data::Collection.new(response, data: data)
+      @base = LHC::Response::Data::Collection.new(@response, data: data)
     end
   end
 

data/lib/lhc/response/data/base.rb

@@ -4,7 +4,7 @@
 # but made accssible in the ruby world
 module LHC::Response::Data::Base
   def as_json
-    @json ||= (@data || response.format.as_json(response.body))
+    @json ||= (@data || @response.format.as_json(@response.body))
   end
 
   def as_open_struct
@@ -12,11 +12,7 @@ module LHC::Response::Data::Base
       if @data
         JSON.parse(@data.to_json, object_class: OpenStruct)
       else
-        response.format.as_open_struct(response.body)
+        @response.format.as_open_struct(@response.body)
       end
   end
-
-  private
-
-  attr_reader :response
 end

data/lib/lhc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LHC
-  VERSION ||= '12.1.1'
+  VERSION ||= '12.3.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,150 @@ 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 'configuration values as Procs' do
+    describe 'calculate "limit" in proc' do
+      let(:options_limit) do
+        ->(*) { 10_000 }
+      end
+
+      before(:each) do
+        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)
+          end
+        end
+      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)
+          end
+        end
+      end
+    end
+
+    describe 'calculate "reset" in proc' do
+      let(:options_expires) { ->(*) { Time.zone.now + 1.second } }
+
+      before(:each) do
+        stub_request(:get, 'http://local.ch').to_return(
+          headers: { 'limit' => quota_limit, 'remaining' => quota_remaining }
+        )
+        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)
+          end
+        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)
+        end
+      end
+    end
+  end
+
+  context 'when value is empty' do
+    let(:quota_reset) { nil }
+
+    before do
+      stub_request(:get, 'http://local.ch').to_return(
+        headers: { 'limit' => quota_limit, 'remaining' => quota_remaining }
+      )
+      LHC.get('http://local.ch', options)
+    end
+
+    it 'still runs' do
+      LHC.get('http://local.ch', options)
+    end
+  end
 end

data/spec/response/data_spec.rb

@@ -58,4 +58,28 @@ describe LHC::Response do
       end
     end
   end
+
+  context 'response data if responding error data contains a response' do
+    before do
+      stub_request(:get, "http://listings/")
+        .to_return(status: 404, body: {
+          meta: {
+            errors: [
+              { code: 2000, msg: 'I like to hide error messages (this is meta).' }
+            ]
+          },
+          response: 'why not?'
+        }.to_json)
+    end
+
+    it 'does not throw a stack level to deep issue when accessing data in a rescue context' do
+      begin
+        LHC.get('http://listings')
+      rescue LHC::Error => error
+        expect(
+          error.response.request.response.data.meta.errors.detect { |item| item.code == 2000 }.msg
+        ).to eq 'I like to hide error messages (this is meta).'
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhc
 version: !ruby/object:Gem::Version
-  version: 12.1.1
+  version: 12.3.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhc/contributors
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2020-08-26 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: