dhc 1.0.0

data/lib/dhc/interceptors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Handles interceptions during the lifecycle of a request
+# Represents all active interceptors for a request/response.
+class DHC::Interceptors
+
+  attr_accessor :all
+
+  # Intitalizes and determines if global or local interceptors are used
+  def initialize(request)
+    self.all = (request.options[:interceptors] || DHC.config.interceptors).map do |interceptor|
+      interceptor.new(request)
+    end
+  end
+
+  # Forwards messages to interceptors and handles provided responses.
+  def intercept(name)
+    all.each do |interceptor|
+      result = interceptor.send(name)
+      if result.is_a? DHC::Response
+        raise 'Response already set from another interceptor' if @response
+        @response = interceptor.request.response = result
+      end
+    end
+  end
+end

data/lib/dhc/interceptors/auth.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+class DHC::Auth < DHC::Interceptor
+  include ActiveSupport::Configurable
+  config_accessor :refresh_client_token
+
+  def before_raw_request
+    body_authentication! if auth_options[:body]
+  end
+
+  def before_request
+    bearer_authentication! if auth_options[:bearer]
+    basic_authentication! if auth_options[:basic]
+  end
+
+  def after_response
+    return unless configuration_correct?
+    return unless reauthenticate?
+    reauthenticate!
+  end
+
+  private
+
+  def body_authentication!
+    auth = auth_options[:body]
+    request.options[:body] = (request.options[:body] || {}).merge(auth)
+  end
+
+  def basic_authentication!
+    auth = auth_options[:basic]
+    credentials = "#{auth[:username]}:#{auth[:password]}"
+    set_authorization_header("Basic #{Base64.strict_encode64(credentials).chomp}")
+  end
+
+  def bearer_authentication!
+    token = auth_options[:bearer]
+    token = token.call if token.is_a?(Proc)
+    set_bearer_authorization_header(token)
+  end
+
+  def set_authorization_header(value)
+    request.headers['Authorization'] = value
+  end
+
+  def set_bearer_authorization_header(token)
+    set_authorization_header("Bearer #{token}")
+  end
+
+  def reauthenticate!
+    # refresh token and update header
+    token = refresh_client_token_option.call
+    set_bearer_authorization_header(token)
+    # trigger DHC::Retry and ensure we do not trigger reauthenticate!
+    # again should it fail another time
+    new_options = request.options.dup
+    new_options = new_options.merge(retry: { max: 1 })
+    new_options = new_options.merge(auth: { reauthenticated: true })
+    request.options = new_options
+  end
+
+  def reauthenticate?
+    !response.success? &&
+      !auth_options[:reauthenticated] &&
+      bearer_header_present? &&
+      DHC::Error.find(response) == DHC::Unauthorized
+  end
+
+  def bearer_header_present?
+    @has_bearer_header ||= request.headers['Authorization'] =~ /^Bearer .+$/i
+  end
+
+  def refresh_client_token_option
+    @refresh_client_token_option ||= auth_options[:refresh_client_token] || refresh_client_token
+  end
+
+  def auth_options
+    request.options[:auth] || {}
+  end
+
+  def configuration_correct?
+    # warn user about configs, only if refresh_client_token_option is set at all
+    refresh_client_token_option && refresh_client_token? && retry_interceptor?
+  end
+
+  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?(DHC::Retry) && all_interceptor_classes.index(DHC::Retry) > all_interceptor_classes.index(self.class)
+    warn('[WARNING] Your interceptors must include DHC::Retry after DHC::Auth.')
+  end
+end

data/lib/dhc/interceptors/caching.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+class DHC::Caching < DHC::Interceptor
+  include ActiveSupport::Configurable
+
+  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 = %i[expires_in race_condition_ttl].freeze
+
+  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 %([DHC] served from central cache: "#{key}")
+        return central_response
+      end
+      local_response = @local.fetch(key) if @local
+      if local_response
+        puts %([DHC] 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)
+    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),
+      cache_options
+    )
+  end
+
+  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(
+      central: central_cache,
+      local: local_cache
+    )
+  end
+
+  # returns the local cache either configured for entire DHC
+  # 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]
+    (local_cache || central_cache) &&
+      cached_method?(request.method, options[:methods])
+  end
+
+  def options
+    options = (request.options[:cache] == true) ? {} : request.options[:cache].dup
+    options
+  end
+
+  # converts json we read from the cache to an DHC::Response object
+  def from_cache(request, data)
+    raw = Typhoeus::Response.new(data)
+    response = DHC::Response.new(raw, request, from_cache: true)
+    request.response = response
+    response
+  end
+
+  # converts a DHC::Response object to json, we store in the cache
+  def to_cache(response)
+    data = {}
+    data[:body] = response.body
+    data[:code] = response.code
+    # convert into a actual hash because the typhoeus headers object breaks marshaling
+    data[:headers] = response.headers ? Hash[response.headers] : response.headers
+    # return_code is quite important as Typhoeus relies on it in order to determin 'success?'
+    data[:return_code] = response.options[:return_code]
+    # in a test scenario typhoeus uses mocks and not return_code to determine 'success?'
+    data[:mock] = response.mock
+    data
+  end
+
+  def key(request, key)
+    unless key
+      key = "#{request.method.upcase} #{request.url}"
+      key += "?#{request.params.to_query}" unless request.params.blank?
+    end
+    "DHC_CACHE(v#{CACHE_VERSION}): #{key}"
+  end
+
+  # Checks if the provided method should be cached
+  # in regards of the provided options.
+  def cached_method?(method, cached_methods)
+    (cached_methods || [:get]).include?(method)
+  end
+
+  # extracts the options that should be forwarded to
+  # the cache
+  def cache_options
+    options.each_with_object({}) do |(key, value), result|
+      result[key] = value if key.in? FORWARDED_OPTIONS
+      result
+    end
+  end
+end

