lhc 13.0.0 → 15.0.0

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,17 +65,19 @@ 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
     debug << _message
-
     debug.map { |str| self.class.fix_invalid_encoding(str) }.join("\n")
   end
 end

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

@@ -41,15 +41,16 @@ 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 +60,14 @@ 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(
@@ -75,6 +84,7 @@ class LHC::Caching < LHC::Interceptor
 
   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?
@@ -86,6 +96,7 @@ class LHC::Caching < LHC::Interceptor
   # return false if this interceptor cannot work
   def cache?(request)
     return false unless request.options[:cache]
+
     (local_cache || central_cache) &&
       cached_method?(request.method, options[:methods])
   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

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

@@ -12,7 +12,13 @@ class LHC::Request
 
   TYPHOEUS_OPTIONS ||= [:params, :method, :body, :headers, :follow_location, :params_encoding]
 
-  attr_accessor :response, :options, :raw, :format, :error_handler, :errors_ignored, :source
+  attr_accessor :response,
+                :options,
+                :raw,
+                :format,
+                :error_handler,
+                :errors_ignored,
+                :source
 
   def initialize(options, self_executing = true)
     self.errors_ignored = (options.fetch(:ignore, []) || []).to_a.compact
@@ -25,7 +31,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
@@ -52,6 +62,23 @@ class LHC::Request
     raw.run
   end
 
+  def scrubbed_params
+    LHC::ParamsScrubber.new(params.deep_dup).scrubbed
+  end
+
+  def scrubbed_headers
+    LHC::HeadersScrubber.new(headers.deep_dup, options[:auth]).scrubbed
+  end
+
+  def scrubbed_options
+    scrubbed_options = options.deep_dup
+    scrubbed_options[:params] = LHC::ParamsScrubber.new(scrubbed_options[:params]).scrubbed
+    scrubbed_options[:headers] = LHC::HeadersScrubber.new(scrubbed_options[:headers], scrubbed_options[:auth]).scrubbed
+    scrubbed_options[:auth] = LHC::AuthScrubber.new(scrubbed_options[:auth]).scrubbed
+    scrubbed_options[:body] = LHC::BodyScrubber.new(scrubbed_options[:body]).scrubbed
+    scrubbed_options
+  end
+
   private
 
   attr_accessor :interceptors
@@ -63,6 +90,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 +109,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 +126,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 +138,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 +160,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