lhc 13.0.0 → 14.0.0

data/.ruby-version

@@ -1 +1 @@
-ruby-2.6.5
+ruby-2.7.2

data/README.md

@@ -73,6 +73,10 @@ use it like:
            * [Installation](#installation-1)
            * [Environment](#environment)
            * [What it tracks](#what-it-tracks)
+              * [Before and after request tracking](#before-and-after-request-tracking)
+              * [Response tracking](#response-tracking)
+              * [Timeout tracking](#timeout-tracking)
+              * [Caching tracking](#caching-tracking)
            * [Configure](#configure-1)
         * [Prometheus Interceptor](#prometheus-interceptor)
         * [Retry Interceptor](#retry-interceptor)
@@ -95,6 +99,7 @@ use it like:
 
 
 
+
 ## Basic methods
 
 Available are `get`, `post`, `put` & `delete`.
@@ -744,11 +749,15 @@ It tracks request attempts with `before_request` and `after_request` (counts).
 In case your workers/processes are getting killed due limited time constraints,
 you are able to detect deltas with relying on "before_request", and "after_request" counts:
 
+###### Before and after request tracking
+
 ```ruby
   "lhc.<app_name>.<env>.<host>.<http_method>.before_request", 1
   "lhc.<app_name>.<env>.<host>.<http_method>.after_request", 1
 ```
 
+###### Response tracking
+
 In case of a successful response it reports the response code with a count and the response time with a gauge value.
 
 ```ruby
@@ -759,6 +768,17 @@ In case of a successful response it reports the response code with a count and t
   "lhc.<app_name>.<env>.<host>.<http_method>.time", 43
 ```
 
+In case of a unsuccessful response it reports the response code with a count but no time:
+
+```ruby
+  LHC.get('http://local.ch')
+
+  "lhc.<app_name>.<env>.<host>.<http_method>.count", 1
+  "lhc.<app_name>.<env>.<host>.<http_method>.500", 1
+```
+
+###### Timeout tracking
+
 Timeouts are also reported:
 
 ```ruby
@@ -767,6 +787,30 @@ Timeouts are also reported:
 
 All the dots in the host are getting replaced with underscore, because dot is the default separator in graphite.
 
+###### Caching tracking
+
+When you want to track caching stats please make sure you have enabled the `LHC::Caching` and the `LHC::Monitoring` interceptor.
+
+Make sure that the `LHC::Caching` is listed before `LHC::Monitoring` interceptor when configuring interceptors:
+
+```ruby
+LHC.configure do |c|
+  c.interceptors = [LHC::Caching, LHC::Monitoring]
+end
+```
+
+If a response was served from cache it tracks:
+
+```ruby
+  "lhc.<app_name>.<env>.<host>.<http_method>.cache.hit", 1
+```
+
+If a response was not served from cache it tracks:
+
+```ruby
+  "lhc.<app_name>.<env>.<host>.<http_method>.cache.miss", 1
+```
+
 ##### Configure
 
 It is possible to set the key for Monitoring Interceptor on per request basis:

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -17,9 +19,7 @@ end
 begin
   require 'rspec/core/rake_task'
   RSpec::Core::RakeTask.new(:spec)
-  task :default => :spec
-rescue LoadError
-  # no rspec available
+  task default: :spec
 end
 
 Bundler::GemHelper.install_tasks

data/lhc.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   s.requirements << 'Ruby >= 2.0.0'
+  s.required_ruby_version = '>= 2.7' # Needed for rubocop
 
   s.add_dependency 'activesupport', '>= 5.2'
   s.add_dependency 'addressable'
@@ -31,7 +32,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rails', '>= 5.2'
   s.add_development_dependency 'redis'
   s.add_development_dependency 'rspec-rails', '>= 3.0.0'
-  s.add_development_dependency 'rubocop', '~> 0.57.1'
+  s.add_development_dependency 'rubocop', '~> 1.0'
+  s.add_development_dependency 'rubocop-performance', '~> 1.0'
   s.add_development_dependency 'rubocop-rspec', '~> 1.26.0'
   s.add_development_dependency 'timecop'
   s.add_development_dependency 'webmock'

data/lib/lhc.rb

@@ -6,131 +6,131 @@ require 'active_support/core_ext/hash/keys'
 
 module LHC
   autoload :BasicMethodsConcern,
-    'lhc/concerns/lhc/basic_methods_concern'
+           'lhc/concerns/lhc/basic_methods_concern'
   autoload :ConfigurationConcern,
-    'lhc/concerns/lhc/configuration_concern'
+           'lhc/concerns/lhc/configuration_concern'
   autoload :FixInvalidEncodingConcern,
-    'lhc/concerns/lhc/fix_invalid_encoding_concern'
+           'lhc/concerns/lhc/fix_invalid_encoding_concern'
   autoload :FormatsConcern,
-    'lhc/concerns/lhc/formats_concern'
+           'lhc/concerns/lhc/formats_concern'
 
   include BasicMethodsConcern
   include ConfigurationConcern
   include FormatsConcern
 
   autoload :Auth,
-    'lhc/interceptors/auth'
+           'lhc/interceptors/auth'
   autoload :Caching,
-    'lhc/interceptors/caching'
+           'lhc/interceptors/caching'
   autoload :DefaultTimeout,
-    'lhc/interceptors/default_timeout'
+           'lhc/interceptors/default_timeout'
   autoload :Logging,
-    'lhc/interceptors/logging'
+           'lhc/interceptors/logging'
   autoload :Prometheus,
-    'lhc/interceptors/prometheus'
+           'lhc/interceptors/prometheus'
   autoload :Retry,
-    'lhc/interceptors/retry'
+           'lhc/interceptors/retry'
   autoload :Throttle,
-    'lhc/interceptors/throttle'
+           'lhc/interceptors/throttle'
 
   autoload :Config,
-    'lhc/config'
+           'lhc/config'
   autoload :Endpoint,
-    'lhc/endpoint'
+           'lhc/endpoint'
 
   autoload :Error,
-    'lhc/error'
+           'lhc/error'
   autoload :ClientError,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :BadRequest,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :Unauthorized,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :PaymentRequired,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :Forbidden,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :Forbidden,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :NotFound,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :MethodNotAllowed,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :NotAcceptable,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :ProxyAuthenticationRequired,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :RequestTimeout,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :Conflict,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :Gone,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :LengthRequired,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :PreconditionFailed,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :RequestEntityTooLarge,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :RequestUriToLong,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :UnsupportedMediaType,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :RequestedRangeNotSatisfiable,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :ExpectationFailed,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :UnprocessableEntity,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :Locked,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :FailedDependency,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :UpgradeRequired,
-    'lhc/errors/client_error'
+           'lhc/errors/client_error'
   autoload :ParserError,
-    'lhc/errors/parser_error'
+           'lhc/errors/parser_error'
   autoload :ServerError,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :InternalServerError,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :NotImplemented,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :BadGateway,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :ServiceUnavailable,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :GatewayTimeout,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :HttpVersionNotSupported,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :InsufficientStorage,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :NotExtended,
-    'lhc/errors/server_error'
+           'lhc/errors/server_error'
   autoload :Timeout,
-    'lhc/errors/timeout'
+           'lhc/errors/timeout'
   autoload :UnknownError,
-    'lhc/errors/unknown_error'
+           'lhc/errors/unknown_error'
 
   autoload :Interceptor,
-    'lhc/interceptor'
+           'lhc/interceptor'
   autoload :Interceptors,
-    'lhc/interceptors'
+           'lhc/interceptors'
   autoload :Formats,
-    'lhc/formats'
+           'lhc/formats'
   autoload :Format,
-    'lhc/format'
+           'lhc/format'
   autoload :Monitoring,
-    'lhc/interceptors/monitoring'
+           'lhc/interceptors/monitoring'
   autoload :Request,
-    'lhc/request'
+           'lhc/request'
   autoload :Response,
-    'lhc/response'
+           'lhc/response'
   autoload :Rollbar,
-    'lhc/interceptors/rollbar'
+           'lhc/interceptors/rollbar'
   autoload :Zipkin,
-    'lhc/interceptors/zipkin'
+           'lhc/interceptors/zipkin'
 
   require 'lhc/railtie' if defined?(Rails)
 end

data/lib/lhc/concerns/lhc/fix_invalid_encoding_concern.rb

@@ -12,6 +12,7 @@ module LHC
       # an empty string is returned instead
       def fix_invalid_encoding(string)
         return string unless string.is_a?(String)
+
         result = string.dup
 
         # we assume it's ISO-8859-1 first

data/lib/lhc/config.rb

@@ -13,6 +13,7 @@ class LHC::Config
   def endpoint(name, url, options = {})
     name = name.to_sym
     raise 'Endpoint already exists for that name' if @endpoints[name]
+
     @endpoints[name] = LHC::Endpoint.new(url, options)
   end
 
@@ -23,6 +24,7 @@ class LHC::Config
   def placeholder(name, value)
     name = name.to_sym
     raise 'Placeholder already exists for that name' if @placeholders[name]
+
     @placeholders[name] = value
   end
 
@@ -36,6 +38,7 @@ class LHC::Config
 
   def interceptors=(interceptors)
     raise 'Default interceptors already set and can only be set once' if @interceptors
+
     @interceptors = interceptors
   end
 

data/lib/lhc/endpoint.rb

@@ -55,6 +55,7 @@ class LHC::Endpoint
   # Example: {+datastore}/contracts/{id} == http://local.ch/contracts/1
   def match?(url)
     return true if url == uri.pattern
+
     match_data = match_data(url)
     return false if match_data.nil?
 
@@ -75,6 +76,7 @@ class LHC::Endpoint
   def values_as_params(url)
     match_data = match_data(url)
     return if match_data.nil?
+
     Hash[match_data.variables.map(&:to_sym).zip(match_data.values)]
   end
 
@@ -103,6 +105,7 @@ class LHC::Endpoint
   # creates params according to template
   def self.values_as_params(template, url)
     raise("#{url} does not match the template: #{template}") if !match?(url, template)
+
     new(template).values_as_params(url)
   end
 

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,8 +65,11 @@ 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}"

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
 
@@ -75,10 +76,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 +87,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