data/lib/dhc/interceptors/default_timeout.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class DHC::DefaultTimeout < DHC::Interceptor
+  include ActiveSupport::Configurable
+
+  config_accessor :timeout, :connecttimeout
+
+  CONNECTTIMEOUT = 2 # seconds
+  TIMEOUT = 15 # seconds
+
+  def before_raw_request
+    request_options = (request.options || {})
+    request_options[:timeout] ||= timeout || TIMEOUT
+    request_options[:connecttimeout] ||= connecttimeout || CONNECTTIMEOUT
+  end
+end

data/lib/dhc/interceptors/logging.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class DHC::Logging < DHC::Interceptor
+
+  include ActiveSupport::Configurable
+  config_accessor :logger
+
+  def before_request
+    return unless logger
+    logger.info(
+      [
+        'Before DHC request',
+        "<#{request.object_id}>",
+        request.method.upcase,
+        "#{request.url} at #{Time.now.iso8601}",
+        "Params=#{request.params}",
+        "Headers=#{request.headers}",
+        request.source ? "\nCalled from #{request.source}" : nil
+      ].compact.join(' ')
+    )
+  end
+
+  def after_response
+    return unless logger
+    logger.info(
+      [
+        'After DHC response for request',
+        "<#{request.object_id}>",
+        request.method.upcase,
+        "#{request.url} at #{Time.now.iso8601}",
+        "Time=#{response.time_ms}ms",
+        "URL=#{response.effective_url}",
+        request.source ? "\nCalled from #{request.source}" : nil
+      ].compact.join(' ')
+    )
+  end
+end

data/lib/dhc/interceptors/monitoring.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+class DHC::Monitoring < DHC::Interceptor
+
+  # Options forwarded to the monitoring
+  FORWARDED_OPTIONS = {
+    monitoring_key: :key
+  }.freeze
+
+  include ActiveSupport::Configurable
+
+  config_accessor :statsd, :env
+
+  def before_request
+    return unless statsd
+    DHC::Monitoring.statsd.count("#{key}.before_request", 1)
+  end
+
+  def after_request
+    return unless statsd
+    DHC::Monitoring.statsd.count("#{key}.count", 1)
+    DHC::Monitoring.statsd.count("#{key}.after_request", 1)
+  end
+
+  def after_response
+    return unless statsd
+    monitor_time!
+    monitor_cache!
+    monitor_response!
+  end
+
+  private
+
+  def monitor_time!
+    DHC::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?
+      DHC::Monitoring.statsd.count("#{key}.cache.hit", 1)
+    else
+      DHC::Monitoring.statsd.count("#{key}.cache.miss", 1)
+    end
+  end
+
+  def monitor_caching_configuration_check
+    return true if all_interceptor_classes.include?(DHC::Caching) && all_interceptor_classes.index(self.class) > all_interceptor_classes.index(DHC::Caching)
+    warn('[WARNING] Your interceptors must include DHC::Caching and DHC::Monitoring and also in that order.')
+  end
+
+  def monitor_response!
+    if response.timeout?
+      DHC::Monitoring.statsd.count("#{key}.timeout", 1)
+    else
+      DHC::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 = [
+      'dhc',
+      module_parent_name.underscore,
+      DHC::Monitoring.env || Rails.env,
+      URI.parse(url).host.gsub(/\./, '_'),
+      request.method
+    ]
+    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}"
+  end
+
+  def options(input = {})
+    options = {}
+    FORWARDED_OPTIONS.each do |k, v|
+      options[v] = input[k] if input.key?(k)
+    end
+    options
+  end
+end

data/lib/dhc/interceptors/prometheus.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class DHC::Prometheus < DHC::Interceptor
+  include ActiveSupport::Configurable
+
+  config_accessor :client, :namespace
+
+  REQUEST_COUNTER_KEY = :dhc_requests
+  REQUEST_HISTOGRAM_KEY = :dhc_request_seconds
+
+  class << self
+    attr_accessor :registered
+  end
+
+  def initialize(request)
+    super(request)
+    return if DHC::Prometheus.registered || DHC::Prometheus.client.blank?
+
+    begin
+      DHC::Prometheus.client.registry.counter(DHC::Prometheus::REQUEST_COUNTER_KEY, 'Counter of all DHC requests.')
+      DHC::Prometheus.client.registry.histogram(DHC::Prometheus::REQUEST_HISTOGRAM_KEY, 'Request timings for all DHC requests in seconds.')
+    rescue Prometheus::Client::Registry::AlreadyRegisteredError => e
+      Rails.logger.error(e) if defined?(Rails)
+    ensure
+      DHC::Prometheus.registered = true
+    end
+  end
+
+  def after_response
+    return if !DHC::Prometheus.registered || DHC::Prometheus.client.blank?
+
+    host = URI.parse(request.url).host
+
+    DHC::Prometheus.client.registry
+      .get(DHC::Prometheus::REQUEST_COUNTER_KEY)
+      .increment(
+        code: response.code,
+        success: response.success?,
+        timeout: response.timeout?,
+        host: host,
+        app: DHC::Prometheus.namespace
+      )
+
+    DHC::Prometheus.client.registry
+      .get(DHC::Prometheus::REQUEST_HISTOGRAM_KEY)
+      .observe({
+                 host: host,
+                 app: DHC::Prometheus.namespace
+               }, response.time)
+  end
+end