lhc 3.8.1 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e327e8cf911398de6860f5e328bfee3d4ec4a117
-  data.tar.gz: eee4da06a4953d23eaef467a935a0a6ab7198454
+  metadata.gz: 11c5724e0fa2091b89c7589c00d0c052cab1dffd
+  data.tar.gz: '06869e81b8d6c8f9c4f85422504631a9bb76a5c3'
 SHA512:
-  metadata.gz: 63b5203325d62df8aec412bb04e0e4bd6cffdafa29527641a8e0319a91e7fd39300135d31a0a9e3e169ad287c5c678f248994a71eb786a558957017ff6c8bed5
-  data.tar.gz: b13e872cab4a98c6e06a49d1c5e59ce86fdb1c1ae0ddc2b1bfb11366b5157e2444953b0d6cb52db4d0192656d64c413a24f83295b040afec96cfb795378db954
+  metadata.gz: b63b042df636aff266df087f8b75c7542884d7e2e2bf952fba0d5f13b52f9a495616ff707994c72eec5d5669400921310940f2c0a14b3d8ffddf8d0c4deca6cd
+  data.tar.gz: f7497777305dad01fcbfa28d08893c1b00cdc0b74a23c5b6bbe091a6724cab37ea721279f1e5381fb38afa9a1680949cc9d81a66b438f85b1b7073352e51c92f

data/.rubocop.localch.yml

@@ -16,6 +16,7 @@ AllCops:
     - 'config/unicorn.rb'
     - 'config/compass.rb'
     - 'Rakefile'
+    - 'spec/error/to_s_spec.rb' # this file contains invalid UTF8 character on purpose!
 
 Rails:
   Enabled: true

data/.rubocop.yml

@@ -3,6 +3,9 @@
 inherit_from:
   - ./.rubocop.localch.yml
 
+AllCops:
+  TargetRubyVersion: 2.3
+
 Lint/IneffectiveAccessModifier:
   Enabled: false
 

data/.ruby-version

@@ -1 +1 @@
-ruby-2.2.0
+ruby-2.3.3

data/README.md

