lhc 12.1.2 → 13.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c7bdb4bd4a91af430b69b11f503806f9fdc55cae4154dad422ac425c91b5c14
-  data.tar.gz: 625949e2cdbf59636411283b7ce9e6db35273ffb54612c9e3aa5a52d49c0d928
+  metadata.gz: 4795a0c91e246b2139465a030a8f98e0ba2deb07a48664632524b00ad2f02403
+  data.tar.gz: 821adbc1157dbd699ad9a40f556a3ea7e94088aa8a320de6685b475a11596351
 SHA512:
-  metadata.gz: 0a88ba1534ec293a977484aea27613fc99c7329368b210924b74325904f28a77ac8d6b7e504b3228ee8a39b3f453b8efca1d4fdf354872b0d35177625803b68d
-  data.tar.gz: 2af73f13c98546e6cca30e35ca3bba4c7b2980790fe1ac35de3a339d63883f9d55e5d624932bdafac315dda1c58fa9e809739a5364f289ec73556c213c78f731
+  metadata.gz: 9f8a0035d222617beeafce69dfadb17138d5eb31ea6fed900b6aca4582bbafb332b564e3557f42a1dbbcb287f2e6c55fe100c5e74f92e916f0686172b06f9f07
+  data.tar.gz: '058260bffcbacc6edac359e9852a519c3b49fe902bf48a3c7635226c43c563f73c1308ca11fbf6096213ade013ffc40e22c22e4901e455628b19e0d87cc74c7d'

data/Gemfile.activesupport5

@@ -1,4 +1,4 @@
 source 'https://rubygems.org/'
 
 gemspec
-gem 'activesupport', '~> 5.0.0'
+gem 'activesupport', '~> 5.2'

data/Gemfile.activesupport6

@@ -1,4 +1,4 @@
 source 'https://rubygems.org/'
 
 gemspec
-gem 'activesupport', '~> 6.0.0'
+gem 'activesupport', '~> 6.0'

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
 ```
 
@@ -600,7 +601,6 @@ You can configure your own cache (default Rails.cache) and logger (default Rails
 
 ```ruby
   LHC::Caching.cache = ActiveSupport::Cache::MemoryStore.new
-  LHC::Caching.logger = Logger.new(STDOUT)
 ```
 
 Caching is not enabled by default, although you added it to your basic set of interceptors.
@@ -631,6 +631,18 @@ Responses served from cache are marked as served from cache:
   response.from_cache? # true
 ```
 
