lhc 12.3.0 → 13.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: edceeb5ec4bd94dd580a56ed8a0ed0a71a31a8bd5c0b1f08dc96c7f8614d42b3
-  data.tar.gz: 183c118e2861b420877c37dfc8f86643d8fd410f8c2abbb8d681cdd168956108
+  metadata.gz: 4795a0c91e246b2139465a030a8f98e0ba2deb07a48664632524b00ad2f02403
+  data.tar.gz: 821adbc1157dbd699ad9a40f556a3ea7e94088aa8a320de6685b475a11596351
 SHA512:
-  metadata.gz: 92bd31139ebf0bc508e0681c99c5f35b8b9c93b0a6f56fdf2fcdbfb1faa1c3fa80c2894d48ebc31ad8c4138af5df9548b3f65f87a33bb5ebbf5a873a8d696585
-  data.tar.gz: 5b4f2fee1a99c4823ad1d0231624d6bf62794bff60bc27379c180b676439b88f89242813a2b306e44dde1946985114fa1190b1e67a22befdc089f41af520f759
+  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

@@ -601,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.
@@ -632,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
@@ -644,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.
 

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/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.3.0'
+  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/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.3.0
+  version: 13.0.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhc/contributors
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-08-26 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
@@ -389,7 +402,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 +418,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - Ruby >= 2.0.0
-rubygems_version: 3.0.3
-signing_key:
+rubygems_version: 3.0.6
+signing_key: 
 specification_version: 4
 summary: Advanced HTTP Client for Ruby, fueled with interceptors
 test_files:
@@ -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