@@ -66,7 +66,7 @@ You can also access response data directly through the response object (with squ
 ## Parallel requests
 
 If you pass an array of requests to `LHC.request`, it will perform those requests in parallel.
-You will get back an array of LHC::Response objects.
+You will get back an array of LHC::Response objects in the same order of the passed requests.
 
 ```ruby
   options = []
@@ -75,6 +75,11 @@ You will get back an array of LHC::Response objects.
   responses = LHC.request(options)
 ```
 
+```ruby
+LHC.get([request1, request2, request3])
+# returns [response1, response2, response3]
+```
+
 ## Follow redirects
 
 ```ruby
@@ -163,6 +168,12 @@ To monitor and manipulate the http communication done with LHC, you can define i
 
 → [Read more about interceptors](docs/interceptors.md)
 
+A set of core interceptors is part of LHC,
+like [Caching](/docs/interceptors/caching.md), [Monitoring](/docs/interceptors/monitoring.md), [Authentication](/docs/interceptors/authentication.md), [Rollbar](/docs/interceptors/rollbar.md).
+
+→ [Read more about core interceptors](docs/interceptors.md#core-interceptors)
+
+
 ## License
 
 [GNU Affero General Public License Version 3.](https://www.gnu.org/licenses/agpl-3.0.en.html)

data/docs/interceptors.md

@@ -20,10 +20,10 @@ Interceptors
   LHC.request({url: 'http://local.ch', interceptors: []}) # no interceptor for this request
 ```
 
-## Basic Interceptors
+## Core Interceptors
 
-There are some interceptors available, that cover some basic usecases:
-[lhc-core-interceptors](https://github.com/local-ch/lhc-core-interceptors)
+There are some interceptors that are part of LHC already, that cover some basic usecases:
+like [Caching](/docs/interceptors/caching.md), [Monitoring](/docs/interceptors/monitoring.md), [Authentication](/docs/interceptors/authentication.md), [Rollbar](/docs/interceptors/rollbar.md).
 
 ## Callbacks
 

data/docs/interceptors/authentication.md

@@ -0,0 +1,33 @@
+# Authentication Interceptor
+
+Add the auth interceptor to your basic set of LHC interceptors.
+
+```ruby
+  LHC.config.interceptors = [LHC::Auth]
+```
+
+## Bearer Authentication
+
+```ruby
+  LHC.get('http://local.ch', auth: { bearer: -> { access_token } })
+```
+
+Adds the following header to the request:
+```
+  'Authorization': 'Bearer 123456'
+```
+
+Assuming the method `access_token` responds on runtime of the request with `123456`.
+
+## Basic Authentication
+
+```ruby
+  LHC.get('http://local.ch', auth: { basic: { username: 'steve', password: 'can' } })
+```
+
+Adds the following header to the request:
+```
+  'Authorization': 'Basic c3RldmU6Y2Fu'
+```
+
+Which is the base64 encoded credentials "username:password".

data/docs/interceptors/caching.md

@@ -0,0 +1,54 @@
+# Caching Interceptor
+
+Add the cache interceptor to your basic set of LHC interceptors.
+
+```ruby
+  LHC.config.interceptors = [LHC::Caching]
+```
+
+You can configure your own cache (default Rails.cache) and logger (default Rails.logger):
+
+```ruby
+  LHC::Caching.cache = ActiveSupport::Cache::MemoryStore.new
+  LHC::Caching.logger = Logger.new(STDOUT)
+```
+
+
+Caching is not enabled by default, although you added it to your basic set of interceptors.
+If you want to have requests served/stored and stored in/from cache, you have to enable it by request.
+
+```ruby
+  LHC.get('http://local.ch', cache: true)
+```
+
+You can also enable caching when configuring an endpoint in LHS.
+
+```ruby
+  class Feedbacks < LHS::Service
+    endpoint ':datastore/v2/feedbacks', cache: true
+  end
+```
+
+## Options
+
+```ruby
+  LHC.get('http://local.ch', cache: true, cache_expires_in: 1.day, cache_race_condition_ttl: 15.seconds)
+```
+
+`cache_expires_in` - lets the cache expires every X seconds.
+
+`cache_key` - Set the key that is used for caching by using the option. Every key is prefixed with `LHC_CACHE(v1): `.
+
+`cache_race_condition_ttl` - very useful in situations where a cache entry is used very frequently and is under heavy load.
+If a cache expires and due to heavy load several different processes will try to read data natively and then they all will try to write to cache.
+To avoid that case the first process to find an expired cache entry will bump the cache expiration time by the value set in `cache_race_condition_ttl`.
+
+## Testing
+
+Add to your spec_helper.rb:
+
+```ruby
+  require 'lhc/test/cache_helper.rb'
+```
+
+This will initialize a MemoryStore cache for LHC::Caching interceptor and resets the cache before every test.

data/docs/interceptors/monitoring.md

@@ -0,0 +1,54 @@
+# Monitoring Interceptor
+
+Add the monitoring interceptor to your basic set of LHC interceptors.
+
+```ruby
+  LHC.config.interceptors = [LHC::Monitoring]
+```
+
+You also have to configure statsd in order to have the monitoring interceptor report.
+
+```ruby
+  LHC::Monitoring.statsd = <your-instance-of-statsd>
+```
+
+The monitoring interceptor reports all the HTTP communication done with LHS.
+It reports the trial always.
+
+In case of a successful response it reports the response code with a count and the response time with a gauge value.
+
+```ruby
+  LHC.get('http://local.ch')
+
+  "lhc.<app_name>.<env>.<host>.<http_method>.count", 1
+  "lhc.<app_name>.<env>.<host>.<http_method>.200", 1
+  "lhc.<app_name>.<env>.<host>.<http_method>.time", 43
+```
+
+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:
+
+```ruby
+  "lhc.<app_name>.<env>.<host>.<http_method>.before_request", 1
+  "lhc.<app_name>.<env>.<host>.<http_method>.after_request", 1
+```
+
+Timeouts are also reported:
+
+```ruby
+  "lhc.<app_name>.<env>.<host>.<http_method>.timeout", 1
+```
+
+All the dots in the host are getting replaced with underscore (_), because dot is the default separator in graphite.
+
+It is also possible to set the key for Monitoring Interceptor on per request basis:
+
+```ruby
+  LHC.get('http://local.ch', monitoring_key: 'local_website')
+
+  "local_website.count", 1
+  "local_website.200", 1
+  "local_website.time", 43
+```
+
+If you use this approach you need to add all namespaces (app, environment etc.) to the key on your own.

data/docs/interceptors/rollbar.md

@@ -0,0 +1,19 @@
+# Rollbar Interceptor
+
+Forward errors to rollbar when exceptions occur during http requests.
+
+```ruby
+  LHC.config.interceptors = [LHC::Rollbar]
+```
+
+```ruby
+  LHC.get('http://local.ch')
+```
+
+If it raises, it forwards the request and response object to rollbar, which contain all necessary data.
+
+## Forward additional parameters
+
+```ruby
+  LHC.get('http://local.ch', rollbar: { tracking_key: 'this particular request' })
+```

data/lhc.gemspec

@@ -7,7 +7,7 @@ require "lhc/version"
 Gem::Specification.new do |s|
   s.name        = "lhc"
   s.version     = LHC::VERSION
-  s.authors     = ['local.ch']
+  s.authors     = ['https://github.com/local-ch/lhc/contributors']
   s.email       = ['ws-operations@local.ch']
   s.homepage    = 'https://github.com/local-ch/lhc'
   s.summary     = 'LocalHttpClient'
@@ -18,18 +18,18 @@ Gem::Specification.new do |s|
                    `git ls-files -- non_rails_spec/*`.split("\n")
   s.require_paths = ['lib']
 
-  s.requirements << 'Ruby >= 1.9.2'
-  s.required_ruby_version = '>= 1.9.2'
+  s.requirements << 'Ruby >= 2.0.0'
+  s.required_ruby_version = '>= 2.0.0'
 
   s.add_dependency 'typhoeus'
-  s.add_dependency 'activesupport', '>= 4.1'
+  s.add_dependency 'activesupport', '>= 4.2'
 
   s.add_development_dependency 'rspec-rails', '>= 3.0.0'
-  s.add_development_dependency 'rails', '~> 4.1.1'
+  s.add_development_dependency 'rails', '~> 4.2'
   s.add_development_dependency 'webmock'
   s.add_development_dependency 'geminabox'
   s.add_development_dependency 'pry'
-  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop', '~> 0.36.0'
   s.add_development_dependency 'rubocop-rspec'
   
   s.license = 'GPL-3'

data/lib/lhc.rb

@@ -14,4 +14,10 @@ module LHC
   end
 end
 
-Gem.find_files('lhc/**/*.rb').sort.each { |path| require path }
+Gem.find_files('lhc/**/*.rb')
+  .sort
+  .each do |path|
+    require path if defined?(Rails) || !File.basename(path).include?('railtie.rb')
+  end
+
+require 'lhc/railtie' if defined?(Rails)

data/lib/lhc/config.rb

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

data/lib/lhc/endpoint.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # An endpoint is an url that leads to a backend resource.
 # The url can also be an url-template.
 class LHC::Endpoint
@@ -20,7 +21,7 @@ class LHC::Endpoint
         else
           find_value(match, params)
         end
-      replacement || raise("Compilation incomplete. Unable to find value for #{match.gsub(':', '')}.")
+      replacement || fail("Compilation incomplete. Unable to find value for #{match.gsub(':', '')}.")
     end
   end
 

data/lib/lhc/interceptor_processor.rb

@@ -15,7 +15,7 @@ class LHC::InterceptorProcessor
     interceptors.each do |interceptor|
       result = interceptor.send(name, target)
       if result.is_a? LHC::Response
-        raise 'Response already set from another interceptor' if @response
+        fail 'Response already set from another interceptor' if @response
         request = target.is_a?(LHC::Request) ? target : target.request
         @response = request.response = result
       end

data/lib/lhc/interceptors/auth.rb

@@ -0,0 +1,33 @@
+class LHC::Auth < LHC::Interceptor
+
+  def before_request(request)
+    options = request.options[:auth] || {}
+    authenticate!(request, options)
+  end
+
+  private
+
+  def authenticate!(request, options)
+    if options[:bearer]
+      bearer_authentication!(request, options)
+    elsif options[:basic]
+      basic_authentication!(request, options)
+    end
+  end
+
+  def basic_authentication!(request, options)
+    auth = options[:basic]
+    credentials = "#{auth[:username]}:#{auth[:password]}"
+    set_authorization_header request, "Basic #{Base64.encode64(credentials).chomp}"
+  end
+
+  def bearer_authentication!(request, options)
+    token = options[:bearer]
+    token = token.call if token.is_a?(Proc)
+    set_authorization_header request, "Bearer #{token}"
+  end
+
+  def set_authorization_header(request, value)
+    request.headers['Authorization'] = value
+  end
+end

data/lib/lhc/interceptors/caching.rb

@@ -0,0 +1,66 @@
+class LHC::Caching < LHC::Interceptor
+  include ActiveSupport::Configurable
+
+  config_accessor :cache, :logger
+
+  CACHE_VERSION = '1'
+
+  # Options forwarded to the cache
+  FORWARDED_OPTIONS = {
+    cache_expires_in: :expires_in,
+    cache_race_condition_ttl: :race_condition_ttl
+  }
+
+  def before_request(request)
+    return unless cache
+    return unless request.options[:cache]
+    cached_response_data = cache.fetch(key(request))
+    return unless cached_response_data
+    logger.info "Served from cache: #{key(request)}" if logger
+    from_cache(request, cached_response_data)
+  end
+
+  def after_response(response)
+    return unless cache
+    request = response.request
+    return if !request.options[:cache] || !response.success?
+    cache.write(key(request), to_cache(response), options(request.options))
+  end
+
+  private
+
+  # converts json we read from the cache to an LHC::Response object
+  def from_cache(request, data)
+    raw = Typhoeus::Response.new(data)
+    request.response = LHC::Response.new(raw, request)
+  end
+
+  # converts a LHC::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]
+    data
+  end
+
+  def key(request)
+    key = request.options[:cache_key]
+    unless key
+      key = "#{request.method.upcase} #{request.url}"
+      key += "?#{request.params.to_query}" unless request.params.blank?
+    end
+    "LHC_CACHE(v#{CACHE_VERSION}): #{key}"
+  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/monitoring.rb

@@ -0,0 +1,61 @@
+class LHC::Monitoring < LHC::Interceptor
+
+  # Options forwarded to the monitoring
+  FORWARDED_OPTIONS = {
+    monitoring_key: :key
+  }
+
+  include ActiveSupport::Configurable
+
+  config_accessor :statsd
+
+  def before_request(request)
+    return unless statsd
+    LHC::Monitoring.statsd.count("#{key(request)}.before_request", 1)
+  end
+
+  def after_request(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(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,
+      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/rollbar.rb

@@ -0,0 +1,26 @@
+class LHC::Rollbar < LHC::Interceptor
+  include ActiveSupport::Configurable
+
+  def after_response(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
+    Rollbar.warning("Status: #{response.code} URL: #{request.url}", data)
+  end
+end

data/lib/lhc/railtie.rb

@@ -0,0 +1,8 @@
+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

data/lib/lhc/request.rb

@@ -108,6 +108,6 @@ class LHC::Request
 
   def throw_error(response)
     error = LHC::Error.find(response)
-    raise error.new(error, response)
+    fail error.new(error, response)
   end
 end

data/lib/lhc/test/cache_helper.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  LHC::Caching.cache = ActiveSupport::Cache::MemoryStore.new
+
+  config.before(:each) do
+    LHC::Caching.cache.clear
+  end
+end

data/lib/lhc/version.rb

@@ -1,3 +1,3 @@
 module LHC
-  VERSION ||= "3.8.1"
+  VERSION ||= "4.0.0"
 end

data/spec/interceptors/auth/basic_auth_spec.rb

@@ -0,0 +1,15 @@
+require 'rails_helper'
+
+describe LHC::Auth do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Auth]
+  end
+
+  it 'adds basic auth to every request' do
+    options = { basic: { username: 'steve', password: 'can' } }
+    LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+    stub_request(:get, 'http://local.ch')
+      .with(headers: { 'Authorization' => 'Basic c3RldmU6Y2Fu' })
+    LHC.get(:local)
+  end
+end

data/spec/interceptors/auth/bearer_spec.rb

@@ -0,0 +1,17 @@
+require 'rails_helper'
+
+describe LHC::Auth do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Auth]
+  end
+
+  it 'adds the bearer token to every request' do
+    def bearer_token
+      '123456'
+    end
+    options = { bearer: -> { bearer_token } }
+    LHC.config.endpoint(:local, 'http://local.ch', auth: options)
+    stub_request(:get, 'http://local.ch').with(headers: { 'Authorization' => 'Bearer 123456' })
+    LHC.get(:local)
+  end
+end

data/spec/interceptors/caching/main_spec.rb

@@ -0,0 +1,60 @@
+require 'rails_helper'
+
+describe LHC::Caching do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Caching]
+    LHC::Caching.cache = Rails.cache
+    Rails.cache.clear
+  end
+
+  let(:stub) { stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website') }
+
+  it 'serves a response from cache' do
+    stub
+    LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_expires_in: 5.minutes)
+    expect(Rails.cache).to receive(:write)
+      .with(
+        "LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): GET http://local.ch",
+        {
+          body: 'The Website',
+          code: 200,
+          headers: nil,
+          return_code: nil
+        }, { expires_in: 5.minutes }
+      )
+      .and_call_original
+    original_response = LHC.get(:local)
+    cached_response = LHC.get(:local)
+    expect(original_response.body).to eq cached_response.body
+    expect(original_response.code).to eq cached_response.code
+    expect(original_response.headers).to eq cached_response.headers
+    expect(original_response.headers).to eq cached_response.headers
+    assert_requested stub, times: 1
+  end
+
+  it 'does not serve from cache if option is not set' do
+    LHC.config.endpoint(:local, 'http://local.ch')
+    expect(Rails.cache).not_to receive(:write)
+    expect(Rails.cache).not_to receive(:fetch)
+    stub
+    2.times { LHC.get(:local) }
+    assert_requested stub, times: 2
+  end
+
+  it 'lets you configure the cache key that will be used' do
+    LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_key: 'STATICKEY')
+    expect(Rails.cache).to receive(:fetch).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY").and_call_original
+    expect(Rails.cache).to receive(:write).with("LHC_CACHE(v#{LHC::Caching::CACHE_VERSION}): STATICKEY", anything, anything).and_call_original
+    stub
+    LHC.get(:local)
+  end
+
+  it 'does not store server errors in cache' do
+    LHC.config.endpoint(:local, 'http://local.ch', cache: true)
+    stub_request(:get, 'http://local.ch').to_return(status: 500, body: 'ERROR')
+    expect { LHC.get(:local) }.to raise_error LHC::ServerError
+    stub
+    expect(Rails.cache).to receive(:write).once
+    LHC.get(:local)
+  end
+end

data/spec/interceptors/caching/parameters_spec.rb

@@ -0,0 +1,22 @@
+require 'rails_helper'
+
+describe LHC::Caching do
+  context 'parameters' do
+    before(:each) do
+      LHC.config.interceptors = [LHC::Caching]
+      Rails.cache.clear
+    end
+
+    it 'considers parameters when writing/reading from cache' do
+      LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_expires_in: 5.minutes)
+      stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website')
+      stub_request(:get, 'http://local.ch?location=zuerich').to_return(status: 200, body: 'The Website for Zuerich')
+      expect(
+        LHC.get(:local).body
+      ).to eq 'The Website'
+      expect(
+        LHC.get(:local, params: { location: 'zuerich' }).body
+      ).to eq 'The Website for Zuerich'
+    end
+  end
+end

