lhc 13.0.0 → 13.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4795a0c91e246b2139465a030a8f98e0ba2deb07a48664632524b00ad2f02403
-  data.tar.gz: 821adbc1157dbd699ad9a40f556a3ea7e94088aa8a320de6685b475a11596351
+  metadata.gz: 98300a9c64d910094f32a96b4428c71aa4d1d8927e1dc9e4b939c1119e28333c
+  data.tar.gz: 7cb93bf8911d06c5fbd015b36b2ccc62c3ff211a1e70a2aa10dfd8fe447be878
 SHA512:
-  metadata.gz: 9f8a0035d222617beeafce69dfadb17138d5eb31ea6fed900b6aca4582bbafb332b564e3557f42a1dbbcb287f2e6c55fe100c5e74f92e916f0686172b06f9f07
-  data.tar.gz: '058260bffcbacc6edac359e9852a519c3b49fe902bf48a3c7635226c43c563f73c1308ca11fbf6096213ade013ffc40e22c22e4901e455628b19e0d87cc74c7d'
+  metadata.gz: 24d10469629a7bb4942bd2a77fabc74910a98179e5998fef6e502fa88e25d583274becd33897f4f509ed97e3e9a3ed2d246145ac9a0908ae3b367d4d0f00ca9d
+  data.tar.gz: c22f9044dbc3a2052c3487eb014f04e86791017da1b3d438d6c9e48e63d30bf4bf5e19663854f3b1a2ba675ad240da84e3c528a0ca25037759a3576109275657

data/README.md

