dhc 1.0.0

data/lib/dhc/interceptors/retry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class DHC::Retry < DHC::Interceptor
+  attr_accessor :retries, :current_retry
+
+  class << self
+    attr_accessor :max, :all
+  end
+
+  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
+      response.request.run!
+    rescue DHC::Error
+      return
+    end
+    response.request.response if current_retry == response.request.options[:retries]
+  end
+
+  private
+
+  def retry?(request)
+    return false if request.response.success?
+    return false if request.error_ignored?
+    return false if !request.options.dig(:retry) && !DHC::Retry.all
+    request.options[:retries] < max(request)
+  end
+
+  def max(request)
+    options(request).is_a?(Hash) ? options(request).fetch(:max, DHC::Retry.max) : DHC::Retry.max
+  end
+
+  def options(request)
+    @options ||= request.options.dig(:retry)
+  end
+end
+
+DHC::Retry.max = 3

data/lib/dhc/interceptors/rollbar.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'core_ext/hash/deep_transform_values'
+
+class DHC::Rollbar < DHC::Interceptor
+  include ActiveSupport::Configurable
+  include DHC::FixInvalidEncodingConcern
+
+  def after_response
+    return unless Object.const_defined?('Rollbar')
+    return if response.success?
+    request = response.request
+    additional_params = request.options.fetch(:rollbar, {})
+    data = {
+      response: {
+        body: response.body,
+        code: response.code,
+        headers: response.headers,
+        time: response.time,
+        timeout?: response.timeout?
+      },
+      request: {
+        url: request.url,
+        method: request.method,
+        headers: request.headers,
+        params: request.params
+      }
+    }.merge additional_params
+    begin
+      Rollbar.warning("Status: #{response.code} URL: #{request.url}", data)
+    rescue Encoding::UndefinedConversionError
+      sanitized_data = data.deep_transform_values { |value| self.class.fix_invalid_encoding(value) }
+      Rollbar.warning("Status: #{response.code} URL: #{request.url}", sanitized_data)
+    end
+  end
+end

data/lib/dhc/interceptors/throttle.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'active_support/duration'
+
+class DHC::Throttle < DHC::Interceptor
+  class OutOfQuota < StandardError
+  end
+
+  class << self
+    attr_accessor :track
+  end
+
+  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('%')
+  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),
+      remaining: remaining(options: options[:remaining], response: response),
+      expires: expires(options: options[:expires], response: response)
+    }
+  end
+
+  private
+
+  def throttle?(options)
+    [options&.dig(:track), response.headers].none?(&:blank?)
+  end
+
+  def break_when_quota_reached!
+    options = request.options.dig(:throttle)
+    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]
+    quota = 100 - options[:break].to_i
+    raise(OutOfQuota, "Reached predefined quota for #{options[:provider]}") if remaining < quota * limit
+  end
+
+  def limit(options:, response:)
+    @limit ||=
+      if options.is_a?(Proc)
+        options.call(response)
+      elsif options.is_a?(Integer)
+        options
+      elsif options.is_a?(Hash) && options[:header]
+        response.headers[options[:header]]&.to_i
+      end
+  end
+
+  def remaining(options:, response:)
+    @remaining ||=
+      begin
+        if options.is_a?(Proc)
+          options.call(response)
+        elsif options.is_a?(Hash) && options[:header]
+          response.headers[options[:header]]&.to_i
+        end
+      end
+  end
+
+  def expires(options:, response:)
+    @expires ||= convert_expires(read_expire_option(options, response))
+  end
+
+  def read_expire_option(options, response)
+    (options.is_a?(Hash) && options[:header]) ? response.headers[options[:header]] : options
+  end
+
+  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/)
+    Time.zone.at(value.to_i).to_datetime
+  end
+end

data/lib/dhc/interceptors/zipkin.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+class DHC::Zipkin < DHC::Interceptor
+  B3_HEADERS = {
+    trace_id: 'X-B3-TraceId',
+    parent_id: 'X-B3-ParentSpanId',
+    span_id: 'X-B3-SpanId',
+    sampled: 'X-B3-Sampled',
+    flags: 'X-B3-Flags'
+  }.freeze
+  TRUE = '1' # true in binary annotation
+
+  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 }
+      # only sample the current call if we're instructed to do so
+      start_trace! if ::Trace.tracer && trace_id.sampled?
+    end
+  end
+
+  def after_response
+    # only sample the current call if we're instructed to do so
+    return unless dependencies? && trace_id.sampled?
+    end_trace!
+  end
+
+  private
+
+  def tracing?
+    ZipkinTracer::TraceContainer.current
+  end
+
+  def start_trace!
+    record_path
+    record_remote_endpoint
+    record_local_endpoint
+  end
+
+  def end_trace!
+    record_status
+    record_error unless response.success?
+    record_end
+  end
+
+  def trace_id
+    @trace_id ||= ZipkinTracer::TraceGenerator.new.next_trace_id
+  end
+
+  # register a new span with zipkin tracer
+  def span
+    @span ||= ::Trace.tracer.start_span(trace_id, url.path)
+  end
+
+  def url
+    @url ||= URI(request.raw.url)
+  end
+
+  def status
+    @status ||= response.code.to_s
+  end
+
+  def service_name
+    @service_name ||= url.host
+  end
+
+  def record_local_endpoint
+    span.record(::Trace::Annotation::CLIENT_SEND, local_endpoint)
+  end
+
+  def record_remote_endpoint
+    span.record_tag(::Trace::BinaryAnnotation::SERVER_ADDRESS, TRUE, ::Trace::BinaryAnnotation::Type::BOOL, remote_endpoint)
+  end
+
+  def record_path
+    span.record_tag(::Trace::BinaryAnnotation::PATH, url.path, ::Trace::BinaryAnnotation::Type::STRING, local_endpoint)
+  end
+
+  def record_end
+    span.record(::Trace::Annotation::CLIENT_RECV, local_endpoint)
+    ::Trace.tracer.end_span(span)
+  end
+
+  def record_error
+    span.record_tag(::Trace::BinaryAnnotation::ERROR, status, ::Trace::BinaryAnnotation::Type::STRING, local_endpoint)
+  end
+
+  def record_status
+    span.record_tag(::Trace::BinaryAnnotation::STATUS, status, ::Trace::BinaryAnnotation::Type::STRING, local_endpoint)
+  end
+
+  def local_endpoint
+    @local_endpoint ||= ::Trace.default_endpoint
+  end
+
+  def remote_endpoint
+    @remote_endpoint ||= ::Trace::Endpoint.remote_endpoint(url, service_name, local_endpoint.ip_format)
+  end
+
+  def dependencies?
+    (
+      defined?(ZipkinTracer::TraceContainer) &&
+      defined?(::Trace) &&
+      defined?(::Trace::Annotation) &&
+      defined?(::Trace::BinaryAnnotation) &&
+      defined?(::Trace::Endpoint)
+    ) || warn('[WARNING] Zipkin interceptor is enabled but dependencies are not found. See: https://github.com/DePayFi/dhc#zipkin')
+  end
+end