data/spec/interceptors/caching/response_status_spec.rb

@@ -0,0 +1,27 @@
+require 'rails_helper'
+
+describe LHC::Caching do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Caching]
+    LHC.config.endpoint(:local, 'http://local.ch', cache: true, cache_expires_in: 5.minutes)
+    Rails.cache.clear
+    # leverage the Typhoeus internal mock attribute in order to get Typhoeus evaluate the return_code
+    # lib/typhoeus/response/status.rb:48
+    allow_any_instance_of(Typhoeus::Response).to receive(:mock).and_return(false)
+  end
+
+  let!(:stub) { stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website') }
+
+  it 'provides the correct response status for responses from cache' do
+    stub
+    # the real request provides the return_code
+    allow_any_instance_of(Typhoeus::Response).to receive(:options)
+      .and_return(code: 200, status_message: '', body: 'The Website', headers: nil, return_code: :ok)
+    response = LHC.get(:local)
+    expect(response.success?).to eq true
+    # the cached response should get it from the cache
+    allow_any_instance_of(Typhoeus::Response).to receive(:options).and_call_original
+    cached_response = LHC.get(:local)
+    expect(cached_response.success?).to eq true
+  end
+end

data/spec/interceptors/caching/to_cache_spec.rb

@@ -0,0 +1,14 @@
+require 'rails_helper'
+
+describe LHC::Caching do
+  context 'to_cache' do
+    it 'returns a marshalable object to store in the cache' do
+      expect do
+        response = Typhoeus::Response.new(headers: { 'Accept' => 'application/json' })
+        Marshal.dump(
+          LHC::Caching.new.send(:to_cache, response)
+        )
+      end.not_to raise_error
+    end
+  end
+end

data/spec/interceptors/monitoring/main_spec.rb

@@ -0,0 +1,82 @@
+require 'rails_helper'
+
+describe LHC::Monitoring do
+  let(:stub) { stub_request(:get, 'http://local.ch').to_return(status: 200, body: 'The Website') }
+  let(:endpoint_configuration) { LHC.config.endpoint(:local, 'http://local.ch') }
+
+  module Statsd
+    def self.count(_path, _value)
+    end
+
+    def self.timing(_path, _value)
+    end
+  end
+
+  before(:each) do
+    LHC.config.interceptors = [LHC::Monitoring]
+    LHC::Monitoring.statsd = Statsd
+    Rails.cache.clear
+    endpoint_configuration
+  end
+
+  it 'does not report anything if no statsd is configured' do
+    stub
+    LHC.get(:local) # and also does not crash ;)
+  end
+
+  context 'statsd configured' do
+    it 'reports trial, response and timing by default ' do
+      stub
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.200', 1)
+      expect(Statsd).to receive(:timing).with('lhc.dummy.test.local_ch.get.time', anything)
+      LHC.get(:local)
+    end
+
+    it 'does not report timing when response failed' do
+      stub_request(:get, 'http://local.ch').to_return(status: 500)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.500', 1)
+      expect(Statsd).not_to receive(:timing)
+      expect { LHC.get(:local) }.to raise_error LHC::ServerError
+    end
+
+    it 'reports timeout instead of status code if response timed out' do
+      stub_request(:get, 'http://local.ch').to_timeout
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.timeout', 1)
+      expect(Statsd).not_to receive(:timing)
+      expect { LHC.get(:local) }.to raise_error LHC::Timeout
+    end
+
+    it 'allows to set the stats key for request' do
+      stub
+      expect(Statsd).to receive(:count).with('defined_key.before_request', 1)
+      expect(Statsd).to receive(:count).with('defined_key.after_request', 1)
+      expect(Statsd).to receive(:count).with('defined_key.count', 1)
+      expect(Statsd).to receive(:count).with('defined_key.200', 1)
+      expect(Statsd).to receive(:timing).with('defined_key.time', anything)
+      LHC.get(:local, monitoring_key: 'defined_key')
+    end
+  end
+
+  context 'without protocol' do
+    let(:endpoint_configuration) { LHC.config.endpoint(:local, 'local.ch') }
+
+    it 'reports trial, response and timing by default ' do
+      stub
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.before_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.after_request', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.count', 1)
+      expect(Statsd).to receive(:count).with('lhc.dummy.test.local_ch.get.200', 1)
+      expect(Statsd).to receive(:timing).with('lhc.dummy.test.local_ch.get.time', anything)
+      LHC.get(:local)
+    end
+  end
+end

