circuitbox 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87808cd77975fc82ac067b5c0c82f72f993f6b77
-  data.tar.gz: 74889c759914d18561ec967cd77edde519bd6d5d
+  metadata.gz: c0f2e7b33bd03af9f5b4aa606de11a0a1068b931
+  data.tar.gz: 922098a0bf91d9c782c3ac147e94af11f834cf94
 SHA512:
-  metadata.gz: 427a52c594b433cc8a506ebe995d56c64b7f1174766c74ce43f476cbf4f848656c2e9c9f6867a8cc31fcadecd92c64a7fcff4db865e7e4cca2c0605e18f6fc0b
-  data.tar.gz: 6236374797da10131120158b8c2c65f2cff3b4654f3b3ca24a0c85a27f02a6ccb20025babab8c412f6ea82d8457027d600544b9cd857c16fdea2a4636cfb38f8
+  metadata.gz: e1fefde3c0c5af41966ff72eee0c71d3c0e5478306b3f744b95eed5ea4e5daeb651ecaf0cf0f7a92eb354571b0af3628c48881e3b29b0f291b8c1a8f1da57adb
+  data.tar.gz: 34add156e9af7dd00a3a12be2c6dde1d05e7f8c5ab5bfcb7006022351ddcbccc57586b340bd6d4b8323bb71cfc02022a49e5fef0bf8afbc88df0288edd93822b

data/README.md

