lhc 13.0.0 → 14.0.0

data/lib/lhc/interceptors/logging.rb

@@ -7,6 +7,7 @@ class LHC::Logging < LHC::Interceptor
 
   def before_request
     return unless logger
+
     logger.info(
       [
         'Before LHC request',
@@ -22,6 +23,7 @@ class LHC::Logging < LHC::Interceptor
 
   def after_response
     return unless logger
+
     logger.info(
       [
         'After LHC response for request',

data/lib/lhc/interceptors/monitoring.rb

@@ -13,34 +13,64 @@ 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,8 +78,13 @@ 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?://})
+    return url if url.match?(%r{https?://})
+
     "http://#{url}"
   end
 

data/lib/lhc/interceptors/retry.rb

@@ -10,6 +10,7 @@ class LHC::Retry < LHC::Interceptor
   def after_response
     response.request.options[:retries] ||= 0
     return unless retry?(response.request)
+
     response.request.options[:retries] += 1
     current_retry = response.request.options[:retries]
     begin
@@ -26,6 +27,7 @@ class LHC::Retry < LHC::Interceptor
     return false if request.response.success?
     return false if request.error_ignored?
     return false if !request.options.dig(:retry) && !LHC::Retry.all
+
     request.options[:retries] < max(request)
   end
 

data/lib/lhc/interceptors/rollbar.rb

@@ -9,6 +9,7 @@ class LHC::Rollbar < LHC::Interceptor
   def after_response
     return unless Object.const_defined?('Rollbar')
     return if response.success?
+
     request = response.request
     additional_params = request.options.fetch(:rollbar, {})
     data = {

data/lib/lhc/interceptors/throttle.rb

@@ -13,14 +13,17 @@ class LHC::Throttle < LHC::Interceptor
   def before_request
     options = request.options.dig(:throttle)
     return unless options
+
     break_options = options.dig(:break)
     return unless break_options
-    break_when_quota_reached! if break_options.match('%')
+
+    break_when_quota_reached! if break_options.match?('%')
   end
 
   def after_response
     options = response.request.options.dig(:throttle)
     return unless throttle?(options)
+
     self.class.track ||= {}
     self.class.track[options.dig(:provider)] = {
       limit: limit(options: options[:limit], response: response),
@@ -40,6 +43,7 @@ class LHC::Throttle < LHC::Interceptor
     track = (self.class.track || {}).dig(options[:provider])
     return if track.blank? || track[:remaining].blank? || track[:limit].blank? || track[:expires].blank?
     return if Time.zone.now > track[:expires]
+
     # avoid floats by multiplying with 100
     remaining = track[:remaining] * 100
     limit = track[:limit]
@@ -80,7 +84,8 @@ class LHC::Throttle < LHC::Interceptor
   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/)
+    return Time.parse(value) if value.match?(/GMT/)
+
     Time.zone.at(value.to_i).to_datetime
   end
 end

data/lib/lhc/interceptors/zipkin.rb

@@ -12,6 +12,7 @@ class LHC::Zipkin < LHC::Interceptor
 
   def before_request
     return if !dependencies? || !tracing?
+
     ZipkinTracer::TraceContainer.with_trace_id(trace_id) do
       # add headers even if the current trace_id should not be sampled
       B3_HEADERS.each { |method, header| request.headers[header] = trace_id.send(method).to_s }
@@ -23,6 +24,7 @@ class LHC::Zipkin < LHC::Interceptor
   def after_response
     # only sample the current call if we're instructed to do so
     return unless dependencies? && trace_id.sampled?
+
     end_trace!
   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
@@ -63,6 +67,7 @@ class LHC::Request
 
   def optionally_encoded_url(options)
     return options[:url] unless options.fetch(:url_encoding, true)
+
     encode_url(options[:url])
   end
 
@@ -81,13 +86,15 @@ class LHC::Request
 
   def translate_body(options)
     return options if options.fetch(:body, nil).blank?
+
     options[:body] = format.to_body(options[:body])
     options
   end
 
   def encode_url(url)
     return url if url.nil?
-    URI.escape(url)
+
+    Addressable::URI.escape(url)
   end
 
   def typhoeusize(options)
@@ -96,6 +103,7 @@ class LHC::Request
     options.delete(:url)
     options.each do |key, _v|
       next if TYPHOEUS_OPTIONS.include? key
+
       method = "#{key}="
       options.delete key unless easy.respond_to?(method)
     end
@@ -107,6 +115,7 @@ class LHC::Request
   def use_configured_endpoint!
     endpoint = LHC.config.endpoints[options[:url]]
     return unless endpoint
+
     # explicit options override endpoint options
     new_options = endpoint.options.deep_merge(options)
     # set new options
@@ -128,13 +137,14 @@ 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
 
   def handle_error(response)
     return if ignore_error?
+
     throw_error(response) unless error_handler
     response.body_replacement = error_handler.call(response)
   end

data/lib/lhc/response.rb

@@ -50,6 +50,7 @@ class LHC::Response
 
   def format
     return LHC::Formats::JSON.new if request.nil?
+
     request.format
   end
 

data/lib/lhc/response/data.rb

@@ -18,7 +18,7 @@ class LHC::Response::Data
     end
   end
 
-  def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissingSuper
+  def method_missing(method, *args, &block)
     @base.send(method, *args, &block)
   end
 

data/lib/lhc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LHC
-  VERSION ||= '13.0.0'
+  VERSION ||= '14.0.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,14 +6,14 @@ 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' }
 
     it 'formats requests to be multipart/form-data' do
       stub_request(:post, 'http://local.ch/') do |request|
         raise 'Content-Type header wrong' unless request.headers['Content-Type'] == 'multipart/form-data'
-        raise 'Body wrongly formatted' unless request.body.match(/file=%23%3CActionDispatch%3A%3AHttp%3A%3AUploadedFile%3A.*%3E&type=Image/)
+        raise 'Body wrongly formatted' unless request.body.match?(/file=%23%3CActionDispatch%3A%3AHttp%3A%3AUploadedFile%3A.*%3E&type=Image/)
       end.to_return(status: 200, body: body, headers: { 'Location' => location })
       response = LHC.multipart.post(
         'http://local.ch',

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

@@ -62,7 +62,8 @@ describe LHC::Caching do
 
     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(: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

data/spec/interceptors/define_spec.rb

@@ -7,6 +7,7 @@ describe LHC do
     before(:each) do
       class SomeInterceptor < LHC::Interceptor
       end
+
       class AnotherInterceptor < LHC::Interceptor
       end
     end

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