data/spec/interceptors/rollbar/main_spec.rb

@@ -0,0 +1,50 @@
+require 'rails_helper'
+
+describe LHC::Rollbar do
+  before(:each) do
+    LHC.config.interceptors = [LHC::Rollbar]
+  end
+
+  it 'does not report if Rollbar is not defined' do
+    stub_request(:get, 'http://local.ch').to_return(status: 400)
+    expect(-> { LHC.get('http://local.ch') })
+      .to raise_error LHC::BadRequest
+  end
+
+  context 'Rollbar is defined' do
+    before(:each) do
+      class Rollbar; end
+      allow(::Rollbar).to receive(:warning)
+    end
+
+    it 'does report errors to rollbar' do
+      stub_request(:get, 'http://local.ch').to_return(status: 400)
+      expect(-> { LHC.get('http://local.ch') })
+        .to raise_error LHC::BadRequest
+      expect(::Rollbar).to have_received(:warning)
+        .with(
+          'Status: 400 URL: http://local.ch',
+          response: hash_including(body: anything, code: anything, headers: anything, time: anything, timeout?: anything),
+          request: hash_including(url: anything, method: anything, headers: anything, params: anything)
+        )
+    end
+
+    context 'additional params' do
+      it 'does report errors to rollbar with additional data' do
+        stub_request(:get, 'http://local.ch')
+          .to_return(status: 400)
+        expect(-> { LHC.get('http://local.ch', rollbar: { additional: 'data' }) })
+          .to raise_error LHC::BadRequest
+        expect(::Rollbar).to have_received(:warning)
+          .with(
+            'Status: 400 URL: http://local.ch',
+            hash_including(
+              response: anything,
+              request: anything,
+              additional: 'data'
+            )
+          )
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -1,4 +1,4 @@
 require 'spec_helper'
