lhc 13.2.0 → 13.4.0.pre.pro1766.1

data/lib/lhc/interceptors/caching.rb

@@ -42,6 +42,7 @@ class LHC::Caching < LHC::Interceptor
   def before_request
     return unless cache?(request)
     return if response_data.blank?
+
     from_cache(request, response_data)
   end
 
@@ -49,6 +50,7 @@ class LHC::Caching < LHC::Interceptor
     return unless response.success?
     return unless cache?(request)
     return if response_data.present?
+
     multilevel_cache.write(
       key(request, options[:key]),
       to_cache(response),
@@ -62,6 +64,7 @@ class LHC::Caching < LHC::Interceptor
   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
 
@@ -81,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?
@@ -92,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,17 +13,20 @@ class LHC::Monitoring < LHC::Interceptor
 
   def before_request
     return unless statsd
+
     LHC::Monitoring.statsd.count("#{key}.before_request", 1)
   end
 
   def after_request
     return unless statsd
+
     LHC::Monitoring.statsd.count("#{key}.count", 1)
     LHC::Monitoring.statsd.count("#{key}.after_request", 1)
   end
 
   def after_response
     return unless statsd
+
     monitor_time!
     monitor_cache!
     monitor_response!
@@ -38,6 +41,7 @@ class LHC::Monitoring < LHC::Interceptor
   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
@@ -47,6 +51,7 @@ class LHC::Monitoring < LHC::Interceptor
 
   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
 
@@ -78,7 +83,8 @@ class LHC::Monitoring < LHC::Interceptor
   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/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/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
@@ -56,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
@@ -67,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
 
@@ -85,12 +109,14 @@ 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?
+
     Addressable::URI.escape(url)
   end
 
@@ -100,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
@@ -111,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
@@ -139,6 +167,7 @@ class LHC::Request
 
   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/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/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/scrubber.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class LHC::Scrubber
+  attr_accessor :scrubbed
+
+  SCRUB_DISPLAY = '[FILTERED]'
+
+  def initialize(data)
+    @scrubbed = data.deep_dup
+  end
+
+  private
+
+  def scrub_auth_elements
+    LHC.config.scrubs.dig(:auth)
+  end
+
+  def scrub!
+    return if scrub_elements.blank?
+    return if scrubbed.blank?
+
+    LHC::Scrubber.scrub_hash!(scrub_elements, scrubbed) if scrubbed.is_a?(Hash)
+    LHC::Scrubber.scrub_array!(scrub_elements, scrubbed) if scrubbed.is_a?(Array)
+  end
+
+  def self.scrub_array!(scrub_elements, scrubbed)
+    scrubbed.each do |scrubbed_hash|
+      LHC::Scrubber.scrub_hash!(scrub_elements, scrubbed_hash)
+    end
+  end
+
+  def self.scrub_hash!(scrub_elements, scrubbed)
+    scrub_elements.each do |scrub_element|
+      if scrubbed.key?(scrub_element.to_s)
+        key = scrub_element.to_s
+      elsif scrubbed.key?(scrub_element.to_sym)
+        key = scrub_element.to_sym
+      end
+      next if key.blank?
+
+      scrubbed[key] = SCRUB_DISPLAY
+    end
+    scrubbed.values.each { |v| LHC::Scrubber.scrub_hash!(scrub_elements, v) if v.instance_of?(Hash) }
+  end
+end

data/lib/lhc/scrubbers/auth_scrubber.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class LHC::AuthScrubber < LHC::Scrubber
+  def initialize(data)
+    super(data)
+    scrub_auth_options!
+  end
+
+  private
+
+  def scrub_auth_options!
+    return if scrubbed.blank?
+    return if scrub_auth_elements.blank?
+
+    scrub_basic_auth_options! if scrub_auth_elements.include?(:basic)
+    scrub_bearer_auth_options! if scrub_auth_elements.include?(:bearer)
+  end
+
+  def scrub_basic_auth_options!
+    return if scrubbed[:basic].blank?
+
+    scrubbed[:basic][:username] = SCRUB_DISPLAY
+    scrubbed[:basic][:password] = SCRUB_DISPLAY
+    scrubbed[:basic][:base_64_encoded_credentials] = SCRUB_DISPLAY
+  end
+
+  def scrub_bearer_auth_options!
+    return if scrubbed[:bearer].blank?
+
+    scrubbed[:bearer_token] = SCRUB_DISPLAY
+  end
+end

data/lib/lhc/scrubbers/body_scrubber.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class LHC::BodyScrubber < LHC::Scrubber
+  def initialize(data)
+    super(data)
+    parse!
+    scrub!
+  end
+
+  private
+
+  def scrub_elements
+    LHC.config.scrubs[:body]
+  end
+
+  def parse!
+    return if scrubbed.nil?
+    return if scrubbed.is_a?(Hash)
+    return if scrubbed.is_a?(Array)
+
+    if scrubbed.is_a?(String)
+      json = scrubbed
+    else
+      json = scrubbed.to_json
+    end
+
+    parsed = JSON.parse(json)
+    self.scrubbed = parsed if parsed.is_a?(Hash) || parsed.is_a?(Array)
+  end
+end

data/lib/lhc/scrubbers/headers_scrubber.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class LHC::HeadersScrubber < LHC::Scrubber
+  def initialize(data, auth_options)
+    super(data)
+    @auth_options = auth_options
+    scrub!
+    scrub_auth_headers!
+  end
+
+  private
+
+  attr_reader :auth_options
+
+  def scrub_elements
+    LHC.config.scrubs[:headers]
+  end
+
+  def scrub_auth_headers!
+    return if scrub_auth_elements.blank?
+    return if auth_options.blank?
+
+    scrub_basic_authentication_headers! if scrub_auth_elements.include?(:basic)
+    scrub_bearer_authentication_headers! if scrub_auth_elements.include?(:bearer)
+  end
+
+  def scrub_basic_authentication_headers!
+    return if auth_options[:basic].blank?
+    return if scrubbed['Authorization'].blank?
+
+    scrubbed['Authorization'] = scrubbed['Authorization'].gsub(auth_options[:basic][:base_64_encoded_credentials], SCRUB_DISPLAY)
+  end
+
+  def scrub_bearer_authentication_headers!
+    return if @auth_options[:bearer].blank?
+    return if @scrubbed['Authorization'].blank?
+
+    @scrubbed['Authorization'] = scrubbed['Authorization'].gsub(auth_options[:bearer_token], SCRUB_DISPLAY)
+  end
+end

data/lib/lhc/scrubbers/params_scrubber.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class LHC::ParamsScrubber < LHC::Scrubber
+  def initialize(data)
+    super(data)
+    scrub!
+  end
+
+  private
+
+  def scrub_elements
+    LHC.config.scrubs[:params]
+  end
+end

data/lib/lhc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LHC
-  VERSION ||= '13.2.0'
+  VERSION ||= '13.4.0-pro1766.1'
 end