lhc 12.2.0 → 13.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a536d04e90db04fdeca6edd06c3e88782106a660d410a1b908b94147a3e9154
-  data.tar.gz: d0d89904a00069fdd8f3ef297f296e5da9d1383a4b4239aeebf00b6869be082a
+  metadata.gz: b7e042d800751c9fceb6d4f3e01513a1a849a3e00fb8bf7e0987bf1df73b5a45
+  data.tar.gz: 6fa4a578f6003a9ef46ca27ed81766ef2c4dbd07ad231d4201624274b7255153
 SHA512:
-  metadata.gz: 858291c8b53ce6447df1cc23fabd7c74ca4307ff7590eaebb76f4d538b769f81d9d89055bf79bf564814cf55c6832fccee42918100433061331252c6aafd8042
-  data.tar.gz: 49356178736094b85a4d9c1eab8dcf390024df5b580cb696e7f02683cbc1f1cf4a3e5bcfc6e03f5e8b9330fed1e02b94dd8bbbe17ec3c58e14b91b7352df9030
+  metadata.gz: 80b0d65063c77912df0cf07bc8f25acbb083af34186248689131283cb07e90f9bc2677973b96170d0eeba788b7bcde19ce0f3efddefe349501e33b3825f39b53
+  data.tar.gz: 2f0b273133f8fe5311eeaa4c46d11170430c58099c8599f855e303659f299fbab0ababbc5091999a0fc7c433a7eccdd80fbc343e5cac267aeae3aab7595bbdcb

data/.github/workflows/rubocop.yml

@@ -0,0 +1,27 @@
+name: Rubocop
+
+on: push
+
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-ruby@v1
+        with:
+          ruby-version: 2.7.2
+      - name: Cache Ruby Gems
+        uses: actions/cache@v2
+        with:
+          path: /.tmp/vendor/bundle
+          key: ${{ runner.os }}-gems-latest-${{ hashFiles('**/Gemfile.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-gems-latest-
+      - name: Bundle Install
+        run: |
+          bundle config path /.tmp/vendor/bundle
+          bundle install --jobs 4 --retry 3
+      - name: Run Rubocop
+        run: |
+          bundle exec rubocop

data/.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: Test
+
+on: push
+
+jobs:
+  rspec:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-ruby@v1
+        with:
+          ruby-version: 2.7.2
+      - name: Cache Ruby Gems
+        uses: actions/cache@v2
+        with:
+          path: /.tmp/vendor/bundle
+          key: ${{ runner.os }}-gems-latest-${{ hashFiles('**/Gemfile.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-gems-latest-
+      - name: Bundle Install
+        run: |
+          bundle config path /.tmp/vendor/bundle
+          bundle install --jobs 4 --retry 3
+      - name: Run Tests
+        run: |
+          bundle exec rspec

data/.rubocop.yml

@@ -5,6 +5,9 @@ inherit_from:
 
 AllCops:
   TargetRubyVersion: 2.3
+  Exclude:
+    - vendor/**
+    - vendor/**/.*
 
 Lint/IneffectiveAccessModifier:
   Enabled: false

data/.ruby-version

@@ -1 +1 @@
-ruby-2.6.5
+ruby-2.7.2

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

@@ -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`.
@@ -601,7 +606,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 +636,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 +660,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.
 
@@ -733,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
@@ -748,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
@@ -756,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:
@@ -895,16 +950,22 @@ LHC.get('http://local.ch', options)
 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`: either a hard-coded integer, or a hash pointing at the response header containing the limit value
+* `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 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
 

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -17,9 +19,7 @@ end
 begin
   require 'rspec/core/rake_task'
   RSpec::Core::RakeTask.new(:spec)
-  task :default => :spec
-rescue LoadError
-  # no rspec available
+  task default: :spec
 end
 
 Bundler::GemHelper.install_tasks

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/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

@@ -3,69 +3,104 @@
 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)
-    return unless response_data
-    logger&.info "Served from cache: #{key}"
+    return if response_data.blank?
     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(
+    return if response_data.present?
+    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)
+  # 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(
+      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 +139,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