-require File.expand_path("../dummy/config/environment", __FILE__)
-
 ENV["RAILS_ENV"] ||= 'test'
+
+require File.expand_path("../dummy/config/environment", __FILE__)

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 require 'pry'
 require 'webmock/rspec'
-require 'lhc'
 
 Dir[File.join(__dir__, "support/**/*.rb")].each { |f| require f }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhc
 version: !ruby/object:Gem::Version
-  version: 3.8.1
+  version: 4.0.0
 platform: ruby
 authors:
-- local.ch
+- https://github.com/local-ch/lhc/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-19 00:00:00.000000000 Z
+date: 2017-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.1.1
+        version: '4.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.1.1
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -112,16 +112,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.36.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.36.0
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +164,10 @@ files:
 - docs/configuration.md
 - docs/exceptions.md
 - docs/interceptors.md
+- docs/interceptors/authentication.md
+- docs/interceptors/caching.md
+- docs/interceptors/monitoring.md
+- docs/interceptors/rollbar.md
 - docs/request.md
 - docs/response.md
 - lhc.gemspec
@@ -181,11 +185,16 @@ files:
 - lib/lhc/formats/json.rb
 - lib/lhc/interceptor.rb
 - lib/lhc/interceptor_processor.rb
+- lib/lhc/interceptors/auth.rb
+- lib/lhc/interceptors/caching.rb
+- lib/lhc/interceptors/monitoring.rb
+- lib/lhc/interceptors/rollbar.rb
+- lib/lhc/railtie.rb
 - lib/lhc/request.rb
 - lib/lhc/response.rb
 - lib/lhc/response/data.rb
