lhc 12.0.0

data/lib/lhc/interceptors/default_timeout.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class LHC::DefaultTimeout < LHC::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/lhc/interceptors/logging.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class LHC::Logging < LHC::Interceptor
+
+  include ActiveSupport::Configurable
+  config_accessor :logger
+
+  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}",
+        request.source ? "\nCalled from #{request.source}" : nil
+      ].compact.join(' ')
+    )
+  end
+
+  def after_response
+    return unless logger
+    logger.info(
+      [
+        'After LHC 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/lhc/interceptors/monitoring.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class LHC::Monitoring < LHC::Interceptor
+
+  # Options forwarded to the monitoring
+  FORWARDED_OPTIONS = {
+    monitoring_key: :key
+  }
+
+  include ActiveSupport::Configurable
+
+  config_accessor :statsd, :env
+
+  def before_request
+    return unless statsd
+    LHC::Monitoring.statsd.count("#{key(request)}.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)
+  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)
+  end
+
+  private
+
+  def key(target)
+    request = target.is_a?(LHC::Request) ? target : target.request
+    key = options(request.options)[:key]
+    return key if key.present?
+
+    url = sanitize_url(request.url)
+    key = [
+      'lhc',
+      Rails.application.class.parent_name.underscore,
+      LHC::Monitoring.env || Rails.env,
+      URI.parse(url).host.gsub(/\./, '_'),
+      request.method
+    ]
+    key.join('.')
+  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/lhc/interceptors/prometheus.rb

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

data/lib/lhc/interceptors/retry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class LHC::Retry < LHC::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 LHC::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) && !LHC::Retry.all
+    request.options[:retries] < max(request)
+  end
+
+  def max(request)
+    options(request).is_a?(Hash) ? options(request).fetch(:max, LHC::Retry.max) : LHC::Retry.max
+  end
+
+  def options(request)
+    @options ||= request.options.dig(:retry)
+  end
+end
+
+LHC::Retry.max = 3

data/lib/lhc/interceptors/rollbar.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'core_ext/hash/deep_transform_values'
+
+class LHC::Rollbar < LHC::Interceptor
+  include ActiveSupport::Configurable
+  include LHC::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/lhc/interceptors/throttle.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'active_support/duration'
+
+class LHC::Throttle < LHC::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 options
+    return unless options.dig(:track)
+    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 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 ||= begin
+      if options.is_a?(Integer)
+        options
+      elsif options.is_a?(Hash) && options[:header] && response.headers.present?
+        response.headers[options[:header]]&.to_i
+      end
+    end
+  end
+
+  def remaining(options:, response:)
+    @remaining ||= begin
+      if options.is_a?(Hash) && options[:header] && response.headers.present?
+        response.headers[options[:header]]&.to_i
+      end
+    end
+  end
+
+  def expires(options:, response:)
+    @expires ||= begin
+      if options.is_a?(Hash) && options[:header] && response.headers.present?
+        convert_expires(response.headers[options[:header]]&.to_i)
+      else
+        convert_expires(options)
+      end
+    end
+  end
+
+  def convert_expires(value)
+    if value.is_a?(Integer)
+      Time.zone.at(value).to_datetime
+    end
+  end
+end

data/lib/lhc/interceptors/zipkin.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+class LHC::Zipkin < LHC::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 if !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/local-ch/lhc#zipkin')
+  end
+end

data/lib/lhc/railtie.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module LHC
+  class Railtie < Rails::Railtie
+    initializer "lhc.configure_rails_initialization" do
+      LHC::Caching.cache ||= Rails.cache
+      LHC::Caching.logger ||= Rails.logger
+    end
+  end
+end