@@ -196,13 +196,27 @@ conn.get("/api", circuit_breaker_run_options: {})
 c.use Circuitbox::FaradayMiddleware, circuit_breaker_options: {}
 ```
 
-## TODO
-* ~~Fix Faraday integration to return a Faraday response object~~
-* Split stats into it's own repository
-* ~~Circuit Breaker should raise an exception by default instead of returning nil~~
-* Refactor to use single state variable
-* Fix the partition hack
-* Integrate with Breakerbox/Hystrix
+<<<<<<< HEAD
+* `open_circuit` lambda determining what response is considered a failure, 
+  counting towards the opening of the circuit
+
+```ruby
+c.use Circuitbox::FaradayMiddleware, open_circuit: lambda { |response| response.status >= 500 }
+```
+## CHANGELOG
+<<<<<<< HEAD
+### version next
+
+### v0.10
+- configuration option for faraday middleware for what should be considered to open the circuit [enrico-scalavio](https://github.com/enrico-scalavino)
+- fix for issue 16, support of in_parallel requests in faraday middlware which were opening the circuit.
+- deprecate the __run_option__ `:storage_key`
+
+### v0.9
+- add `run!` method to raise exception on circuit open and service
+
+### v0.8
+- Everything prior to keeping the change log
 
 ## Installation
 

data/circuitbox.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "gimme"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "mocha"
+  spec.add_development_dependency "typhoeus"
   spec.add_development_dependency "timecop"
   spec.add_development_dependency "faraday"
   spec.add_development_dependency "logger"

data/lib/circuitbox/circuit_breaker.rb

@@ -43,7 +43,6 @@ class Circuitbox
 
     def run!(run_options = {})
       @partition = run_options.delete(:partition) # sorry for this hack.
-      cache_key  = run_options.delete(:storage_key)
 
       if open?
         logger.debug "[CIRCUIT] open: skipping #{service}"
@@ -62,17 +61,12 @@ class Circuitbox
           end
 
           logger.debug "[CIRCUIT] closed: #{service} querie success"
-          cache_response(cache_key, response) if cache_key
           success!
         rescue *exceptions => exception
           logger.debug "[CIRCUIT] closed: detected #{service} failure"
           failure!
           open! if half_open?
-          if cache_key
-            response = get_cached_response(cache_key)
-          else
-            raise Circuitbox::ServiceFailureError.new(service, exception)
-          end
+          raise Circuitbox::ServiceFailureError.new(service, exception)
         end
       end
 
@@ -252,14 +246,6 @@ class Circuitbox
       Digest::SHA1.hexdigest(storage_key(:cache, args.inspect.to_s))
     end
 
-    def cache_response(args, response)
-      cache.write(response_key(args), response)
-    end
-
-    def get_cached_response(args)
-      cache.read(response_key(args))
-    end
-
     def stat_storage_key(event, options = {})
       storage_key(:stats, align_time_on_minute, event, options)
     end

data/lib/circuitbox/faraday_middleware.rb

@@ -22,19 +22,22 @@ class Circuitbox
 
     def initialize(app, opts = {})
       @app = app
-      @opts = opts
+      default_options = { open_circuit: lambda { |response| !response.success? } }
+      @opts = default_options.merge(opts)
       super(app)
     end
 
     def call(request_env)
       service_response = nil
-      response = circuit(request_env).run(run_options(request_env)) do
-          service_response = @app.call(request_env)
-          raise RequestFailed unless service_response.success?
-          service_response
+      check_circuit_open!(request_env)
+      circuit(request_env).run!(run_options(request_env)) do
+        @app.call(request_env).on_complete do |env|
+          service_response = Faraday::Response.new(env)
+          raise RequestFailed if open_circuit?(service_response)
+        end
       end
-
-      response.nil? ? circuit_open_value(request_env, service_response) : response
+    rescue Circuitbox::Error
+      circuit_open_value(request_env, service_response)
     end
 
     def exceptions
@@ -47,6 +50,11 @@ class Circuitbox
 
     private
 
+    def check_circuit_open!(env)
+      # raises if the circuit is open
+      circuit(env).run!(run_options(env)) { :noop }
+    end
+
     def run_options(env)
       env[:circuit_breaker_run_options] || {}
     end
@@ -75,6 +83,10 @@ class Circuitbox
                        end
     end
 
+    def open_circuit?(response)
+      opts[:open_circuit].call(response)
+    end
+
     def circuitbox
       @circuitbox ||= opts.fetch(:circuitbox, Circuitbox)
     end

data/lib/circuitbox/version.rb

@@ -1,3 +1,3 @@
 class Circuitbox
-VERSION='0.9.0'
+VERSION='0.10.0'
 end

data/test/faraday_middleware_test.rb

@@ -7,13 +7,14 @@ class Circuitbox
   class FaradayMiddlewareTest < Minitest::Test
 
     attr_reader :app
+    
     def setup
       @app = gimme
     end
 
     def test_default_identifier
       env = { url: "sential" }
-      assert_equal FaradayMiddleware.new(app).identifier.call(env), "sential"
+      assert_equal "sential", FaradayMiddleware.new(app).identifier.call(env)
     end
 
     def test_overwrite_identifier
@@ -25,19 +26,21 @@ class Circuitbox
       stub_circuitbox
       env = { url: "url" }
       give(circuitbox).circuit("url", anything) { circuit }
+      give(circuit).run!(anything) { raise Circuitbox::Error }
       default_value_generator = lambda { |_| :sential }
       middleware = FaradayMiddleware.new(app,
                                          circuitbox: circuitbox,
                                          default_value: default_value_generator)
-      assert_equal middleware.call(env), :sential
+      assert_equal :sential, middleware.call(env)
     end
 
     def test_overwrite_default_value_generator_static_value
       stub_circuitbox
       env = { url: "url" }
       give(circuitbox).circuit("url", anything) { circuit }
+      give(circuit).run!(anything) { raise Circuitbox::Error }
       middleware = FaradayMiddleware.new(app, circuitbox: circuitbox, default_value: :sential)
-      assert_equal middleware.call(env), :sential
+      assert_equal :sential, middleware.call(env)
     end
 
     def test_default_exceptions
@@ -46,6 +49,29 @@ class Circuitbox
       assert_includes middleware.exceptions, FaradayMiddleware::RequestFailed
     end
 
+    def test_overridde_success_response
+      env = { url: "url" }
+      app = gimme
+      give(app).call(anything) { Faraday::Response.new(status: 400) }
+      error_response = lambda { |response| response.status >= 500 }
+      response = FaradayMiddleware.new(app, open_circuit: error_response).call(env)
+      assert_kind_of Faraday::Response, response
+      assert_equal response.status, 400
+      assert response.finished?
+      refute response.success?
+    end
+
+    def test_default_success_response
+      env = { url: "url" }
+      app = gimme
+      give(app).call(anything) { Faraday::Response.new(status: 400) }
+      response = FaradayMiddleware.new(app).call(env)
+      assert_kind_of Faraday::Response, response
+      assert_equal response.status, 503
+      assert response.finished?
+      refute response.success?
+    end
+
     def test_overwrite_exceptions
       middleware = FaradayMiddleware.new(app, exceptions: [SentialException])
       assert_includes middleware.exceptions, SentialException
@@ -53,12 +79,12 @@ class Circuitbox
 
     def test_pass_circuit_breaker_run_options
       stub_circuitbox
-      give(circuit).run(:sential)
+      give(circuit).run!(:sential)
       give(circuitbox).circuit("url", anything) { circuit }
       env = { url: "url", circuit_breaker_run_options: :sential }
       middleware = FaradayMiddleware.new(app, circuitbox: circuitbox)
       middleware.call(env)
-      verify(circuit).run(:sential)
+      verify(circuit, 2.times).run!(:sential) # one to check open, one to execute command
     end
 
     def test_pass_circuit_breaker_options
@@ -74,13 +100,14 @@ class Circuitbox
       middleware = FaradayMiddleware.new(app, options)
       middleware.call(env)
 
-      verify(circuitbox).circuit("url", expected_circuit_breaker_options)
+      verify(circuitbox, 2.times).circuit("url", expected_circuit_breaker_options)
     end
 
     def test_overwrite_circuitbreaker_default_value
       stub_circuitbox
       env = { url: "url", circuit_breaker_default_value: :sential }
       give(circuitbox).circuit("url", anything) { circuit }
+      give(circuit).run!(anything) { raise Circuitbox::Error }
       middleware = FaradayMiddleware.new(app, circuitbox: circuitbox)
       assert_equal middleware.call(env), :sential
     end
@@ -88,7 +115,7 @@ class Circuitbox
     def test_return_value_closed_circuit
       stub_circuitbox
       env = { url: "url" }
-      give(circuit).run(anything) { :sential }
+      give(circuit).run!(anything) { :sential }
       give(circuitbox).circuit("url", anything) { circuit }
       middleware = FaradayMiddleware.new(app, circuitbox: circuitbox)
       assert_equal middleware.call(env), :sential
@@ -97,7 +124,7 @@ class Circuitbox
     def test_return_null_response_for_open_circuit
       stub_circuitbox
       env = { url: "url" }
-      give(circuit).run(anything) { nil }
+      give(circuit).run!(anything) { raise Circuitbox::Error }
       give(circuitbox).circuit("url", anything) { circuit }
       response = FaradayMiddleware.new(app, circuitbox: circuitbox).call(env)
       assert_kind_of Faraday::Response, response

data/test/integration/faraday_middleware_test.rb

@@ -1,4 +1,5 @@
 require "integration_helper"
+require "typhoeus/adapters/faraday"
 
 class Circuitbox
   class FaradayMiddlewareTest < Minitest::Test
@@ -6,7 +7,7 @@ class Circuitbox
     def setup
       @connection = Faraday.new do |c|
         c.use FaradayMiddleware
-        c.adapter Faraday.default_adapter
+        c.adapter :typhoeus # support in_parallel
       end
       @success_url = "http://localhost:4711"
       @failure_url = "http://localhost:4712"
@@ -21,16 +22,47 @@ class Circuitbox
       Circuitbox.reset
     end
 
+    def test_failure_circuit_response
+      failure_response = @connection.get(@failure_url)
+      assert_equal failure_response.status, 503
+      assert_match failure_response.original_response.body, "Failure!"
+    end
+
     def test_open_circuit_response
       10.times { @connection.get(@failure_url) } # make the CircuitBreaker open
+
       open_circuit_response = @connection.get(@failure_url)
-      assert open_circuit_response.status, 503
-      assert_match open_circuit_response.original_response.body, "Failure!"
+      assert_equal open_circuit_response.status, 503
+      assert open_circuit_response.original_response.nil?
     end
 
     def test_closed_circuit_response
       result = @connection.get(@success_url)
       assert result.success?
     end
+
+    def test_parallel_requests_closed_circuit_response
+      response_1, response_2 = nil
+      @connection.in_parallel do
+        response_1 = @connection.get(@success_url)
+        response_2 = @connection.get(@success_url)
+      end
+
+      assert response_1.success?
+      assert response_2.success?
+    end
+
+    def test_parallel_requests_open_circuit_response
+      10.times { @connection.get(@failure_url) } # make the CircuitBreaker open
+      response_1, response_2 = nil
+      @connection.in_parallel do
+        response_1 = @connection.get(@failure_url)
+        response_2 = @connection.get(@failure_url)
+      end
+
+      assert_equal response_1.status, 503
+      assert_equal response_2.status, 503
+    end
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: circuitbox
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Fahim Ferdous
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-16 00:00:00.000000000 Z
+date: 2015-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  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: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -245,7 +259,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: A robust circuit breaker that manages failing external services.