lhc 12.3.0 → 13.4.0.pre.pro1766.1

data/lib/lhc/endpoint.rb

@@ -55,6 +55,7 @@ class LHC::Endpoint
   # Example: {+datastore}/contracts/{id} == http://local.ch/contracts/1
   def match?(url)
     return true if url == uri.pattern
+
     match_data = match_data(url)
     return false if match_data.nil?
 
@@ -75,6 +76,7 @@ class LHC::Endpoint
   def values_as_params(url)
     match_data = match_data(url)
     return if match_data.nil?
+
     Hash[match_data.variables.map(&:to_sym).zip(match_data.values)]
   end
 
@@ -103,6 +105,7 @@ class LHC::Endpoint
   # creates params according to template
   def self.values_as_params(template, url)
     raise("#{url} does not match the template: #{template}") if !match?(url, template)
+
     new(template).values_as_params(url)
   end
 

data/lib/lhc/error.rb

@@ -43,6 +43,7 @@ class LHC::Error < StandardError
 
   def self.find(response)
     return LHC::Timeout if response.timeout?
+
     status_code = response.code.to_s[0..2].to_i
     error = map[status_code]
     error ||= LHC::UnknownError
@@ -64,12 +65,15 @@ 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}"
-    debug << "Headers: #{request.headers}"
+    debug << "Options: #{request.scrubbed_options}"
+    debug << "Headers: #{request.scrubbed_headers}"
     debug << "Response Code: #{response.code} (#{response.options[:return_code]})"
     debug << "Response Options: #{response.options}"
     debug << response.body

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.rb

@@ -19,6 +19,7 @@ class LHC::Interceptors
       result = interceptor.send(name)
       if result.is_a? LHC::Response
         raise 'Response already set from another interceptor' if @response
+
         @response = interceptor.request.response = result
       end
     end

data/lib/lhc/interceptors/auth.rb

@@ -16,6 +16,7 @@ class LHC::Auth < LHC::Interceptor
   def after_response
     return unless configuration_correct?
     return unless reauthenticate?
+
     reauthenticate!
   end
 
@@ -29,7 +30,7 @@ class LHC::Auth < LHC::Interceptor
   def basic_authentication!
     auth = auth_options[:basic]
     credentials = "#{auth[:username]}:#{auth[:password]}"
-    set_authorization_header("Basic #{Base64.strict_encode64(credentials).chomp}")
+    set_basic_authorization_header(Base64.strict_encode64(credentials).chomp)
   end
 
   def bearer_authentication!
@@ -43,7 +44,13 @@ class LHC::Auth < LHC::Interceptor
     request.headers['Authorization'] = value
   end
 
+  def set_basic_authorization_header(base_64_encoded_credentials)
+    request.options[:auth][:basic] = request.options[:auth][:basic].merge(base_64_encoded_credentials: base_64_encoded_credentials)
+    set_authorization_header("Basic #{base_64_encoded_credentials}")
+  end
+
   def set_bearer_authorization_header(token)
+    request.options[:auth] = request.options[:auth].merge(bearer_token: token)
     set_authorization_header("Bearer #{token}")
   end
   # rubocop:enable Style/AccessorMethodName
@@ -75,10 +82,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
@@ -90,11 +93,13 @@ class LHC::Auth < LHC::Interceptor
 
   def refresh_client_token?
     return true if refresh_client_token_option.is_a?(Proc)
+
     warn("[WARNING] The given refresh_client_token must be a Proc for reauthentication.")
   end
 
   def retry_interceptor?
     return true if all_interceptor_classes.include?(LHC::Retry) && all_interceptor_classes.index(LHC::Retry) > all_interceptor_classes.index(self.class)
+
     warn("[WARNING] Your interceptors must include LHC::Retry after LHC::Auth.")
   end
 end

data/lib/lhc/interceptors/caching.rb

@@ -3,69 +3,109 @@
 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 +144,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/interceptors/logging.rb

@@ -7,14 +7,15 @@ class LHC::Logging < LHC::Interceptor
 
   def before_request
     return unless logger
+
     logger.info(
       [
         'Before LHC request',
         "<#{request.object_id}>",
         request.method.upcase,
         "#{request.url} at #{Time.now.iso8601}",
-        "Params=#{request.params}",
-        "Headers=#{request.headers}",
+        "Params=#{request.scrubbed_params}",
+        "Headers=#{request.scrubbed_headers}",
         request.source ? "\nCalled from #{request.source}" : nil
       ].compact.join(' ')
     )
@@ -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 = {
@@ -22,8 +23,8 @@ class LHC::Rollbar < LHC::Interceptor
       request: {
         url: request.url,
         method: request.method,
-        headers: request.headers,
-        params: request.params
+        headers: request.scrubbed_headers,
+        params: request.scrubbed_params
       }
     }.merge additional_params
     begin

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