routemaster-drain 2.0.0 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ced68b1893076a1cf8df7899e43afcf468487c74
-  data.tar.gz: 951f8e35d74922de878504e6487f64a689cea6f9
+  metadata.gz: 1f2f159625c82cda6149dd385d892605cbbc5381
+  data.tar.gz: 4355b7da645ddcaed97629f458ea056e037f1c1f
 SHA512:
-  metadata.gz: 9d2be82bf2e1e3f4ad23687ee2a3b9d75ce1f49a9266f04e628da6608b4cdd18db86c06872f1685171d4bb61c98b465046ed75b84d6583dd53cc9edea02b1095
-  data.tar.gz: 12281b606df8070c1d97eee13c14ba75ee33fbbe3adf9c648fec2790e6cf7a2462fee51033c75e0828a16ddf05f4df03b3210c43e490361b7c1e647ef83114a4
+  metadata.gz: 38adf1dbf83ed92e88ba395cb0cd1cded85c9146d9efafe112d290171663ff7f2794440eb56173e1ea20d05ff30c0353320a834a5d0d6c826294d841028fe4da
+  data.tar.gz: 45eac309ef2f3be2339b967b5f46075f1e314a2e07bfe32a1a6b125c4035697872071e4301c644011e4570e61b7676678187a25696e9e4bac18b2b66132ad04e

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+### 2.2.2 (2017-01-10)
+
+- Fix logging for error responses:
+  For unsuccessful responses rescue the raised error and
+  send increment signal to metrics backend
+- Add Telemetry support for requests and responses
+- Add support for PATCH requests. 
+  Invalidate cached response (if any) on PATCH
+
+### 2.0.0 (2016-12-14)
+
+Major upgrade: the gem now includes a high-level HTTP API client.
+
+- Request materialisation, JSON-HAL parsing, and hypermedia link traversal (#6)
+- Surface HTTP errors as exceptions (#8)
+- Various fixes (#7, #9, #10)
+- Testing against multiple versions of Rails (#11)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    routemaster-drain (2.0.0)
+    routemaster-drain (2.2.2)
       faraday (>= 0.9.0)
       faraday_middleware
       hashie
@@ -31,7 +31,7 @@ GEM
     diff-lcs (1.2.5)
     docile (1.1.5)
     dotenv (2.1.1)
-    faraday (0.10.0)
+    faraday (0.10.1)
       multipart-post (>= 1.2, < 3)
     faraday_middleware (0.10.1)
       faraday (>= 0.7.4, < 1.0)
@@ -77,7 +77,7 @@ GEM
       pry (~> 0.10)
     psych (2.2.1)
     public_suffix (2.0.4)
-    rack (1.4.7)
+    rack (1.6.5)
     rack-protection (1.5.3)
       rack
     rack-test (0.6.3)

data/gemfiles/rails_3.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    routemaster-drain (1.1.0)
+    routemaster-drain (2.2.1)
       faraday (>= 0.9.0)
       faraday_middleware
       hashie
@@ -31,6 +31,10 @@ GEM
       activesupport (= 3.2.14)
       builder (~> 3.0.0)
     activerecord (3.2.14)
+      activemodel (= 3.2.14)
+      activesupport (= 3.2.14)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
     activeresource (3.2.14)
       activemodel (= 3.2.14)
       activesupport (= 3.2.14)
@@ -43,6 +47,7 @@ GEM
       bundler
       rake
       thor (>= 0.14.0)
+    arel (3.0.3)
     builder (3.0.4)
     byebug (9.0.6)
     codeclimate-test-reporter (1.0.3)
@@ -108,7 +113,7 @@ GEM
     pry-byebug (3.4.2)
       byebug (~> 9.0)
       pry (~> 0.10)
-    psych (2.2.1)
+    psych (2.2.2)
     public_suffix (2.0.4)
     rack (1.4.7)
     rack-cache (1.6.1)
@@ -191,6 +196,7 @@ GEM
     treetop (1.4.15)
       polyglot
       polyglot (>= 0.3.1)
+    tzinfo (0.3.52)
     vegas (0.1.11)
       rack (>= 1.0.0)
     webmock (2.3.1)

data/gemfiles/rails_4.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    routemaster-drain (1.1.0)
+    routemaster-drain (2.2.1)
       faraday (>= 0.9.0)
       faraday_middleware
       hashie
@@ -110,7 +110,7 @@ GEM
     pry-byebug (3.4.2)
       byebug (~> 9.0)
       pry (~> 0.10)
-    psych (2.2.1)
+    psych (2.2.2)
     public_suffix (2.0.4)
     rack (1.5.5)
     rack-protection (1.5.3)

data/gemfiles/rails_5.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    routemaster-drain (1.1.0)
+    routemaster-drain (2.2.1)
       faraday (>= 0.9.0)
       faraday_middleware
       hashie
@@ -111,7 +111,7 @@ GEM
       mime-types-data (~> 3.2015)
     mime-types-data (3.2016.0521)
     mini_portile2 (2.1.0)
-    minitest (5.9.1)
+    minitest (5.10.1)
     mono_logger (1.1.0)
     multi_json (1.12.1)
     multipart-post (2.0.0)
@@ -130,7 +130,7 @@ GEM
     pry-byebug (3.4.2)
       byebug (~> 9.0)
       pry (~> 0.10)
-    psych (2.2.1)
+    psych (2.2.2)
     public_suffix (2.0.4)
     rack (2.0.1)
     rack-protection (1.5.3)

data/lib/routemaster/api_client.rb

@@ -5,13 +5,21 @@ require 'hashie'
 require 'routemaster/config'
 require 'routemaster/middleware/response_caching'
 require 'routemaster/middleware/error_handling'
+require 'routemaster/middleware/metrics'
+require 'routemaster/responses/future_response'
 
 module Routemaster
   class APIClient
-    def initialize(middlewares: [], listener: nil, response_class: nil)
+    def initialize(middlewares: [],
+                   listener: nil,
+                   response_class: nil,
+                   metrics_client: nil,
+                   source_peer: nil)
       @listener = listener
       @middlewares = middlewares
       @response_class = response_class
+      @metrics_client = metrics_client
+      @source_peer = source_peer
     end
 
     # Performs a GET HTTP request for the `url`, with optional
@@ -27,13 +35,38 @@ module Routemaster
       end
     end
 
+    def fget(url, params: {}, headers: {})
+      Responses::FutureResponse.new { get(url, params: {}, headers: {}) }
+    end
+
     def post(url, body: {}, headers: {})
       host = URI.parse(url).host
       response_wrapper do
         connection.post do |req|
           req.url url
           req.headers = headers.merge(auth_header(host))
-          req.body = body.to_json
+          req.body = body
+        end
+      end
+    end
+
+    def patch(url, body: {}, headers: {})
+      host = URI.parse(url).host
+      response_wrapper do
+        connection.patch do |req|
+          req.url url
+          req.headers = headers.merge(auth_header(host))
+          req.body = body
+        end
+      end
+    end
+
+    def delete(url, headers: {})
+      host = URI.parse(url).host
+      response_wrapper do
+        connection.delete do |req|
+          req.url url
+          req.headers = headers.merge(auth_header(host))
         end
       end
     end
@@ -56,6 +89,7 @@ module Routemaster
         f.response :mashify
         f.response :json, content_type: /\bjson/
         f.use Routemaster::Middleware::ResponseCaching, listener: @listener
+        f.use Routemaster::Middleware::Metrics, client: @metrics_client, source_peer: @source_peer
         f.adapter  :net_http_persistent
         f.use Routemaster::Middleware::ErrorHandling
 

data/lib/routemaster/cache.rb

@@ -1,9 +1,4 @@
 require 'routemaster/api_client'
-require 'thread/pool'
-require 'thread/future'
-require 'singleton'
-require 'delegate'
-require 'json'
 require 'wisper'
 
 module Routemaster
@@ -21,47 +16,8 @@ module Routemaster
   class Cache
     include Wisper::Publisher
 
-    # A pool of threads, used for parallel/future request processing.
-    class Pool < SimpleDelegator
-      include Singleton
-
-      def initialize
-        Thread.pool(5, 20).tap do |p|
-          # TODO: configurable pool size and trim timeout?
-          p.auto_trim!
-          p.idle_trim! 10 # 10 seconds
-          super p
-        end
-      end
-    end
-
-    # Wraps a future response, so it quacks exactly like an ordinary response.
-    class FutureResponse
-      extend Forwardable
-
-      # The `block` is expected to return a {Response}
-      def initialize(&block)
-        @future = Pool.instance.future(&block)
-      end
-
-      # @!attribute status
-      # @return [Integer]
-      # Delegated to the `block`'s return value.
-
-      # @!attribute headers
-      # @return [Hash]
-      # Delegated to the `block`'s return value.
-
-      # @!attribute body
-      # @return [Hashie::Mash]
-      # Delegated to the `block`'s return value.
-
-      delegate :value => :@future
-      delegate %i(status headers body) => :value
-    end
-
-    def initialize(redis:nil, client:nil)
-      @redis   = redis || Config.cache_redis
+    def initialize(redis: nil, client: nil)
+      @redis  = redis || Config.cache_redis
       @client = client || APIClient.new(listener: self)
     end
 
@@ -87,13 +43,7 @@ module Routemaster
     #
     # @return [Response], which responds to `status`, `headers`, and `body`.
     def get(url, version: nil, locale: nil)
-      headers = {
-        'Accept' => version ?
-          "application/json;v=#{version}" :
-          "application/json"
-      }
-      headers['Accept-Language'] = locale if locale
-      @client.get(url, headers: headers)
+      @client.get(url, headers: headers(version: version, locale: locale))
     end
 
     # Like {#get}, but schedules any request in the background using a thread
@@ -102,7 +52,16 @@ module Routemaster
     # @return [FutureResponse], which responds to `status`, `headers`, and `body`
     # like [Response].
     def fget(url, version: nil, locale: nil)
-      FutureResponse.new { get(url, version: version, locale: locale) }
+      @client.fget(url, headers: headers(version: version, locale: locale))
+    end
+
+    private
+
+    def headers(version: nil, locale: nil)
+      @headers ||= {}.tap do |hash|
+        hash['Accept'] = version ? "application/json;v=#{version}" : "application/json"
+        hash['Accept-Language'] = locale if locale
+      end
     end
   end
 end

data/lib/routemaster/drain.rb

@@ -1,5 +1,5 @@
 module Routemaster
   module Drain
-    VERSION = '2.0.0'
+    VERSION = '2.2.2'
   end
 end

data/lib/routemaster/errors.rb

@@ -9,7 +9,7 @@ module Routemaster
       end
 
       def errors
-        body['errors']
+        body.fetch('errors', {})
       end
 
       def message
@@ -27,44 +27,44 @@ module Routemaster
       end
     end
 
-    class UnauthorizedResourceAccessError < BaseError
+    class UnauthorizedResourceAccess < BaseError
       def message
         "Unauthorized Resource Access Error"
       end
     end
 
-    class InvalidResourceError < BaseError
+    class InvalidResource < BaseError
       def message
         "Invalid Resource Error"
       end
     end
 
-    class ResourceNotFoundError < BaseError
+    class ResourceNotFound < BaseError
       def message
         "Resource Not Found Error"
       end
     end
 
-    class FatalResourceError < BaseError
+    class FatalResource < BaseError
       def message
         "Fatal Resource Error. body: #{body}, url: #{env.url}, method: #{env.method}"
       end
     end
 
-    class ConflictResourceError < BaseError
+    class ConflictResource < BaseError
       def message
         "ConflictResourceError Resource Error"
       end
     end
 
-    class IncompatibleVersionError < BaseError
+    class IncompatibleVersion < BaseError
       def message
         headers = env.request_headers.select { |k, _| k != 'Authorization' }
         "Incompatible Version Error. headers: #{headers}, url: #{env.url}, method: #{env.method}"
       end
     end
 
-    class ResourceThrottlingError < BaseError
+    class ResourceThrottling < BaseError
       def message
         "Resource Throttling Error"
       end

data/lib/routemaster/middleware/error_handling.rb

@@ -5,15 +5,15 @@ module Routemaster
   module Middleware
     class ErrorHandling < Faraday::Response::Middleware
       ERRORS_MAPPING = {
-        (400..400) => Errors::InvalidResourceError,
-        (401..401) => Errors::UnauthorizedResourceAccessError,
-        (403..403) => Errors::UnauthorizedResourceAccessError,
-        (404..404) => Errors::ResourceNotFoundError,
-        (409..409) => Errors::ConflictResourceError,
-        (412..412) => Errors::IncompatibleVersionError,
-        (413..413) => Errors::InvalidResourceError,
-        (429..429) => Errors::ResourceThrottlingError,
-        (407..500) => Errors::FatalResourceError
+        (400..400) => Errors::InvalidResource,
+        (401..401) => Errors::UnauthorizedResourceAccess,
+        (403..403) => Errors::UnauthorizedResourceAccess,
+        (404..404) => Errors::ResourceNotFound,
+        (409..409) => Errors::ConflictResource,
+        (412..412) => Errors::IncompatibleVersion,
+        (413..413) => Errors::InvalidResource,
+        (429..429) => Errors::ResourceThrottling,
+        (407..500) => Errors::FatalResource
       }.freeze
 
       def on_complete(env)

data/lib/routemaster/middleware/metrics.rb

@@ -0,0 +1,71 @@
+module Routemaster
+  module Middleware
+    class Metrics
+      INTERACTION_KEY = 'api_client'.freeze
+
+      def initialize(app, client: nil, source_peer: nil)
+        @app    = app
+        @client = client
+        @source_peer = source_peer
+      end
+
+      def call(request_env)
+        return @app.call(request_env) unless can_log?
+
+        increment_req_count(request_tags(request_env))
+
+        record_latency(request_tags(request_env)) do
+          begin
+            @app.call(request_env).on_complete do |response_env|
+              increment_response_count(response_tags(response_env))
+            end
+          rescue Routemaster::Errors::BaseError => e
+            increment_response_count(response_tags(e.env))
+            raise e
+          end
+        end
+      end
+
+      private
+
+      attr_reader :client, :source_peer
+
+      def increment_req_count(tags)
+        client.increment("#{INTERACTION_KEY}.request.count", tags: tags)
+      end
+
+      def increment_response_count(tags)
+        client.increment("#{INTERACTION_KEY}.response.count", tags: tags)
+      end
+
+      def record_latency(tags, &block)
+        client.time("#{INTERACTION_KEY}.latency", tags: tags) do
+          block.call
+        end
+      end
+
+      def can_log?
+        client && source_peer
+      end
+
+      def destination_peer(env)
+        env.url.host
+      end
+
+      def peers_tags(env)
+        [
+          "source:#{source_peer}",
+          "destination:#{destination_peer(env)}"
+        ]
+      end
+
+      def request_tags(env)
+        peers_tags(env).concat(["verb:#{env.method}"])
+      end
+
+      def response_tags(env)
+        peers_tags(env).concat(["status:#{env.status}"])
+      end
+    end
+  end
+end

data/lib/routemaster/middleware/response_caching.rb

@@ -16,7 +16,8 @@ module Routemaster
       end
 
       def call(env)
-        return @app.call(env) unless env.method == :get
+        @cache.del(cache_key(env)) if %i(patch delete).include?(env.method)
+        return @app.call(env) if env.method != :get
 
         fetch_from_cache(env) || fetch_from_service(env)
       end

data/lib/routemaster/resources/rest_resource.rb

@@ -21,6 +21,14 @@ module Routemaster
       def index
         @client.get(@url)
       end
+
+      def update(id=nil, params)
+        @client.patch(@url.gsub('{id}', id.to_s), body: params)
+      end
+
+      def destroy(id=nil)
+        @client.delete(@url.gsub('{id}', id.to_s))
+      end
     end
   end
 end

data/lib/routemaster/responses/future_response.rb

@@ -0,0 +1,46 @@
+require 'thread/pool'
+require 'thread/future'
+require 'singleton'
+require 'delegate'
+
+module Routemaster
+  module Responses
+    # A pool of threads, used for parallel/future request processing.
+    class Pool < SimpleDelegator
+      include Singleton
+
+      def initialize
+        Thread.pool(5, 20).tap do |p|
+          # TODO: configurable pool size and trim timeout?
+          p.auto_trim!
+          p.idle_trim! 10 # 10 seconds
+          super p
+        end
+      end
+    end
+
+    class FutureResponse
+      extend Forwardable
+
+      # The `block` is expected to return a {Response}
+      def initialize(&block)
+        @future = Pool.instance.future(&block)
+      end
+
+      # @!attribute status
+      # @return [Integer]
+      # Delegated to the `block`'s return value.
+
+      # @!attribute headers
+      # @return [Hash]
+      # Delegated to the `block`'s return value.
+
+      # @!attribute body
+      # @return [Hashie::Mash]
+      # Delegated to the `block`'s return value.
+
+      delegate :value => :@future
+      delegate %i(status headers body) => :value
+    end
+  end
+end

data/lib/routemaster/responses/hateoas_response.rb

@@ -26,7 +26,7 @@ module Routemaster
           unless respond_to?(method_name)
             resource = Resources::RestResource.new(_links[normalized_method_name]['href'], client: @client)
 
-            self.class.send(:define_method, method_name) do |*m_args|
+            define_singleton_method(method_name) do |*m_args|
               resource
             end
 

data/spec/routemaster/api_client_spec.rb

@@ -32,6 +32,14 @@ describe Routemaster::APIClient do
           'content-type' => 'application/json;v=1'
         }
       )
+
+      @patch_req = stub_request(:patch, /example\.com/).to_return(
+        status:   200,
+        body:     { id: 132, type: 'widget' }.to_json,
+        headers:  {
+          'content-type' => 'application/json;v=1'
+        }
+      )
     end
 
     it 'GETs from the URL' do
@@ -48,6 +56,15 @@ describe Routemaster::APIClient do
       end
     end
 
+    context 'PATCH request' do
+      subject { fetcher.patch(url, body: {}, headers: headers) }
+
+      it 'PATCH from the URL' do
+        subject
+        expect(@patch_req).to have_been_requested
+      end
+    end
+
     it 'has :status, :headers, :body' do
       expect(subject.status).to eq(200)
       expect(subject.headers).to have_key('content-type')

data/spec/routemaster/cache_spec.rb

@@ -70,12 +70,6 @@ module Routemaster
       it_behaves_like 'a GET request'
     end
 
-    describe '#fget' do
-      let(:perform) { subject.fget(url, **options) }
-
-      it_behaves_like 'a GET request'
-    end
-
     describe '#bust' do
       let(:cache)   { Config.cache_redis }
       let(:perform) { subject.bust(url) }

data/spec/routemaster/integration/api_client_spec.rb

@@ -5,6 +5,14 @@ require 'routemaster/api_client'
 require 'webrick'
 
 RSpec.describe 'Api client integration specs' do
+  module WEBrick
+    module HTTPServlet
+      class ProcHandler
+        alias do_PATCH do_GET
+      end
+    end
+  end
+
   uses_dotenv
   uses_redis
 
@@ -17,6 +25,11 @@ RSpec.describe 'Api client integration specs' do
           res.body = { field: 'test' }.to_json
         end
       end
+
+      server.mount_proc "/success" do |req, res|
+        res.status = 200
+        res.body = { field: 'test' }.to_json
+      end
     end
   end
 
@@ -37,40 +50,143 @@ RSpec.describe 'Api client integration specs' do
   let(:host) { 'http://localhost:8000' }
 
   describe 'error handling' do
-    it 'raises an ResourceNotFoundError on 404' do
-      expect { subject.get(host + '/404') }.to raise_error(Routemaster::Errors::ResourceNotFoundError)
+    it 'raises an ResourceNotFound on 404' do
+      expect { subject.get(host + '/404') }.to raise_error(Routemaster::Errors::ResourceNotFound)
+    end
+
+    it 'raises an InvalidResource on 400' do
+      expect { subject.get(host + '/400') }.to raise_error(Routemaster::Errors::InvalidResource)
+    end
+
+    it 'raises an UnauthorizedResourceAccess on 401' do
+      expect { subject.get(host + '/401') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccess)
+    end
+
+    it 'raises an UnauthorizedResourceAccess on 403' do
+      expect { subject.get(host + '/403') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccess)
     end
 
-    it 'raises an InvalidResourceError on 400' do
-      expect { subject.get(host + '/400') }.to raise_error(Routemaster::Errors::InvalidResourceError)
+    it 'raises an ConflictResource on 409' do
+      expect { subject.get(host + '/409') }.to raise_error(Routemaster::Errors::ConflictResource)
     end
 
-    it 'raises an UnauthorizedResourceAccessError on 401' do
-      expect { subject.get(host + '/401') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccessError)
+    it 'raises an IncompatibleVersion on 412' do
+      expect { subject.get(host + '/412') }.to raise_error(Routemaster::Errors::IncompatibleVersion)
+    end
+
+    it 'raises an InvalidResource on 413' do
+      expect { subject.get(host + '/413') }.to raise_error(Routemaster::Errors::InvalidResource)
+    end
+
+    it 'raises an ResourceThrottling on 429' do
+      expect { subject.get(host + '/429') }.to raise_error(Routemaster::Errors::ResourceThrottling)
+    end
+
+    it 'raises an FatalResource on 500' do
+      expect { subject.get(host + '/500') }.to raise_error(Routemaster::Errors::FatalResource)
+    end
+  end
+
+  describe 'Future GET request' do
+    let(:body_cache_keys) { ["cache:#{url}", "v:,l:,body"] }
+    let(:headers_cache_keys) { ["cache:#{url}", "v:,l:,headers"] }
+    let(:url) { "#{host}/success" }
+
+    context 'when there is a previous cached resource' do
+      let(:cache) { Routemaster::Config.cache_redis }
+
+      it 'returns the response from within the future' do
+        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be_nil
+
+        future = subject.fget(url)
+        expect(future).to be_an_instance_of(Routemaster::Responses::FutureResponse)
+
+        future.value
+        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
+      end
     end
+  end
+
+  describe 'PATCH request' do
+    let(:body_cache_keys) { ["cache:#{url}", "v:,l:,body"] }
+    let(:headers_cache_keys) { ["cache:#{url}", "v:,l:,headers"] }
+    let(:url) { "#{host}/success" }
+
+    context 'when there is a previous cached resource' do
+      before { subject.get(url) }
+      let(:cache) { Routemaster::Config.cache_redis }
 
-    it 'raises an UnauthorizedResourceAccessError on 403' do
-      expect { subject.get(host + '/403') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccessError)
+      it 'invalidates the cache on update' do
+        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
+        subject.patch(url, body: {})
+
+        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be_nil
+
+        subject.get(url)
+        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
+      end
     end
+  end
+
+  describe 'DELETE request' do
+    let(:body_cache_keys) { ["cache:#{url}", "v:,l:,body"] }
+    let(:headers_cache_keys) { ["cache:#{url}", "v:,l:,headers"] }
+    let(:url) { "#{host}/success" }
+
+    context 'when there is a previous cached resource' do
+      before { subject.get(url) }
+      let(:cache) { Routemaster::Config.cache_redis }
 
-    it 'raises an ConflictResourceError on 409' do
-      expect { subject.get(host + '/409') }.to raise_error(Routemaster::Errors::ConflictResourceError)
+      it 'invalidates the cache on destroy' do
+        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
+        subject.delete(url)
+
+        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be_nil
+
+        subject.get(url)
+        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
+      end
     end
+  end
+
+  describe 'Telemetry' do
+    let(:metrics_client) { double('MetricsClient') }
+    let(:source_peer) { 'test_service' }
+    let(:url) { "#{host}/success" }
 
-    it 'raises an IncompatibleVersionError on 412' do
-      expect { subject.get(host + '/412') }.to raise_error(Routemaster::Errors::IncompatibleVersionError)
+    subject do
+      Routemaster::APIClient.new(metrics_client: metrics_client,
+                                 source_peer: source_peer)
     end
 
-    it 'raises an InvalidResourceError on 413' do
-      expect { subject.get(host + '/413') }.to raise_error(Routemaster::Errors::InvalidResourceError)
+    context 'when metrics source peer is absent' do
+      subject { Routemaster::APIClient.new(metrics_client: metrics_client) }
+
+      it 'does not send metrics' do
+        expect(metrics_client).to receive(:increment).never
+        subject.get(url)
+      end
     end
 
-    it 'raises an ResourceThrottlingError on 429' do
-      expect { subject.get(host + '/429') }.to raise_error(Routemaster::Errors::ResourceThrottlingError)
+    it 'does send request metrics' do
+      allow(metrics_client).to receive(:time).and_yield
+      allow(metrics_client).to receive(:increment)
+      expected_req_count_tags = ["source:test_service", "destination:localhost", "verb:get"]
+
+      expect(metrics_client).to receive(:increment).with('api_client.request.count', tags: expected_req_count_tags)
+
+      subject.get(url)
     end
 
-    it 'raises an FatalResourceError on 500' do
-      expect { subject.get(host + '/500') }.to raise_error(Routemaster::Errors::FatalResourceError)
+    it 'does send response metrics' do
+      allow(metrics_client).to receive(:increment)
+      expected_res_count_tags = ["source:test_service", "destination:localhost", "status:200"]
+      expected_latency_tags = ["source:test_service", "destination:localhost", "verb:get"]
+
+      expect(metrics_client).to receive(:increment).with('api_client.response.count', tags: expected_res_count_tags)
+      expect(metrics_client).to receive(:time).with('api_client.latency', tags: expected_latency_tags).and_yield
+
+      subject.get(url)
     end
   end
 end

data/spec/routemaster/integration/cache_spec.rb

@@ -58,9 +58,7 @@ RSpec.describe 'Requests with caching' do
     end
 
     context 'when there is a previous cached response' do
-      before do
-        subject.get(url)
-      end
+      before { subject.get(url) }
 
       it 'fetches the cached response' do
         expect(subject.get(url).body).to eq({ field: 'test' }.to_json)

data/spec/routemaster/resources/rest_resource_spec.rb

@@ -30,6 +30,20 @@ module Routemaster
           subject.index
         end
       end
+
+      describe '#update' do
+        it 'updates the given resource' do
+          expect(client).to receive(:patch).with(url, body: params)
+          subject.update(1, params)
+        end
+      end
+
+      describe '#destroy' do
+        it 'destroys the given resource' do
+          expect(client).to receive(:delete).with(url)
+          subject.destroy(1)
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: routemaster-drain
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.2
 platform: ruby
 authors:
 - Julien Letessier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-14 00:00:00.000000000 Z
+date: 2017-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -137,6 +137,7 @@ files:
 - ".travis.yml"
 - ".yardopts"
 - Appraisals
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - Guardfile
@@ -172,11 +173,13 @@ files:
 - lib/routemaster/middleware/dirty.rb
 - lib/routemaster/middleware/error_handling.rb
 - lib/routemaster/middleware/filter.rb
+- lib/routemaster/middleware/metrics.rb
 - lib/routemaster/middleware/parse.rb
 - lib/routemaster/middleware/response_caching.rb
 - lib/routemaster/middleware/root_post_only.rb
 - lib/routemaster/redis_broker.rb
 - lib/routemaster/resources/rest_resource.rb
+- lib/routemaster/responses/future_response.rb
 - lib/routemaster/responses/hateoas_response.rb
 - routemaster-drain.gemspec
 - spec/routemaster/api_client_spec.rb