px-service-client 1.0.1 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af7a7e8bbce817e251279c1a31fe9737e05d7d2d
-  data.tar.gz: deef44499ba41a91b75c2d1efbf4a55568a5fa62
+  metadata.gz: 31469d2437619f1f3afec21f42201aa2054ade9b
+  data.tar.gz: 55491249709bd72ab3e90fa9648cb72dee46880b
 SHA512:
-  metadata.gz: 7caf92bd8294aafe32fa12de6c5328d51960cee2c19c93ea42dd48a335778d13b83fa34b44e05a58a879f5720deb0954b0c6b5cfe6a84c1a8496752b46cfc60a
-  data.tar.gz: cc7781a37f252033c1e585d31e6eb125fc1c5bda0f15c7396a3de44ca767cfc91aff3fa6f2e280d48088220c3df459022464a5db30c6d98c4df0317ce7d4408e
+  metadata.gz: bb3b61faa7e47e838f45db03731effe82ef5c92ca109878bd592ab80869ab8a00706c611dd586d253078cd9c01b48ae28dda04fd650c71a1cfdefe2dafd8419d
+  data.tar.gz: b86dff5d8658f923ae59494edc8314dd2eb371b2e4757ace908598a106c084f4c02ffa878cd05a882bbcc4056df4cbd7f93335d03f67de75b25aaef6415c9bfd

data/README.md

@@ -24,8 +24,8 @@ Then use it:
 require 'px-service-client'
 
 class MyClient
-  include Px::Service::Client::::Caching
-  include Px::Service::Client::::CircuitBreaker
+  include Px::Service::Client::Caching
+  include Px::Service::Client::CircuitBreaker
 end
 
 ```
@@ -37,10 +37,10 @@ This gem includes several common features used in 500px service client libraries
 
 The features are:
 
-#### Px::Service::Client::::Caching
+#### Px::Service::Client::Caching
 
 ```ruby
-include Px::Service::Client::::Caching
+include Px::Service::Client::Caching
 
 self.cache_client =  Dalli::Client.new(...)
 self.cache_logger = Logger.new(STDOUT) # or Rails.logger, for example
@@ -55,13 +55,9 @@ to be refreshed probabilistically (rather than on every request).
 *first-resort* means that the cached value is always used, if present.  Requests to the service are only made
 when the cached value is close to expiry.
 
-#### Px::Service::Client::::CircuitBreaker
+#### Px::Service::Client::CircuitBreaker
 
 ```ruby
-def call_remote_service() ...
-
-circuit_method :call_remote_service
-
 # Optional
 circuit_handler do |handler|
  handler.logger = Logger.new(STDOUT)
@@ -72,25 +68,21 @@ circuit_handler do |handler|
 end
 ```
 
-Provides a circuit breaker on the class, and turns the class into a singleton.  Each method named using
-`circuit_method` will be wrapped in a circuit breaker that will raise a `Px::Service::ServiceError` if the breaker
-is open.  The circuit will open on any exception from the wrapped method, or if the wrapped method
-runs for longer than the `invocation_timeout`.
+Adds a circuit breaker to the client.  The circuit will open on any exception from the wrapped method, or if the request runs for longer than the `invocation_timeout`.
 
-Note that `Px::Service::ServiceRequestError` exceptions do NOT trip the breaker, as these exceptions indicate an error
-on the caller's part (e.g. an HTTP 4xx error).
+Note that `Px::Service::ServiceRequestError` exceptions do NOT trip the breaker, as these exceptions indicate an error on the caller's part (e.g. an HTTP 4xx error).
 