+- lib/lhc/test/cache_helper.rb
 - lib/lhc/version.rb
-- non_rails_spec/request/request_spec.rb
 - script/ci/build.sh
 - spec/basic_methods/delete_spec.rb
 - spec/basic_methods/get_spec.rb
@@ -233,6 +242,7 @@ files:
 - spec/dummy/public/422.html
 - spec/dummy/public/500.html
 - spec/dummy/public/favicon.ico
+- spec/dummy/tmp/cache/.gitkeep
 - spec/endpoint/compile_spec.rb
 - spec/endpoint/match_spec.rb
 - spec/endpoint/placeholders_spec.rb
@@ -245,18 +255,27 @@ files:
 - spec/formats/json_spec.rb
 - spec/interceptors/after_request_spec.rb
 - spec/interceptors/after_response_spec.rb
+- spec/interceptors/auth/basic_auth_spec.rb
+- spec/interceptors/auth/bearer_spec.rb
 - spec/interceptors/before_request_spec.rb
 - spec/interceptors/before_response_spec.rb
+- spec/interceptors/caching/main_spec.rb
+- spec/interceptors/caching/parameters_spec.rb
+- spec/interceptors/caching/response_status_spec.rb
+- spec/interceptors/caching/to_cache_spec.rb
 - spec/interceptors/default_interceptors_spec.rb
 - spec/interceptors/define_spec.rb