data/lib/dhc/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DHC
+  class Railtie < Rails::Railtie
+    initializer 'dhc.configure_rails_initialization' do
+      DHC::Caching.cache ||= Rails.cache
+    end
+  end
+end

data/lib/dhc/request.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'active_support/core_ext/object/deep_dup'
+require 'dhc/concerns/dhc/request/user_agent_concern'
+
+# The request is doing an http-request using typhoeus.
+# It provides functionalities to access and alter request data
+# and it communicates with interceptors.
+class DHC::Request
+  include UserAgentConcern
+
+  TYPHOEUS_OPTIONS ||= %i[params method body headers follow_location params_encoding].freeze
+
+  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
+    self.source = options&.dig(:source)
+    self.options = format!(options.deep_dup || {})
+    self.error_handler = options.delete :rescue
+    use_configured_endpoint!
+    generate_url_from_template!
+    self.interceptors = DHC::Interceptors.new(self)
+    interceptors.intercept(:before_raw_request)
+    self.raw = create_request
+    interceptors.intercept(:before_request)
+    if self_executing && !response
+      run!
+    elsif response
+      on_complete(response)
+    end
+  end
+
+  def url
+    raw.base_url || options[:url]
+  end
+
+  def method
+    (raw.options[:method] || options[:method] || :get).to_sym
+  end
+
+  def headers
+    raw.options.fetch(:headers, nil) || raw.options[:headers] = {}
+  end
+
+  def params
+    raw.options.fetch(:params, nil) || raw.options[:params] = {}
+  end
+
+  def error_ignored?
+    ignore_error?
+  end
+
+  def run!
+    raw.run
+  end
+
+  private
+
+  attr_accessor :interceptors
+
+  def format!(options)
+    self.format = options.delete(:format) || DHC::Formats::JSON.new
+    format.format_options(options)
+  end
+
+  def optionally_encoded_url(options)
+    return options[:url] unless options.fetch(:url_encoding, true)
+    encode_url(options[:url])
+  end
+
+  def create_request
+    request = Typhoeus::Request.new(
+      optionally_encoded_url(options),
+      translate_body(typhoeusize(options))
+    )
+    request.on_headers do
+      interceptors.intercept(:after_request)
+      interceptors.intercept(:before_response)
+    end
+    request.on_complete { |response| on_complete(response) }
+    request
+  end
+
+  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
+
+  def typhoeusize(options)
+    options = options.deep_dup
+    easy = Ethon::Easy.new
+    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
+    options
+  end
+
+  # Get configured endpoint and use it for doing the request.
+  # Explicit request options are overriding configured options.
+  def use_configured_endpoint!
+    endpoint = DHC.config.endpoints[options[:url]]
+    return unless endpoint
+    # explicit options override endpoint options
+    new_options = endpoint.options.deep_merge(options)
+    # set new options
+    self.options = new_options
+    options[:url] = endpoint.url
+  end
+
+  # Generates URL from a URL template
+  def generate_url_from_template!
+    endpoint = DHC::Endpoint.new(options[:url])
+    params =
+      if format && options[:body].present? && options[:body].respond_to?(:as_json) && options[:body].as_json.is_a?(Hash)
+        options[:body].as_json.merge(options[:params] || {}).deep_symbolize_keys
+      else
+        options[:params]
+      end
+    options[:url] = endpoint.compile(params)
+    endpoint.remove_interpolated_params!(options[:params])
+  end
+
+  def on_complete(response)
+    self.response = response.is_a?(DHC::Response) ? response : DHC::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
+
+  def ignore_error?
+    @ignore_error ||= begin
+      errors_ignored.detect do |ignored_error|
+        error <= ignored_error
+      end.present?
+    end
+  end
+
+  def error
+    @error ||= DHC::Error.find(response)
+  end
+
+  def throw_error(response)
+    raise error.new(error, response)
+  end
+end