-The class is made a singleton using the standard `Singleton` module.  Access to the class's methods should be done
-using its `instance` class method (calls to `new` will fail).
+Every instance of the class that includes the `CircuitBreaker` concern will share the same circuit state.  You should therefore include `Px::Service::Client::CircuitBreaker` in the most-derived class that subclasses
+`Px::Service::Client::Base`
 
 This module is based on (and uses) the [Circuit Breaker](https://github.com/wsargent/circuit_breaker) gem by Will Sargent.
 
-#### Px::Service::Client::::ListResponse
+#### Px::Service::Client::ListResponse
 
 ```ruby
   def get_something(page, page_size)
     response = JSON.parse(http_get("http://some/url?p=#{page}&l=#{page_size}"))
-    return Px::Service::Client::::ListResponse(page_size, response, "items")
+    return Px::Service::Client::ListResponse(page_size, response, "items")
   end
 
 ```

data/lib/px/service/client/base.rb

@@ -1,7 +1,6 @@
 module Px::Service::Client
   class Base
     include Px::Service::Client::Caching
-    include Px::Service::Client::CircuitBreaker
     cattr_accessor :logger
 
     private
@@ -18,13 +17,16 @@ module Px::Service::Client
       end
     end
 
-    def make_request(method, uri, query: nil, headers: nil, body: nil)
+    ##
+    # Make the request
+    def make_request(method, uri, query: nil, headers: nil, body: nil, timeout: 0)
       req = Typhoeus::Request.new(
         uri,
         method: method,
         params: query,
         body: body,
-        headers: headers)
+        headers: headers,
+        timeout: timeout)
 
       start_time = Time.now
       logger.debug "Making request #{method.to_s.upcase} #{uri}" if logger
@@ -36,6 +38,5 @@ module Px::Service::Client
 
       RetriableResponseFuture.new(req)
     end
-
   end
 end

data/lib/px/service/client/circuit_breaker.rb

@@ -3,10 +3,9 @@ require 'circuit_breaker'
 module Px::Service::Client
   module CircuitBreaker
     extend ActiveSupport::Concern
+    include ::CircuitBreaker
 
     included do
-      include ::CircuitBreaker
-
       # Default circuit breaker configuration.  Can be overridden
       circuit_handler do |handler|
         handler.failure_threshold = 5
@@ -15,33 +14,49 @@ module Px::Service::Client
         handler.excluded_exceptions = [Px::Service::ServiceRequestError]
       end
 
-      class <<self
-        alias_method_chain :circuit_method, :exceptions
+      cattr_accessor :circuit_state do
+        ::CircuitBreaker::CircuitState.new
       end
-    end
 
+      alias_method_chain :make_request, :breaker
+    end
 
-    module ClassMethods
-      ##
-      # Takes a splat of method names, and wraps them with the circuit_handler.
-      # Overrides the circuit_method provided by ::CircuitBreaker
-      def circuit_method_with_exceptions(*methods)
-        circuit_handler = self.circuit_handler
-
-        methods.each do |meth|
-          m = instance_method(meth)
-          define_method(meth) do |*args|
-            begin
-              circuit_handler.handle(self.circuit_state, m.bind(self), *args)
-            rescue Px::Service::ServiceError, Px::Service::ServiceRequestError => ex
-              raise ex
-            rescue StandardError => ex
-              # Wrap other exceptions, includes CircuitBreaker::CircuitBrokenException
-              raise Px::Service::ServiceError.new(ex.message, 503), ex, ex.backtrace
-            end
+    ##
+    # Make the request, respecting the circuit breaker, if configured
+    def make_request_with_breaker(method, uri, query: nil, headers: nil, body: nil)
+      Future.new do
+        state = self.class.circuit_state
+        handler = self.class.circuit_handler
+        
+        if handler.is_tripped(state)
+          handler.logger.debug("handle: breaker is tripped, refusing to execute: #{state}") if handler.logger
+          begin
+            handler.on_circuit_open(state)
+          rescue StandardError => ex
+            # Wrap and reroute other exceptions, includes CircuitBreaker::CircuitBrokenException
+            raise Px::Service::ServiceError.new(ex.message, 503), ex, ex.backtrace
           end
         end
+
+        begin
+          response = make_request_without_breaker(
+            method,
+            uri,
+            query: query,
+            headers: headers,
+            body: body,
+            timeout: handler.invocation_timeout)
+
+          result = response.value!
+          handler.on_success(state)
+
+          result
+        rescue Px::Service::ServiceError
+          handler.on_failure(state)
+          raise
+        end
       end
     end
+
   end
 end

data/lib/px/service/client/future.rb

@@ -56,6 +56,17 @@ module Px::Service::Client
       end
     end
 
+    def value!
+      if @completed
+        result = @value
+      else
+        result = wait_for_value(nil)
+      end
+      raise result if result.kind_of?(Exception)
+
+      result
+    end
+
     def completed?
       @completed
     end

data/lib/px/service/client/version.rb

@@ -1,7 +1,7 @@
 module Px
   module Service
     module Client
-      VERSION = "1.0.1"
+      VERSION = "1.0.4"
     end
   end
 end

