lhc-core-interceptors 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3d8f1d606680b4dc30c467b4b7dd83cabb19423
+  data.tar.gz: 77ec5ff865484eb71beea6c04dc648d4f8ff4f16
+SHA512:
+  metadata.gz: c9a8c8e363242f90b9ffb3cfb39c5ef95e93a2a9687d7c2accb19deadc6311cc1a65fa8db48d1ed101a5ec46ff3c38d2ca97b8bee643b823ca0bb1ea887ea02d
+  data.tar.gz: 3e419cec01d175b226a222c165170b1f5612fb77f2d155a3a368acbdba32419f722ab751886c88855a80476aa1192436a8621e08d05583c5436ead05e15153d2

data/.gitignore

@@ -0,0 +1,40 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+*.log
+spec/dummy/log/*
+spec/dummy/tmp/cache/*
+Gemfile.lock
+.ruby-gemset
+.ruby-version
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.intra.local.ch/'
+
+# Declare your gem's dependencies in lhc.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.

data/README.md

@@ -0,0 +1,108 @@
+LHC Core Interceptors
+===
+
+The following set of interceptors can be used with [LHC](https://github.com/local-ch/lhc).
+
+## Cache Interceptor
+
+Add the cache interceptor to your basic set of LHC interceptors.
+
+```ruby
+  LHC.config.interceptors = [LHC::Caching]
+```
+
+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
+```
+
+### Cache Interceptor 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.
+
+Set the key that is used for caching by using the `cache_key` option. Every key is prefixed with `LHC_CACHE: `.
+
+Setting `cache_race_condition_ttl` is 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`.
+
+## 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 a response timeouts it is also reporting that.
+
+```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.
+
+
+### Auth Interceptor
+
+Add the auth interceptor to your basic set of LHC interceptors.
+
+```ruby
+  LHC.config.interceptors = [LHC::Auth]
+```
+
+```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`.

data/Rakefile

@@ -0,0 +1,25 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'LHC'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+rescue LoadError
+  # no rspec available
+end
+
+Bundler::GemHelper.install_tasks

data/lhc-core-interceptors.gemspec

@@ -0,0 +1,31 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "lhc-core-interceptors/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "lhc-core-interceptors"
+  s.version     = LHCCoreInterceptors::VERSION
+  s.authors     = ['local.ch']
+  s.email       = ['ws-operations@local.ch']
+  s.homepage    = 'https://github.com/local-ch/lhc-core-interceptors'
+  s.summary     = 'A set of interceptors'
+  s.description = 'A set of useful interceptors to use with LHC (like caching, monitoring etc.)'
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.requirements << 'Ruby >= 1.9.2'
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency 'lhc'
+
+  s.add_development_dependency 'rspec-rails', '>= 3.0.0'
+  s.add_development_dependency 'rails', '>= 4.0.0'
+  s.add_development_dependency 'typhoeus', '>= 0.7.0'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'geminabox'
+  s.add_development_dependency 'pry'
+end

data/lib/lhc-core-interceptors.rb

@@ -0,0 +1,2 @@
+require 'lhc'
+Gem.find_files('lhc-core-interceptors/**/*.rb').sort.each { |path| require path }

data/lib/lhc-core-interceptors/auth.rb

@@ -0,0 +1,11 @@
+class LHC::Auth < LHC::Interceptor
+
+  def before_request(request)
+    options = request.options[:auth] || {}
+    if token = options[:bearer]
+      token = token.call if token.is_a?(Proc)
+      request.headers['Authorization'] = "Bearer #{token}"
+    end
+  end
+
+end

data/lib/lhc-core-interceptors/caching.rb

@@ -0,0 +1,57 @@
+class LHC::Caching < LHC::Interceptor
+
+  # 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 request.options[:cache]
+    cached_response_data = Rails.cache.fetch(key(request))
+    return unless cached_response_data
+    Rails.logger.info "Served from cache: #{key(request)}"
+    from_cache(request, cached_response_data)
+  end
+
+  def after_response(response)
+    request = response.request
+    return if !request.options[:cache] || !response.success?
+    Rails.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
+    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: #{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-core-interceptors/monitoring.rb

@@ -0,0 +1,50 @@
+class LHC::Monitoring < LHC::Interceptor
+
+  # Options forwarded to the monitoring
+  FORWARDED_OPTIONS = {
+    monitoring_key: :key,
+  }
+
+  include ActiveSupport::Configurable
+
+  config_accessor :statsd
+
+  def after_request(request)
+    return unless statsd
+    key = "#{key(request)}.count"
+    LHC::Monitoring.statsd.count(key, 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?
+
+    key = [
+      'lhc',
+      Rails.application.class.parent_name.underscore,
+      Rails.env,
+      URI.parse(request.url).host.gsub(/\./, '_'),
+      request.method
+    ]
+    key.join('.')
+  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-core-interceptors/version.rb

@@ -0,0 +1,3 @@
+module LHCCoreInterceptors
+  VERSION = '1.0.0'
+end

data/spec/auth/bearer_spec.rb

@@ -0,0 +1,19 @@
+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/caching/main_spec.rb

@@ -0,0 +1,53 @@
+require 'rails_helper'
+
+describe LHC::Caching do
+
+  before(:each) do
+    LHC.config.interceptors = [LHC::Caching]
+    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: GET http://local.ch', {body: "The Website", code: 200, headers: 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: STATICKEY').and_call_original
+    expect(Rails.cache).to receive(:write).with('LHC_CACHE: 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/caching/parameters_spec.rb

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