+You can also use a central http cache to be used by the `LHC::Caching` interceptor.
+
+If you configure a local and a central cache, LHC will perform multi-level-caching.
+LHC will try to retrieve cached information first from the central, in case of a miss from the local cache, while writing back into both.
+
+```ruby
+  LHC::Caching.central = {
+    read: 'redis://$PASSWORD@central-http-cache-replica.namespace:6379/0',
+    write: 'redis://$PASSWORD@central-http-cache-master.namespace:6379/0'
+  }
+```
+
 ##### Options
 
 ```ruby
@@ -643,7 +655,7 @@ Responses served from cache are marked as served from cache:
 
 `race_condition_ttl` - very useful in situations where a cache entry is used very frequently and is under heavy load.
 If a cache expires and due to heavy load several different processes will try to read data natively and then they all will try to write to cache.
-To avoid that case the first process to find an expired cache entry will bump the cache expiration time by the value set in `cache_race_condition_ttl`.
+To avoid that case the first process to find an expired cache entry will bump the cache expiration time by the value set in `race_condition_ttl`.
 
 `use` - Set an explicit cache to be used for this request. If this option is missing `LHC::Caching.cache` is used.
 
@@ -729,7 +741,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 +792,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 +814,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 +889,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 +907,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/cider-ci.yml

@@ -1,6 +1,5 @@
 jobs:
   include:
-    - cider-ci/jobs/rspec-activesupport-4.yml
     - cider-ci/jobs/rspec-activesupport-5.yml
     - cider-ci/jobs/rspec-activesupport-6.yml
     - cider-ci/jobs/rubocop.yml

data/lhc.gemspec

@@ -21,14 +21,15 @@ Gem::Specification.new do |s|
 
   s.requirements << 'Ruby >= 2.0.0'
 
-  s.add_dependency 'activesupport', '>= 4.2'
+  s.add_dependency 'activesupport', '>= 5.2'
   s.add_dependency 'addressable'
   s.add_dependency 'typhoeus', '>= 0.11'
 
   s.add_development_dependency 'geminabox'
   s.add_development_dependency 'prometheus-client', '~> 0.7.1'
   s.add_development_dependency 'pry'
-  s.add_development_dependency 'rails', '>= 4.2'
+  s.add_development_dependency 'rails', '>= 5.2'
+  s.add_development_dependency 'redis'
   s.add_development_dependency 'rspec-rails', '>= 3.0.0'
   s.add_development_dependency 'rubocop', '~> 0.57.1'
   s.add_development_dependency 'rubocop-rspec', '~> 1.26.0'

data/lib/lhc/interceptors/caching.rb

@@ -3,69 +3,98 @@
 class LHC::Caching < LHC::Interceptor
   include ActiveSupport::Configurable
 
-  config_accessor :cache, :logger
+  config_accessor :cache, :central
 
+  # to control cache invalidation across all applications in case of
+  # breaking changes within this inteceptor
+  # that do not lead to cache invalidation otherwise
   CACHE_VERSION = '1'
 
   # Options forwarded to the cache
   FORWARDED_OPTIONS = [:expires_in, :race_condition_ttl]
 
+  class MultilevelCache
+
+    def initialize(central: nil, local: nil)
+      @central = central
+      @local = local
+    end
+
+    def fetch(key)
+      central_response = @central[:read].fetch(key) if @central && @central[:read].present?
+      if central_response
+        puts %Q{[LHC] served from central cache: "#{key}"}
+        return central_response
+      end
+      local_response = @local.fetch(key) if @local
+      if local_response
+        puts %Q{[LHC] served from local cache: "#{key}"}
+        return local_response
+      end
+    end
+
+    def write(key, content, options)
+      @central[:write].write(key, content, options) if @central && @central[:write].present?
+      @local.write(key, content, options) if @local.present?
+    end
+  end
+
   def before_request
     return unless cache?(request)
-    deprecation_warning(request.options)
-    options = options(request.options)
     key = key(request, options[:key])
-    response_data = cache_for(options).fetch(key)
+    response_data = multilevel_cache.fetch(key)
     return unless response_data
-    logger&.info "Served from cache: #{key}"
     from_cache(request, response_data)
   end
 
   def after_response
     return unless response.success?
-    request = response.request
     return unless cache?(request)
-    options = options(request.options)
-    cache_for(options).write(
+    multilevel_cache.write(
       key(request, options[:key]),
       to_cache(response),
-      cache_options(options)
+      cache_options
     )
   end
 
   private
 
-  # return the cache for the given options
-  def cache_for(options)
+  # performs read/write (fetch/write) on all configured cache levels (e.g. local & central)
+  def multilevel_cache
+    MultilevelCache.new(
+      central: central_cache,
+      local: local_cache
+    )
+  end
+
+  # returns the local cache either configured for entire LHC
+  # or configured locally for that particular request
+  def local_cache
     options.fetch(:use, cache)
   end
 
+  def central_cache
+    return nil if central.blank? || (central[:read].blank? && central[:write].blank?)
+    {}.tap do |options|
+      options[:read] = ActiveSupport::Cache::RedisCacheStore.new(url: central[:read]) if central[:read].present?
+      options[:write] = ActiveSupport::Cache::RedisCacheStore.new(url: central[:write]) if central[:write].present?
+    end
+  end
+
   # do we even need to bother with this interceptor?
   # based on the options, this method will
   # return false if this interceptor cannot work
   def cache?(request)
     return false unless request.options[:cache]
-    options = options(request.options)
-    cache_for(options) &&
+    (local_cache || central_cache) &&
       cached_method?(request.method, options[:methods])
   end
 
-  # returns the request_options
-  # will map deprecated options to the new format
-  def options(request_options)
-    options = (request_options[:cache] == true) ? {} : request_options[:cache].dup
-    map_deprecated_options!(request_options, options)
+  def options
+    options = (request.options[:cache] == true) ? {} : request.options[:cache].dup
     options
   end
 
-  # maps `cache_key` -> `key`, `cache_expires_in` -> `expires_in` and so on
-  def map_deprecated_options!(request_options, options)
-    deprecated_keys(request_options).each do |deprecated_key|
-      new_key = deprecated_key.to_s.gsub(/^cache_/, '').to_sym
-      options[new_key] = request_options[deprecated_key]
-    end
-  end
-
   # converts json we read from the cache to an LHC::Response object
   def from_cache(request, data)
     raw = Typhoeus::Response.new(data)
@@ -104,24 +133,10 @@ class LHC::Caching < LHC::Interceptor
 
   # extracts the options that should be forwarded to
   # the cache
-  def cache_options(input = {})
-    input.each_with_object({}) do |(key, value), result|
+  def cache_options
+    options.each_with_object({}) do |(key, value), result|
       result[key] = value if key.in? FORWARDED_OPTIONS
       result
     end
   end
-
-  # grabs the deprecated keys from the request options
-  def deprecated_keys(request_options)
-    request_options.keys.select { |k| k =~ /^cache_.*/ }.sort
-  end
-
-  # emits a deprecation warning if necessary
-  def deprecation_warning(request_options)
-    unless deprecated_keys(request_options).empty?
-      ActiveSupport::Deprecation.warn(
-        "Cache options have changed! #{deprecated_keys(request_options).join(', ')} are deprecated and will be removed in future versions."
-      )
-    end
-  end
 end

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/railtie.rb

@@ -4,7 +4,6 @@ module LHC
   class Railtie < Rails::Railtie
     initializer "lhc.configure_rails_initialization" do
       LHC::Caching.cache ||= Rails.cache
-      LHC::Caching.logger ||= Rails.logger
     end
   end
 end

data/lib/lhc/rspec.rb

@@ -3,9 +3,8 @@
 require 'lhc'
 
 RSpec.configure do |config|
-  LHC::Caching.cache = ActiveSupport::Cache::MemoryStore.new
-
   config.before(:each) do
+    LHC::Caching.cache = ActiveSupport::Cache::MemoryStore.new
     LHC::Caching.cache.clear
     LHC::Throttle.track = nil
   end

data/lib/lhc/version.rb

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

data/spec/interceptors/caching/multilevel_cache_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Caching do
+  let(:redis_url) { 'redis://localhost:6379/0' }
+  let(:redis_cache) do
+    spy('ActiveSupport::Cache::RedisCacheStore')
+  end
+
+  before do
+    Rails.cache.clear
+    LHC.config.interceptors = [LHC::Caching]
+    ActiveSupport::Cache::RedisCacheStore.new(url: redis_url).clear
+    allow(ActiveSupport::Cache::RedisCacheStore).to receive(:new).and_return(redis_cache)
+    allow(redis_cache).to receive(:present?).and_return(true)
+  end
+
+  let!(:request_stub) do
+    stub_request(:get, "http://local.ch/")
+      .to_return(body: '<h1>Hi there</h1>')
+  end
+
+  def request
+    LHC.get('http://local.ch', cache: true)
+  end
+
+  def response_has_been_cached_and_served_from_cache!
+    original_response = request
+    cached_response = request
+
+    expect(original_response.body).to eq cached_response.body
+    expect(original_response.code).to eq cached_response.code
+    expect(original_response.headers).to eq cached_response.headers
+    expect(original_response.options[:return_code]).to eq cached_response.options[:return_code]
+    expect(original_response.mock).to eq cached_response.mock
+
+    assert_requested request_stub, times: 1
+  end
+
+  context 'only local cache has been configured' do
+    before do
+      LHC::Caching.cache = Rails.cache
+    end
+
+    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(%Q{[LHC] served from local cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+    end
+  end
+
+  context 'local and central cache have been configured' do
+    before do
+      LHC::Caching.cache = Rails.cache
+      LHC::Caching.central = {
+        read: redis_url,
+        write: redis_url
+      }
+    end
+
+    context 'found in central cache' do
+      it 'serves it from central cache if found there' 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(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(%Q{[LHC] served from central cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+      end
+    end
+
+    context 'not found in central cache' do
+      it 'serves it from local cache if found there' do
+        expect(redis_cache).to receive(:fetch).and_return(nil, nil)
+        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(%Q{[LHC] served from local cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+      end
+    end
+  end
+
+  context 'only central read configured' do
+    before do
+      LHC::Caching.cache = Rails.cache
+      LHC::Caching.central = {
+        read: redis_url
+      }
+    end
+
+    it 'still serves responses from cache, but does not write them back' 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).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(%Q{[LHC] served from central cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+    end
+  end
+
+  context 'only central write configured' do
+    before do
+      LHC::Caching.cache = Rails.cache
+      LHC::Caching.central = {
+        write: redis_url
+      }
+    end
+
+    it 'still writes responses to cache, but does not retrieve them from there' do
+      expect(redis_cache).not_to receive(:fetch)
+      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(%Q{[LHC] served from local cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+    end
+  end
+
+  context 'central cache configured only' do
+    before do
+      LHC::Caching.cache = nil
+      LHC::Caching.central = {
+        read: redis_url,
+        write: redis_url
+      }
+    end
+
+    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(%Q{[LHC] served from central cache: "LHC_CACHE(v1): GET http://local.ch"\n}).to_stdout
+    end
+  end
+end

data/spec/interceptors/caching/options_spec.rb

@@ -20,17 +20,6 @@ describe LHC::Caching do
     default_cache.clear
   end
 
-  it 'maps deprecated cache options' do
-    expected_options = { expires_in: 5.minutes, race_condition_ttl: 15.seconds }
-    expected_key = "LHC_CACHE(v1): key"
-    expect(default_cache).to receive(:write).with(expected_key, anything, expected_options)
-    expect(lambda {
-      LHC.get('http://local.ch', cache: true, cache_expires_in: 5.minutes, cache_key: 'key', cache_race_condition_ttl: 15.seconds)
-    }).to output(
-      /Cache options have changed! cache_expires_in, cache_key, cache_race_condition_ttl are deprecated and will be removed in future versions./
-    ).to_stderr
-  end
-
   it 'does cache' do
     expect(default_cache).to receive(:fetch)
     expect(default_cache).to receive(:write)

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/spec_helper.rb

@@ -3,6 +3,7 @@
 require 'pry'
 require 'webmock/rspec'
 require 'lhc'
+require 'lhc/rspec'
 require 'timecop'
 
 Dir[File.join(__dir__, "support/**/*.rb")].each { |f| require f }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhc
 version: !ruby/object:Gem::Version
-  version: 12.1.2
+  version: 13.0.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhc/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-20 00:00:00.000000000 Z
+date: 2020-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
@@ -100,14 +100,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -193,7 +207,6 @@ files:
 - ".rubocop.yml"
 - ".ruby-version"
 - Gemfile
-- Gemfile.activesupport4
 - Gemfile.activesupport5
 - Gemfile.activesupport6
 - LICENSE
@@ -203,7 +216,6 @@ files:
 - cider-ci/bin/bundle
 - cider-ci/bin/ruby_install
 - cider-ci/bin/ruby_version
-- cider-ci/jobs/rspec-activesupport-4.yml
 - cider-ci/jobs/rspec-activesupport-5.yml
 - cider-ci/jobs/rspec-activesupport-6.yml
 - cider-ci/jobs/rubocop.yml
@@ -335,6 +347,7 @@ files:
 - spec/interceptors/caching/hydra_spec.rb
 - spec/interceptors/caching/main_spec.rb
 - spec/interceptors/caching/methods_spec.rb
+- spec/interceptors/caching/multilevel_cache_spec.rb
 - spec/interceptors/caching/options_spec.rb
 - spec/interceptors/caching/parameters_spec.rb
 - spec/interceptors/caching/response_status_spec.rb
@@ -488,6 +501,7 @@ test_files:
 - spec/interceptors/caching/hydra_spec.rb
 - spec/interceptors/caching/main_spec.rb
 - spec/interceptors/caching/methods_spec.rb
+- spec/interceptors/caching/multilevel_cache_spec.rb
 - spec/interceptors/caching/options_spec.rb
 - spec/interceptors/caching/parameters_spec.rb
 - spec/interceptors/caching/response_status_spec.rb

data/Gemfile.activesupport4

@@ -1,4 +0,0 @@
-source 'https://rubygems.org/'
-
-gemspec
-gem 'activesupport', '~> 4.2.11'

data/cider-ci/jobs/rspec-activesupport-4.yml

@@ -1,28 +0,0 @@
-rspec-active-support-v4:
-  name: 'rspec with ActiveSupport v4'
-
-  run_when:
-    'some HEAD has been updated':
-      type: branch
-      include_match: ^.*$
-
-  context:
-
-    script_defaults:
-      template_environment_variables: true
-
-    task_defaults:
-      environment_variables:
-        ACTIVESUPPORT: '4'
-        BUNDLER: '_1.17.3_'
-
-      max_trials: 2
-      dispatch_storm_delay_duration: 1 Seconds
-      include:
-        - cider-ci/task_components/ruby.yml
-        - cider-ci/task_components/bundle.yml
-        - cider-ci/task_components/rspec.yml
-
-    tasks:
-      all-rspec:
-        name: All rspec tests, using ActiveSupport v4