data/px-service-client.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "webmock"
+  spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "vcr"
   spec.add_development_dependency "guard"

data/spec/px/service/client/circuit_breaker_spec.rb

@@ -1,11 +1,17 @@
 require 'spec_helper'
 
 describe Px::Service::Client::CircuitBreaker do
-
   let(:subject_class) {
-    Class.new.include(Px::Service::Client::CircuitBreaker).tap do |c|
+    Class.new do
+      def make_request(method, uri, query: nil, headers: nil, body: nil, timeout: 0)
+        Px::Service::Client::Future.new do
+          _result
+        end
+      end
+    end.tap do |c|
       # Anonymous classes don't have a name.  Stub out :name so that things work
       allow(c).to receive(:name).and_return("CircuitBreaker")
+      c.include(Px::Service::Client::CircuitBreaker)
     end
   }
 
@@ -29,85 +35,171 @@ describe Px::Service::Client::CircuitBreaker do
     end
   end
 
-  describe '#circuit_method' do
-    context "when the wrapped method succeeds" do
+  describe '#make_request' do
+    context "when the underlying request method succeeds" do
       before :each do
-        subject_class.send(:define_method, :test_method) do |arg|
-          "returned #{arg}"
+        subject_class.send(:define_method, :_result) do
+          "returned test"
         end
+      end
 
-        subject_class.circuit_method(:test_method)
+      it "returns a Future" do
+        expect(subject.make_request(:get, "http://test")).to be_a_kind_of(Px::Service::Client::Future)
       end
 
       it "returns the return value" do
-        expect(subject.test_method("test")).to eq("returned test")
+        expect(subject.make_request(:get, "http://test").value!).to eq("returned test")
+      end
+
+      context "when the breaker is open" do
+        before :each do
+          allow(subject_class.circuit_handler).to receive(:is_timeout_exceeded).and_return(true)
+
+          subject.circuit_state.trip
+          subject.circuit_state.last_failure_time = Time.now
+          subject.circuit_state.failure_count = 5
+        end
+
+        it "resets the failure count of the breaker" do
+          expect {
+            subject.make_request(:get, "http://test").value!
+          }.to change{subject.class.circuit_state.failure_count}.to(0)
+        end
+
+        it "closes the breaker" do
+          expect {
+            subject.make_request(:get, "http://test").value!
+          }.to change{subject.class.circuit_state.closed?}.from(false).to(true)
+        end
       end
     end
 
     context "when the wrapped method fails with a ServiceRequestError" do
       before :each do
-        subject_class.send(:define_method, :test_method) do |arg|
+        subject_class.send(:define_method, :_result) do
           raise Px::Service::ServiceRequestError.new("Error", 404)
         end
-
-        subject_class.circuit_method(:test_method)
       end
 
       it "raises a ServiceRequestError" do