@@ -73,6 +73,10 @@ use it like:
            * [Installation](#installation-1)
            * [Environment](#environment)
            * [What it tracks](#what-it-tracks)
+              * [Before and after request tracking](#before-and-after-request-tracking)
+              * [Response tracking](#response-tracking)
+              * [Timeout tracking](#timeout-tracking)
+              * [Caching tracking](#caching-tracking)
            * [Configure](#configure-1)
         * [Prometheus Interceptor](#prometheus-interceptor)
         * [Retry Interceptor](#retry-interceptor)
@@ -95,6 +99,7 @@ use it like:
 
 
 
+
 ## Basic methods
 
 Available are `get`, `post`, `put` & `delete`.
@@ -744,11 +749,15 @@ It tracks request attempts with `before_request` and `after_request` (counts).
 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:
 
+###### Before and after request tracking
+
 ```ruby
   "lhc.<app_name>.<env>.<host>.<http_method>.before_request", 1
   "lhc.<app_name>.<env>.<host>.<http_method>.after_request", 1
 ```
 
+###### Response tracking
+
 In case of a successful response it reports the response code with a count and the response time with a gauge value.
 
 ```ruby
@@ -759,6 +768,17 @@ In case of a successful response it reports the response code with a count and t
   "lhc.<app_name>.<env>.<host>.<http_method>.time", 43
 ```
 
+In case of a unsuccessful response it reports the response code with a count but no time:
+
+```ruby
+  LHC.get('http://local.ch')
+
+  "lhc.<app_name>.<env>.<host>.<http_method>.count", 1
+  "lhc.<app_name>.<env>.<host>.<http_method>.500", 1
+```
+
+###### Timeout tracking
+
 Timeouts are also reported:
 
 ```ruby
@@ -767,6 +787,30 @@ Timeouts are also reported:
 
 All the dots in the host are getting replaced with underscore, because dot is the default separator in graphite.
 
+###### Caching tracking
+
+When you want to track caching stats please make sure you have enabled the `LHC::Caching` and the `LHC::Monitoring` interceptor.
+
+Make sure that the `LHC::Caching` is listed before `LHC::Monitoring` interceptor when configuring interceptors:
+
+```ruby
+LHC.configure do |c|
+  c.interceptors = [LHC::Caching, LHC::Monitoring]
+end
+```
+
+If a response was served from cache it tracks:
+
+```ruby
+  "lhc.<app_name>.<env>.<host>.<http_method>.cache.hit", 1
+```
+
+If a response was not served from cache it tracks:
+
+```ruby
+  "lhc.<app_name>.<env>.<host>.<http_method>.cache.miss", 1
+```
+
 ##### Configure
 
 It is possible to set the key for Monitoring Interceptor on per request basis:

data/lib/lhc/error.rb

@@ -64,8 +64,10 @@ class LHC::Error < StandardError
   end
 
   def to_s
-    return response if response.is_a?(String)
+    return response.to_s unless response.is_a?(LHC::Response)
     request = response.request
+    return unless request.is_a?(LHC::Request)
+
     debug = []
     debug << [request.method, request.url].map { |str| self.class.fix_invalid_encoding(str) }.join(' ')
     debug << "Options: #{request.options}"

data/lib/lhc/interceptor.rb

@@ -29,4 +29,8 @@ class LHC::Interceptor
   def self.dup
     self
   end
+
+  def all_interceptor_classes
+    @all_interceptors ||= LHC::Interceptors.new(request).all.map(&:class)
+  end
 end

data/lib/lhc/interceptors/auth.rb

@@ -75,10 +75,6 @@ class LHC::Auth < LHC::Interceptor
     @refresh_client_token_option ||= auth_options[:refresh_client_token] || refresh_client_token
   end
 
-  def all_interceptor_classes
-    @all_interceptors ||= LHC::Interceptors.new(request).all.map(&:class)
-  end
-
   def auth_options
     request.options[:auth] || {}
   end

data/lib/lhc/interceptors/caching.rb

@@ -41,15 +41,14 @@ class LHC::Caching < LHC::Interceptor
 
   def before_request
     return unless cache?(request)
-    key = key(request, options[:key])
-    response_data = multilevel_cache.fetch(key)
-    return unless response_data
+    return if response_data.blank?
     from_cache(request, response_data)
   end
 
   def after_response
     return unless response.success?
     return unless cache?(request)
+    return if response_data.present?
     multilevel_cache.write(
       key(request, options[:key]),
       to_cache(response),
@@ -59,6 +58,13 @@ class LHC::Caching < LHC::Interceptor
 
   private
 
+  # from cache
+  def response_data
+    # stop calling multi-level cache if it already returned nil for this interceptor instance
+    return @response_data if defined? @response_data
+    @response_data ||= multilevel_cache.fetch(key(request, options[:key]))
+  end
+
   # performs read/write (fetch/write) on all configured cache levels (e.g. local & central)
   def multilevel_cache
     MultilevelCache.new(

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/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
@@ -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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LHC
-  VERSION ||= '13.0.0'
+  VERSION ||= '13.1.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/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/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

data/spec/interceptors/response_competition_spec.rb

@@ -12,7 +12,7 @@ describe LHC do
 
         def before_request
           if @@cached
-            return LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from local cache'), nil)
+            return LHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from local cache'), nil)
           end
         end
       end
@@ -22,7 +22,7 @@ describe LHC do
 
         def before_request
           if request.response.nil?
-            return LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from remote cache'), nil)
+            return LHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from remote cache'), nil)
           end
         end
       end

data/spec/interceptors/return_response_spec.rb

@@ -8,7 +8,7 @@ describe LHC do
       class CacheInterceptor < LHC::Interceptor
 
         def before_request
-          LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from cache'), nil)
+          LHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok, response_body: 'Im served from cache'), nil)
         end
       end
       LHC.configure { |c| c.interceptors = [CacheInterceptor] }
@@ -23,7 +23,7 @@ describe LHC do
       before(:each) do
         class AnotherInterceptor < LHC::Interceptor
           def before_request
-            LHC::Response.new(Typhoeus::Response.new({}), nil)
+            LHC::Response.new(Typhoeus::Response.new(response_code: 200, return_code: :ok), nil)
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhc
 version: !ruby/object:Gem::Version
-  version: 13.0.0
+  version: 13.1.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhc/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-28 00:00:00.000000000 Z
+date: 2020-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -357,6 +357,7 @@ files:
 - spec/interceptors/define_spec.rb
 - spec/interceptors/dup_spec.rb
 - spec/interceptors/logging/main_spec.rb
+- spec/interceptors/monitoring/caching_spec.rb
 - spec/interceptors/monitoring/main_spec.rb
 - spec/interceptors/prometheus_spec.rb
 - spec/interceptors/response_competition_spec.rb
@@ -511,6 +512,7 @@ test_files:
 - spec/interceptors/define_spec.rb
 - spec/interceptors/dup_spec.rb
 - spec/interceptors/logging/main_spec.rb
+- spec/interceptors/monitoring/caching_spec.rb
 - spec/interceptors/monitoring/main_spec.rb
 - spec/interceptors/prometheus_spec.rb
 - spec/interceptors/response_competition_spec.rb