+- spec/interceptors/monitoring/main_spec.rb
 - spec/interceptors/response_competition_spec.rb
 - spec/interceptors/return_response_spec.rb
+- spec/interceptors/rollbar/main_spec.rb
 - spec/rails_helper.rb
 - spec/request/encoding_spec.rb
 - spec/request/error_handling_spec.rb
 - spec/request/headers_spec.rb
 - spec/request/option_dup_spec.rb
 - spec/request/parallel_requests_spec.rb
+- spec/request/request_without_rails_spec.rb
 - spec/request/url_patterns_spec.rb
 - spec/response/body_spec.rb
 - spec/response/code_spec.rb
@@ -287,16 +306,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- Ruby >= 1.9.2
+- Ruby >= 2.0.0
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: LocalHttpClient
@@ -347,6 +366,7 @@ test_files:
 - spec/dummy/public/422.html
 - spec/dummy/public/500.html
 - spec/dummy/public/favicon.ico
+- spec/dummy/tmp/cache/.gitkeep
 - spec/endpoint/compile_spec.rb
 - spec/endpoint/match_spec.rb
 - spec/endpoint/placeholders_spec.rb
@@ -359,18 +379,27 @@ test_files:
 - spec/formats/json_spec.rb
 - spec/interceptors/after_request_spec.rb
 - spec/interceptors/after_response_spec.rb
