lhc 12.2.0 → 13.2.0

data/lib/lhc/interceptors/monitoring.rb

@@ -13,34 +13,59 @@ class LHC::Monitoring < LHC::Interceptor
 
   def before_request
     return unless statsd
-    LHC::Monitoring.statsd.count("#{key(request)}.before_request", 1)
+    LHC::Monitoring.statsd.count("#{key}.before_request", 1)
   end
 
   def after_request
     return unless statsd
-    LHC::Monitoring.statsd.count("#{key(request)}.count", 1)
-    LHC::Monitoring.statsd.count("#{key(request)}.after_request", 1)
+    LHC::Monitoring.statsd.count("#{key}.count", 1)
+    LHC::Monitoring.statsd.count("#{key}.after_request", 1)
   end
 
   def after_response
     return unless statsd
-    key = key(response)
-    LHC::Monitoring.statsd.timing("#{key}.time", response.time) if response.success?
-    key += response.timeout? ? '.timeout' : ".#{response.code}"
-    LHC::Monitoring.statsd.count(key, 1)
+    monitor_time!
+    monitor_cache!
+    monitor_response!
   end
 
   private
 
-  def key(target)
-    request = target.is_a?(LHC::Request) ? target : target.request
+  def monitor_time!
+    LHC::Monitoring.statsd.timing("#{key}.time", response.time) if response.success?
+  end
+
+  def monitor_cache!
+    return if request.options[:cache].blank?
+    return unless monitor_caching_configuration_check
+    if response.from_cache?
+      LHC::Monitoring.statsd.count("#{key}.cache.hit", 1)
+    else
+      LHC::Monitoring.statsd.count("#{key}.cache.miss", 1)
+    end
+  end
+
+  def monitor_caching_configuration_check
+    return true if all_interceptor_classes.include?(LHC::Caching) && all_interceptor_classes.index(self.class) > all_interceptor_classes.index(LHC::Caching)
+    warn("[WARNING] Your interceptors must include LHC::Caching and LHC::Monitoring and also in that order.")
+  end
+
+  def monitor_response!
+    if response.timeout?
+      LHC::Monitoring.statsd.count("#{key}.timeout", 1)
+    else
+      LHC::Monitoring.statsd.count("#{key}.#{response.code}", 1)
+    end
+  end
+
+  def key
     key = options(request.options)[:key]
     return key if key.present?
 
     url = sanitize_url(request.url)
     key = [
       'lhc',
-      Rails.application.class.parent_name.underscore,
+      module_parent_name.underscore,
       LHC::Monitoring.env || Rails.env,
       URI.parse(url).host.gsub(/\./, '_'),
       request.method
@@ -48,6 +73,10 @@ class LHC::Monitoring < LHC::Interceptor
     key.join('.')
   end
 
+  def module_parent_name
+    (ActiveSupport.gem_version >= Gem::Version.new('6.0.0')) ? Rails.application.class.module_parent_name : Rails.application.class.parent_name
+  end
+
   def sanitize_url(url)
     return url if url.match(%r{https?://})
     "http://#{url}"

data/lib/lhc/interceptors/throttle.rb

@@ -3,7 +3,6 @@
 require 'active_support/duration'
 
 class LHC::Throttle < LHC::Interceptor
-
   class OutOfQuota < StandardError
   end
 
@@ -50,12 +49,12 @@ class LHC::Throttle < LHC::Interceptor
 
   def limit(options:, response:)
     @limit ||=
-      begin
-        if options.is_a?(Integer)
-          options
-        elsif options.is_a?(Hash) && options[:header]
-          response.headers[options[:header]]&.to_i
-        end
+      if options.is_a?(Proc)
+        options.call(response)
+      elsif options.is_a?(Integer)
+        options
+      elsif options.is_a?(Hash) && options[:header]
+        response.headers[options[:header]]&.to_i
       end
   end
 
@@ -79,7 +78,9 @@ class LHC::Throttle < LHC::Interceptor
   end
 
   def convert_expires(value)
+    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 if value.present?
+    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/request.rb

@@ -25,7 +25,11 @@ class LHC::Request
     interceptors.intercept(:before_raw_request)
     self.raw = create_request
     interceptors.intercept(:before_request)
-    run! if self_executing && !response
+    if self_executing && !response
+      run!
+    elsif response
+      on_complete(response)
+    end
   end
 
   def url
@@ -87,7 +91,7 @@ class LHC::Request
 
   def encode_url(url)
     return url if url.nil?
-    URI.escape(url)
+    Addressable::URI.escape(url)
   end
 
   def typhoeusize(options)
@@ -128,7 +132,7 @@ class LHC::Request
   end
 
   def on_complete(response)
-    self.response = LHC::Response.new(response, self)
+    self.response = response.is_a?(LHC::Response) ? response : LHC::Response.new(response, self)
     interceptors.intercept(:after_response)
     handle_error(self.response) unless self.response.success?
   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.2.0'
+  VERSION ||= '13.2.0'
 end

data/spec/error/to_s_spec.rb

@@ -45,7 +45,7 @@ describe LHC::Error do
 
     context 'some mocked response' do
       let(:request) do
-        double('request',
+        double('LHC::Request',
                method: 'GET',
                url: 'http://example.com/sessions',
                headers: { 'Bearer Token' => "aaaaaaaa-bbbb-cccc-dddd-eeee" },
@@ -55,7 +55,7 @@ describe LHC::Error do
       end
 
       let(:response) do
-        double('response',
+        double('LHC::Response',
                request: request,
                code: 500,
                options: { return_code: :internal_error, response_headers: "" },
@@ -64,6 +64,11 @@ describe LHC::Error do
 
       subject { LHC::Error.new('The error message', response) }
 
+      before do
+        allow(request).to receive(:is_a?).with(LHC::Request).and_return(true)
+        allow(response).to receive(:is_a?).with(LHC::Response).and_return(true)
+      end
+
       it 'produces correct debug output' do
         expect(subject.to_s.split("\n")).to eq(<<-MSG.strip_heredoc.split("\n"))
           GET http://example.com/sessions

data/spec/formats/multipart_spec.rb

@@ -6,7 +6,7 @@ describe LHC do
   include ActionDispatch::TestProcess
 
   context 'multipart' do
-    let(:file) { fixture_file_upload(Tempfile.new, 'image/jpeg') }
+    let(:file) { Rack::Test::UploadedFile.new(Tempfile.new) }
     let(:body) { { size: 2231 }.to_json }
     let(:location) { 'http://local.ch/uploads/image.jpg' }
 

data/spec/formats/plain_spec.rb

@@ -6,7 +6,7 @@ describe LHC do
   include ActionDispatch::TestProcess
 
   context 'plain' do
-    let(:file) { fixture_file_upload(Tempfile.new, 'image/jpeg') }
+    let(:file) { Rack::Test::UploadedFile.new(Tempfile.new) }
 
     it 'leaves plains requests unformatted' do
       stub_request(:post, 'http://local.ch/')

data/spec/interceptors/after_response_spec.rb

@@ -14,7 +14,7 @@ describe LHC do
           uri = URI.parse(response.request.url)
           path = [
             'web',
-            Rails.application.class.parent_name,
+            ((ActiveSupport.gem_version >= Gem::Version.new('6.0.0')) ? Rails.application.class.module_parent_name : Rails.application.class.parent_name).underscore,
             Rails.env,
             response.request.method,
             uri.scheme,

data/spec/interceptors/caching/main_spec.rb

@@ -47,7 +47,7 @@ describe LHC::Caching do
 
   it 'lets you configure the cache key that will be used' do
     LHC.config.endpoint(:local, 'http://local.ch', cache: { key: 'STATICKEY' })
-    expect(Rails.cache).to receive(:fetch).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY").and_call_original
+    expect(Rails.cache).to receive(:fetch).at_least(:once).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY").and_call_original
     expect(Rails.cache).to receive(:write).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY", anything, anything).and_call_original
     stub
     LHC.get(:local)
@@ -66,8 +66,8 @@ describe LHC::Caching do
     stub
     LHC.config.endpoint(:local, 'http://local.ch', cache: true)
     original_response = LHC.get(:local)
-    cached_response = LHC.get(:local)
     expect(original_response.from_cache?).to eq false
+    cached_response = LHC.get(:local)
     expect(cached_response.from_cache?).to eq true
   end
 end

data/spec/interceptors/caching/multilevel_cache_spec.rb

@@ -0,0 +1,139 @@
+# 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/monitoring/caching_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Monitoring do
+  let(:stub) do
+    stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website')
+  end
+
+  module Statsd
+    def self.count(_path, _value); end
+
+    def self.timing(_path, _value); end
+  end
+
+  before(:each) do
+    LHC::Monitoring.statsd = Statsd
+    Rails.cache.clear
+    allow(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+    allow(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+    allow(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+    allow(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.200', 1)
+  end
+
+  context 'interceptors configured correctly' do
+    before do
+      LHC.config.interceptors = [LHC::Caching, LHC::Monitoring]
+    end
+
+    context 'requesting with cache option' do
+      it 'monitors miss/hit for caching' do
+        stub
+        expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.cache.miss', 1)
+        expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.cache.hit', 1)
+        LHC.get('http://local.ch', cache: true)
+        LHC.get('http://local.ch', cache: true)
+      end
+    end
+
+    context 'request uncached' do
+      it 'requesting without cache option' do
+        stub
+        expect(Statsd).not_to receive(:count).with('lhc.dummy.test.local_ch.get.cache.miss', 1)
+        expect(Statsd).not_to receive(:count).with('lhc.dummy.test.local_ch.get.cache.hit', 1)
+        LHC.get('http://local.ch')
+        LHC.get('http://local.ch')
+      end
+    end
+  end
+
+  context 'wrong interceptor order' do
+    before(:each) do
+      LHC.config.interceptors = [LHC::Monitoring, LHC::Caching] # monitoring needs to be after Caching
+    end
+
+    it 'does monitors miss/hit for caching and warns about wrong order of interceptors' do
+      stub
+      expect(Statsd).not_to receive(:count).with('lhc.dummy.test.local_ch.get.cache.miss', 1)
+      expect(Statsd).not_to receive(:count).with('lhc.dummy.test.local_ch.get.cache.hit', 1)
+      expect(-> {
+        LHC.get('http://local.ch', cache: true)
+        LHC.get('http://local.ch', cache: true)
+      }).to output("[WARNING] Your interceptors must include LHC::Caching and LHC::Monitoring and also in that order.\n[WARNING] Your interceptors must include LHC::Caching and LHC::Monitoring and also in that order.\n").to_stderr
+    end
+  end
+end