-        expect{
-          subject.test_method("test")
+        expect {
+          subject.make_request(:get, "http://test").value!
         }.to raise_error(Px::Service::ServiceRequestError, "Error")
       end
+
+      it "does not increment the failure count of the breaker" do
+        expect {
+          subject.make_request(:get, "http://test").value! rescue nil
+        }.not_to change{subject.class.circuit_state.failure_count}
+      end
     end
 
     context "when the wrapped method fails with a ServiceError" do
       before :each do
-        subject_class.send(:define_method, :test_method) do |arg|
+        subject_class.send(:define_method, :_result) do
           raise Px::Service::ServiceError.new("Error", 500)
         end
-
-        subject_class.circuit_method(:test_method)
       end
 
       it "raises a ServiceError" do
-        expect{
-          subject.test_method("test")
+        expect {
+          subject.make_request(:get, "http://test").value!
         }.to raise_error(Px::Service::ServiceError, "Error")
       end
+
+      it "increments the failure count of the breaker" do
+        expect {
+          subject.make_request(:get, "http://test").value! rescue nil
+        }.to change{subject.class.circuit_state.failure_count}.by(1)
+      end
     end
 
-    context "when the wrapped method fails with another exception" do
+    context "when the circuit is open" do
       before :each do
-        subject_class.send(:define_method, :test_method) do |arg|
-          this_is_not_a_method # Raises NoMethodError
+        subject_class.send(:define_method, :_result) do
+          "should not be called"
         end
 
-        subject_class.circuit_method(:test_method)
+        subject.circuit_state.trip
+        subject.circuit_state.last_failure_time = Time.now
       end
 
       it "raises a ServiceError" do
-        expect{
-          subject.test_method("test")
+        expect {
+          subject.make_request(:get, "http://test").value!
         }.to raise_error(Px::Service::ServiceError)
       end
     end
 
-    context "when the circuit is open" do
+    context "with multiple classes" do
+      let(:other_class) {
+        Class.new do
+          def make_request(method, uri, query: nil, headers: nil, body: nil, timeout: 0)
+            Px::Service::Client::Future.new do
+              "result"
+            end
+          end
+        end.tap do |c|
+          # Anonymous classes don't have a name.  Stub out :name so that things work
+          allow(c).to receive(:name).and_return("OtherCircuitBreaker")
+          c.include(Px::Service::Client::CircuitBreaker)
+        end
+      }
+
+      let(:other) { other_class.new }
+
       before :each do
-        subject_class.send(:define_method, :test_method) do |arg|
+        subject_class.send(:define_method, :_result) do
           "should not be called"
         end
+      end
 
-        subject_class.circuit_method(:test_method)
+      context "when the breaker opens on the first instance" do
+        before :each do
+          subject.circuit_state.trip
+          subject.circuit_state.last_failure_time = Time.now
+        end
 
-        subject.circuit_state.trip
+        it "raises a ServiceError on the first instance" do
+          expect {
+            subject.make_request(:get, "http://test").value!
+          }.to raise_error(Px::Service::ServiceError)
+        end
+
+        it "does not raise a ServiceError on the second instance" do
+          expect(other.make_request(:get, "http://test").value!).to eq("result")
+        end
       end
+    end
 
-      it "raises a ServiceError" do
-        expect{
-          subject.test_method("test")
-        }.to raise_error(Px::Service::ServiceError)
+    context "with multiple instances of the same class" do
+      let(:other) { subject_class.new }
+
+      before :each do
+        subject_class.send(:define_method, :_result) do
+          "should not be called"
+        end
+      end
+
+      context "when the breaker opens on the first instance" do
+        before :each do
+          subject.circuit_state.trip
+          subject.circuit_state.last_failure_time = Time.now
+        end
+
+        it "raises a ServiceError on the first instance" do
+          expect {
+            subject.make_request(:get, "http://test").value!
+          }.to raise_error(Px::Service::ServiceError)
+        end
+
+        it "raises a ServiceError on the second instance" do
+          expect {
+            other.make_request(:get, "http://test").value!
+          }.to raise_error(Px::Service::ServiceError)
+        end
       end
     end
+
   end
 end

data/spec/px/service/client/future_spec.rb

@@ -46,7 +46,7 @@ describe Px::Service::Client::Future do
       it "does not call the method on the value" do
         called = false
         Fiber.new do
-          subject.size
+          subject.value
           called = true
         end.resume
 
@@ -86,6 +86,53 @@ describe Px::Service::Client::Future do
     end
   end
 
+  describe '#value!' do
+    context "when the future is not complete" do
+      it "does not call the method on the value" do
+        called = false
+        Fiber.new do
+          subject.value!
+          called = true
+        end.resume
+
+        expect(called).to eq(false)
+      end
+    end
+
+    context "when the future is already complete" do
+      it "returns the value" do
+        subject.complete(value)
+        expect(subject.value!).to eq(value)
+      end
+    end
+
+    context "when the value is an exception" do
+      it "returns the exception" do
+        Fiber.new do
+          expect {
+            subject.value!
+          }.to raise_error(ArgumentError)
+        end.resume
+
+        Fiber.new do
+          subject.complete(ArgumentError.new("Error"))
+        end.resume
+      end
+    end
+
+    context "when the method returns a value" do
+      it "returns the value" do
+        Fiber.new do
+          expect(subject.value!).to eq(value)
+        end.resume
+
+        Fiber.new do
+          subject.complete(value)
+        end.resume
+      end
+    end
+  end
+
   describe '#method_missing' do
     context "when the future is already complete" do
       context "when the method raised an exception" do

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ Bundler.setup
 
 require 'px/service/client'
 require 'timecop'
+require 'pry'
 require 'vcr'
 
 ##

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: px-service-client
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.4
 platform: ruby
 authors:
 - Chris Micacchi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-08 00:00:00.000000000 Z
+date: 2015-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: will_paginate
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -269,7 +283,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Common service client behaviours for Ruby applications