+- spec/interceptors/auth/basic_auth_spec.rb
+- spec/interceptors/auth/bearer_spec.rb
 - spec/interceptors/before_request_spec.rb
 - spec/interceptors/before_response_spec.rb
+- spec/interceptors/caching/main_spec.rb
+- spec/interceptors/caching/parameters_spec.rb
+- spec/interceptors/caching/response_status_spec.rb
+- spec/interceptors/caching/to_cache_spec.rb
 - spec/interceptors/default_interceptors_spec.rb
 - spec/interceptors/define_spec.rb
+- spec/interceptors/monitoring/main_spec.rb
 - spec/interceptors/response_competition_spec.rb
 - spec/interceptors/return_response_spec.rb
+- spec/interceptors/rollbar/main_spec.rb
 - spec/rails_helper.rb
 - spec/request/encoding_spec.rb
 - spec/request/error_handling_spec.rb
 - spec/request/headers_spec.rb
 - spec/request/option_dup_spec.rb
 - spec/request/parallel_requests_spec.rb
+- spec/request/request_without_rails_spec.rb
 - spec/request/url_patterns_spec.rb
 - spec/response/body_spec.rb
 - spec/response/code_spec.rb
@@ -389,4 +418,3 @@ test_files:
 - spec/support/reset_config.rb
 - spec/timeouts/no_signal_spec.rb
 - spec/timeouts/timings_spec.rb
-- non_rails_spec/request/request_spec.rb