stoplight 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e8f2a2c82dbcebacbd22a8e7c945ded26322e528
-  data.tar.gz: 499150fa4ddaa7280f609e9171ab3d01a5486c6e
+  metadata.gz: 97f3aac00bec5d8f4a86a709adacab7e81246b2c
+  data.tar.gz: ed4f8f332e6111245ff0c6555b337bded9f417a7
 SHA512:
-  metadata.gz: fb0064324bbfdf24238b17eb0d7f486981a1c327799441d0571549df292be4b5e0abf61a8d4697bceae3c7bca2c12f66cf6a6fc090349cb5592fb141c171dab1
-  data.tar.gz: 7cf937362b94a968b2ce0cd425e3cb7bf289f6c6708f5daa9386b4e06fedf493d736f9662fd878493894c9f5e1a39d35f0067bfeb06b134f962b6303c6d0e436
+  metadata.gz: 43be4295193fbd9977303ddb15baf0d1ef3a4f04eeea57302d58e89d97ed3af2066b4c37294d335213f2b5841b987bf3b0e2a74eda00bff619e1504092ada523
+  data.tar.gz: 5b8e1cfda7283a49082308f9f5d9f696ca2508066ddba7707240cc88e31e61f6f2d9611600c0468c68468eef0eb3851a16b1a1f1e85520c5618f043ddbe4fa62

data/README.md

@@ -1,11 +1,11 @@
 # [Stoplight][]
 
-[![Version][]](https://rubygems.org/gems/stoplight)
-[![Build][]](https://travis-ci.org/orgsync/stoplight)
-[![Coverage][]](https://coveralls.io/r/orgsync/stoplight)
-[![Grade][]](http://www.libgrader.com/libraries/ruby/stoplight)
-[![Climate][]](https://codeclimate.com/github/orgsync/stoplight)
-[![Dependencies][]](https://gemnasium.com/orgsync/stoplight)
+[![Version badge][]][version]
+[![Build badge][]][build]
+[![Coverage badge][]][coverage]
+[![Grade badge][]][grade]
+[![Climate badge][]][climate]
+[![Dependencies badge][]][dependencies]
 
 Stoplight is traffic control for code. It's an implementation of the circuit
 breaker pattern in Ruby.
@@ -23,7 +23,7 @@ Check out [stoplight-admin][] for controlling your stoplights.
   - [Custom errors](#custom-errors)
   - [Custom fallback](#custom-fallback)
   - [Custom threshold](#custom-threshold)
-  - [Custom timeout](#custom-timeout)
+  - [Custom cool off time](#custom-cool-off-time)
   - [Rails](#rails)
 - [Setup](#setup)
   - [Data store](#data-store)
@@ -57,14 +57,14 @@ $ gem install stoplight
 Stoplight uses [Semantic Versioning][]. Check out [the change log][] for a
 detailed list of changes.
 
-Stoplight works with all supported versions of Ruby (2.0 through 2.3).
+Stoplight works with all supported versions of Ruby (2.1 through 2.3).
 
 ## Basic usage
 
 To get started, create a stoplight:
 
 ``` rb
-light = Stoplight('example-1') { 22.0 / 7 }
+light = Stoplight('example-pi') { 22.0 / 7 }
 # => #<Stoplight::Light:...>
 ```
 
@@ -84,7 +84,7 @@ stoplight. That's not very interesting though, so let's create a failing
 stoplight:
 
 ``` rb
-light = Stoplight('example-2') { 1 / 0 }
+light = Stoplight('example-zero') { 1 / 0 }
 # => #<Stoplight::Light:...>
 ```
 
@@ -99,10 +99,10 @@ light.run
 light.run
 # ZeroDivisionError: divided by 0
 light.run
-# Switching example-2 from green to red because ZeroDivisionError divided by 0
+# Switching example-zero from green to red because ZeroDivisionError divided by 0
 # ZeroDivisionError: divided by 0
 light.run
-# Stoplight::Error::RedLight: example-2
+# Stoplight::Error::RedLight: example-zero
 light.color
 # => "red"
 ```
@@ -112,70 +112,47 @@ notifier. See [the notifiers section][] to learn more about notifiers.
 
 The stoplight will move into the yellow state after being in the red state for
 a while. (The yellow state corresponds to the half open state for circuit
-  breakers.) To configure how long it takes to switch into the yellow state,
-  check out [the timeout section][] When stoplights are yellow, they will try
-  to run their code. If it fails, they'll switch back to red. If it succeeds,
-  they'll switch to green.
+breakers.) To configure how long it takes to switch into the yellow state,
+check out [the cool off time section][] When stoplights are yellow, they will
+try to run their code. If it fails, they'll switch back to red. If it succeeds,
+they'll switch to green.
 
 ### Custom errors
 
-##### Whitelisted errors
-
 Some errors shouldn't cause your stoplight to move into the red state. Usually
 these are handled elsewhere in your stack and don't represent real failures. A
 good example is `ActiveRecord::RecordNotFound`.
 
-``` rb
-light = Stoplight('example-3') { User.find(123) }
-  .with_whitelisted_errors([ActiveRecord::RecordNotFound])
-# => #<Stoplight::Light:...>
-light.run
-# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
-light.run
-# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
-light.run
-# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
-light.color
-# => "green"
-```
-
-The following errors are always whitelisted: `NoMemoryError`, `ScriptError`,
-`SecurityError`, `SignalException`, `SystemExit`, and `SystemStackError`.
+To prevent some errors from changing the state of your stoplight, you can
+provide a custom block that will be called with the error and a handler
+`Proc`. It can do one of three things:
 
-Whitelisted errors take precedence over [blacklisted errors](#blacklisted-errors).
+1.  Re-raise the error. This causes Stoplight to ignore the error. Do this for
+    errors like `ActiveRecord::RecordNotFound` that don't represent real
+    failures.
 
-##### Blacklisted errors
+2.  Call the handler with the error. This is the default behavior. Stoplight
+    will only ignore the error if it shouldn't have been caught in the first
+    place. See `Stoplight::Error::AVOID_RESCUING` for a list of errors that
+    will be ignored.
 
-You may want only certain errors to cause your stoplight to move into the red
-state.
+3.  Do nothing. This is **not recommended**. Doing nothing causes Stoplight to
+    never ignore the error. That means a `NoMemoryError` could change the color
+    of your stoplights.
 
 ``` rb
-light = Stoplight('example-4') { 1 / 0 }
-  .with_blacklisted_errors([ZeroDivisionError])
-# => #<Stoplight::Light:...>
-light.run
-# ZeroDivisionError: divided by 0
-light.run
-# ZeroDivisionError: divided by 0
-light.run
-# ZeroDivisionError: divided by 0
-light.color
-# => "red"
-```
-
-This will cause all other errors to be raised normally. They won't affect the
-state of your stoplight.
-
-``` rb
-light = Stoplight('example-5') { fail }
-  .with_blacklisted_errors([ZeroDivisionError])
+light = Stoplight('example-not-found') { User.find(123) }
+  .with_error_handler do |error, handle|
+    raise error if error.is_a?(ActiveRecord::RecordNotFound)
+    handle.call(error)
+  end
 # => #<Stoplight::Light:...>
 light.run
-# RuntimeError:
+# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
 light.run
-# RuntimeError:
+# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
 light.run
-# RuntimeError:
+# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
 light.color
 # => "green"
 ```
@@ -188,7 +165,7 @@ fallback that will be called in both of these cases. It will be passed the
 error if the light was green.
 
 ``` rb
-light = Stoplight('example-6') { 1 / 0 }
+light = Stoplight('example-fallback') { 1 / 0 }
   .with_fallback { |e| p e; 'default' }
 # => #<Stoplight::Light:..>
 light.run
@@ -198,7 +175,7 @@ light.run
 # #<ZeroDivisionError: divided by 0>
 # => "default"
 light.run
-# Switching example-4 from green to red because ZeroDivisionError divided by 0
+# Switching example-fallback from green to red because ZeroDivisionError divided by 0
 # #<ZeroDivisionError: divided by 0>
 # => "default"
 light.run
@@ -212,34 +189,34 @@ Some bits of code might be allowed to fail more or less frequently than others.
 You can configure this by setting a custom threshold.
 
 ``` rb
-light = Stoplight('example-7') { fail }
+light = Stoplight('example-threshold') { fail }
   .with_threshold(1)
 # => #<Stoplight::Light:...>
 light.run
-# Switching example-5 from green to red because RuntimeError
+# Switching example-threshold from green to red because RuntimeError
 # RuntimeError:
 light.run
-# Stoplight::Error::RedLight: example-5
+# Stoplight::Error::RedLight: example-threshold
 ```
 
 The default threshold is `3`.
 
-### Custom timeout
+### Custom cool off time
 
 Stoplights will automatically attempt to recover after a certain amount of
-time. A light in the red state for longer than the timeout will transition to
-the yellow state. This timeout is customizable.
+time. A light in the red state for longer than the cool of period will
+transition to the yellow state. This cool off time is customizable.
 
 ``` rb
-light = Stoplight('example-8') { fail }
-  .with_timeout(1)
+light = Stoplight('example-cool-off') { fail }
+  .with_cool_off_time(1)
 # => #<Stoplight::Light:...>
 light.run
 # RuntimeError:
 light.run
 # RuntimeError:
 light.run
-# Switching example-6 from green to red because RuntimeError
+# Switching example-cool-off from green to red because RuntimeError
 # RuntimeError:
 sleep(1)
 # => 1
@@ -249,10 +226,10 @@ light.run
 # RuntimeError:
 ```
 
-The default timeout is `60` seconds. To disable automatic recovery, set the
-timeout to `Float::INFINITY`. To make automatic recovery instantaneous, set the
-timeout to `0` seconds. Note that this is not recommended, as it effectively
-replaces the red state with yellow.
+The default cool off time is `60` seconds. To disable automatic recovery, set
+the cool off to `Float::INFINITY`. To make automatic recovery instantaneous,
+set the cool off to `0` seconds. Note that this is not recommended, as it
+effectively replaces the red state with yellow.
 
 ### Rails
 
@@ -267,7 +244,6 @@ class ApplicationController < ActionController::Base
 
   def stoplight(&block)
     Stoplight("#{params[:controller]}##{params[:action]}", &block)
-      .with_whitelisted_errors([ActiveRecord::RecordNotFound])
       .with_fallback do |error|
         Rails.logger.error(error)
         render(nothing: true, status: :service_unavailable)
@@ -322,7 +298,7 @@ If you want to send notifications elsewhere, you'll have to set them up.
 
 #### Bugsnag
 
-Make sure you have [the Bugsnag gem][] (`~> 2.8`) installed before configuring
+Make sure you have [the Bugsnag gem][] (`~> 4.0`) installed before configuring
 Stoplight.
 
 ``` rb
@@ -419,14 +395,14 @@ override the default behavior. You can lock a light in either the green or red
 state using `set_state`.
 
 ``` rb
-light = Stoplight('example-9') { true }
+light = Stoplight('example-locked') { true }
 # => #<Stoplight::Light:..>
 light.run
 # => true
 light.data_store.set_state(light, Stoplight::State::LOCKED_RED)
 # => "locked_red"
 light.run
-# Stoplight::Error::RedLight: example-7
+# Stoplight::Error::RedLight: example-locked
 ```
 
 **Code in locked red lights may still run under certain conditions!** If you
@@ -477,27 +453,33 @@ Martin Fowler's [CircuitBreaker][] article.
 
 Stoplight is licensed under [the MIT License][].
 
-[stoplight]: https://github.com/orgsync/stoplight
-[version]: https://img.shields.io/gem/v/stoplight.svg?label=version
-[build]: https://img.shields.io/travis/orgsync/stoplight/master.svg?label=build
-[grade]: https://img.shields.io/badge/grade-A-brightgreen.svg
-[coverage]: https://img.shields.io/coveralls/orgsync/stoplight/master.svg?label=coverage
-[climate]: https://img.shields.io/codeclimate/github/orgsync/stoplight.svg?label=climate
-[dependencies]: https://img.shields.io/gemnasium/orgsync/stoplight.svg?label=dependencies
+[Stoplight]: https://github.com/orgsync/stoplight
+[Version badge]: https://img.shields.io/gem/v/stoplight.svg?label=version
+[version]: https://rubygems.org/gems/stoplight
+[Build badge]: https://img.shields.io/travis/orgsync/stoplight/master.svg?label=build
+[build]: https://travis-ci.org/orgsync/stoplight
+[Coverage badge]: https://img.shields.io/coveralls/orgsync/stoplight/master.svg?label=coverage
+[coverage]: https://coveralls.io/r/orgsync/stoplight
+[Grade badge]: https://img.shields.io/badge/grade-A-brightgreen.svg
+[grade]: http://www.libgrader.com/libraries/ruby/stoplight
+[Climate badge]: https://img.shields.io/codeclimate/github/orgsync/stoplight.svg?label=climate
+[climate]: https://codeclimate.com/github/orgsync/stoplight
+[Dependencies badge]: https://img.shields.io/gemnasium/orgsync/stoplight.svg?label=dependencies
+[dependencies]: https://gemnasium.com/orgsync/stoplight
 [stoplight-admin]: https://github.com/orgsync/stoplight-admin
-[semantic versioning]: http://semver.org/spec/v2.0.0.html
+[Semantic Versioning]: http://semver.org/spec/v2.0.0.html
 [the change log]: CHANGELOG.md
 [the notifiers section]: #notifiers
-[the timeout section]: #custom-timeout
-[the redis gem]: https://rubygems.org/gems/redis
-[the bugsnag gem]: https://rubygems.org/gems/bugsnag
-[the hipchat gem]: https://rubygems.org/gems/hipchat
-[the honeybadger gem]: https://rubygems.org/gems/honeybadger
-[the logger class]: http://ruby-doc.org/stdlib-2.2.3/libdoc/logger/rdoc/Logger.html
-[the slack gem]: https://rubygems.org/gems/slack-notifier
+[the cool off time section]: #custom-cool-off-time
+[the Redis gem]: https://rubygems.org/gems/redis
+[the Bugsnag gem]: https://rubygems.org/gems/bugsnag
+[the HipChat gem]: https://rubygems.org/gems/hipchat
+[the Honeybadger gem]: https://rubygems.org/gems/honeybadger
+[the Logger class]: http://ruby-doc.org/stdlib-2.2.3/libdoc/logger/rdoc/Logger.html
+[the Slack gem]: https://rubygems.org/gems/slack-notifier
 [@camdez]: https://github.com/camdez
 [@tfausak]: https://github.com/tfausak
 [@orgsync]: https://github.com/OrgSync
 [complete list of contributors]: https://github.com/orgsync/stoplight/graphs/contributors
-[circuitbreaker]: http://martinfowler.com/bliki/CircuitBreaker.html
-[the mit license]: LICENSE.md
+[CircuitBreaker]: http://martinfowler.com/bliki/CircuitBreaker.html
+[the MIT license]: LICENSE.md

data/lib/stoplight/default.rb

@@ -2,19 +2,12 @@
 
 module Stoplight
   module Default
-    WHITELISTED_ERRORS = [
-      NoMemoryError,
-      ScriptError,
-      SecurityError,
-      SignalException,
-      SystemExit,
-      SystemStackError
-    ].freeze
-
-    BLACKLISTED_ERRORS = [].freeze
+    COOL_OFF_TIME = 60.0
 
     DATA_STORE = DataStore::Memory.new
 
+    ERROR_HANDLER = -> (error, handler) { handler.call(error) }
+
     ERROR_NOTIFIER = -> (error) { warn error }
 
     FALLBACK = nil
@@ -30,7 +23,5 @@ module Stoplight
     ].freeze
 
     THRESHOLD = 3
-
-    TIMEOUT = 60.0
   end
 end

data/lib/stoplight/error.rb

@@ -2,6 +2,19 @@
 
 module Stoplight
   module Error
+    HANDLER = lambda do |error|
+      raise error if AVOID_RESCUING.any? { |klass| error.is_a?(klass) }
+    end
+
+    AVOID_RESCUING = [
+      NoMemoryError,
+      ScriptError,
+      SecurityError,
+      SignalException,
+      SystemExit,
+      SystemStackError
+    ].freeze
+
     Base = Class.new(StandardError)
     RedLight = Class.new(Base)
   end

data/lib/stoplight/light.rb

@@ -4,15 +4,15 @@ module Stoplight
   class Light # rubocop:disable Style/Documentation
     include Runnable
 
-    # @return [Array<Exception>]
-    attr_reader :whitelisted_errors
-    # @return [Array<Exception>]
-    attr_reader :blacklisted_errors
     # @return [Proc]
     attr_reader :code
+    # @return [Float]
+    attr_reader :cool_off_time
     # @return [DataStore::Base]
     attr_reader :data_store
     # @return [Proc]
+    attr_reader :error_handler
+    # @return [Proc]
     attr_reader :error_notifier
     # @return [Proc, nil]
     attr_reader :fallback
@@ -22,8 +22,6 @@ module Stoplight
     attr_reader :notifiers
     # @return [Fixnum]
     attr_reader :threshold
-    # @return [Float]
-    attr_reader :timeout
 
     class << self
       # @return [DataStore::Base]
@@ -44,36 +42,34 @@ module Stoplight
       @name = name
       @code = code
 
-      @whitelisted_errors = Default::WHITELISTED_ERRORS
-      @blacklisted_errors = Default::BLACKLISTED_ERRORS
+      @cool_off_time = Default::COOL_OFF_TIME
       @data_store = self.class.default_data_store
+      @error_handler = Default::ERROR_HANDLER
       @error_notifier = self.class.default_error_notifier
       @fallback = Default::FALLBACK
       @notifiers = self.class.default_notifiers
       @threshold = Default::THRESHOLD
-      @timeout = Default::TIMEOUT
     end
 
-    # @param whitelisted_errors [Array<Exception>]
+    # @param cool_off_time [Float]
     # @return [self]
-    def with_whitelisted_errors(whitelisted_errors)
-      @whitelisted_errors = Default::WHITELISTED_ERRORS + whitelisted_errors
+    def with_cool_off_time(cool_off_time)
+      @cool_off_time = cool_off_time
       self
     end
 
-    alias with_allowed_errors with_whitelisted_errors
-
-    # @param blacklisted_errors [Array<Exception>]
+    # @param data_store [DataStore::Base]
     # @return [self]
-    def with_blacklisted_errors(blacklisted_errors)
-      @blacklisted_errors = Default::BLACKLISTED_ERRORS + blacklisted_errors
+    def with_data_store(data_store)
+      @data_store = data_store
       self
     end
 
-    # @param data_store [DataStore::Base]
+    # @yieldparam error [Exception]
+    # @yieldparam handle [Proc]
     # @return [self]
-    def with_data_store(data_store)
-      @data_store = data_store
+    def with_error_handler(&error_handler)
+      @error_handler = error_handler
       self
     end
 
@@ -104,12 +100,5 @@ module Stoplight
       @threshold = threshold
       self
     end
-
-    # @param timeout [Float]
-    # @return [self]
-    def with_timeout(timeout)
-      @timeout = timeout
-      self
-    end
   end
 end

data/lib/stoplight/light/runnable.rb

@@ -12,7 +12,8 @@ module Stoplight
         when state == State::LOCKED_GREEN then Color::GREEN
         when state == State::LOCKED_RED then Color::RED
         when failures.size < threshold then Color::GREEN
-        when failure && Time.new - failure.time >= timeout then Color::YELLOW
+        when failure && Time.new - failure.time >= cool_off_time
+          Color::YELLOW
         else Color::RED
         end
       end
@@ -52,18 +53,12 @@ module Stoplight
         failures = clear_failures
         on_success.call(failures) if on_success
         result
-      rescue => error
+      rescue Exception => error # rubocop:disable Lint/RescueException
         handle_error(error, on_failure)
       end
 
-      def not_blacklisted_error?(error)
-        !blacklisted_errors.empty? &&
-          blacklisted_errors.none? { |klass| error.is_a?(klass) }
-      end
-
       def handle_error(error, on_failure)
-        raise error if whitelisted_errors.any? { |klass| error.is_a?(klass) }
-        raise error if not_blacklisted_error?(error)
+        error_handler.call(error, Error::HANDLER)
         size = record_failure(error)
         on_failure.call(size, error) if on_failure
         raise error unless fallback

data/lib/stoplight/version.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 module Stoplight
-  VERSION = Gem::Version.new('1.4.0')
+  VERSION = Gem::Version.new('2.0.0')
 end

data/spec/stoplight/default_spec.rb

@@ -7,39 +7,25 @@ RSpec.describe Stoplight::Default do
     expect(described_class).to be_a(Module)
   end
 
-  describe '::WHITELISTED_ERRORS' do
-    it 'is an array' do
-      expect(Stoplight::Default::WHITELISTED_ERRORS).to be_an(Array)
-    end
-
-    it 'contains exception classes' do
-      Stoplight::Default::WHITELISTED_ERRORS.each do |whitelisted_error|
-        expect(whitelisted_error).to be < Exception
-      end
-    end
-
-    it 'is frozen' do
-      expect(Stoplight::Default::WHITELISTED_ERRORS).to be_frozen
+  describe '::COOL_OFF_TIME' do
+    it 'is a float' do
+      expect(Stoplight::Default::COOL_OFF_TIME).to be_a(Float)
     end
   end
 
-  describe '::BLACKLISTED_ERRORS' do
-    it 'is an array' do
-      expect(Stoplight::Default::BLACKLISTED_ERRORS).to be_an(Array)
-    end
-
-    it 'is empty' do
-      expect(Stoplight::Default::BLACKLISTED_ERRORS).to be_empty
+  describe '::DATA_STORE' do
+    it 'is a data store' do
+      expect(Stoplight::Default::DATA_STORE).to be_a(Stoplight::DataStore::Base)
     end
+  end
 
-    it 'is frozen' do
-      expect(Stoplight::Default::BLACKLISTED_ERRORS).to be_frozen
+  describe '::ERROR_HANDLER' do
+    it 'is a proc' do
+      expect(Stoplight::Default::ERROR_HANDLER).to be_a(Proc)
     end
-  end
 
-  describe '::DATA_STORE' do
-    it 'is a data store' do
-      expect(Stoplight::Default::DATA_STORE).to be_a(Stoplight::DataStore::Base)
+    it 'has an arity of 2' do
+      expect(Stoplight::Default::ERROR_HANDLER.arity).to eql(2)
     end
   end
 
@@ -91,10 +77,4 @@ RSpec.describe Stoplight::Default do
       expect(Stoplight::Default::THRESHOLD).to be_a(Fixnum)
     end
   end
-
-  describe '::TIMEOUT' do
-    it 'is a float' do
-      expect(Stoplight::Default::TIMEOUT).to be_a(Float)
-    end
-  end
 end

data/spec/stoplight/light/runnable_spec.rb

@@ -51,14 +51,14 @@ RSpec.describe Stoplight::Light::Runnable do
         subject.data_store.record_failure(subject, failure)
       end
       other = Stoplight::Failure.new(
-        error.class.name, error.message, Time.new - subject.timeout)
+        error.class.name, error.message, Time.new - subject.cool_off_time)
       subject.data_store.record_failure(subject, other)
       expect(subject.color).to eql(Stoplight::Color::YELLOW)
     end
 
     it 'is red when the least recent failure is old' do
       other = Stoplight::Failure.new(
-        error.class.name, error.message, Time.new - subject.timeout)
+        error.class.name, error.message, Time.new - subject.cool_off_time)
       subject.data_store.record_failure(subject, other)
       (subject.threshold - 1).times do
         subject.data_store.record_failure(subject, failure)
@@ -119,88 +119,34 @@ RSpec.describe Stoplight::Light::Runnable do
           expect(io.string).to_not eql('')
         end
 
-        context 'when the error is whitelisted' do
-          let(:whitelisted_errors) { [error.class] }
-
-          before { subject.with_whitelisted_errors(whitelisted_errors) }
-
-          it 'does not record the failure' do
-            expect(subject.data_store.get_failures(subject).size).to eql(0)
-            begin
-              subject.run
-            rescue error.class
-              nil
-            end
-            expect(subject.data_store.get_failures(subject).size).to eql(0)
-          end
-        end
-
-        context 'when the error is blacklisted' do
-          let(:blacklisted_errors) { [error.class] }
-
-          before { subject.with_blacklisted_errors(blacklisted_errors) }
-
-          it 'records the failure' do
-            expect(subject.data_store.get_failures(subject).size).to eql(0)
-            begin
-              subject.run
-            rescue error.class
-              nil
-            end
-            expect(subject.data_store.get_failures(subject).size).to eql(1)
-          end
-        end
-
-        context 'when the error is not blacklisted' do
-          let(:blacklisted_errors) { [RuntimeError] }
-
-          before { subject.with_blacklisted_errors(blacklisted_errors) }
-
-          it 'does not record the failure' do
-            expect(subject.data_store.get_failures(subject).size).to eql(0)
+        context 'with an error handler' do
+          let(:result) do
             begin
               subject.run
+              expect(false).to be(true)
             rescue error.class
-              nil
+              expect(true).to be(true)
             end
-            expect(subject.data_store.get_failures(subject).size).to eql(0)
           end
-        end
 
-        context 'when the list of blacklisted errors is empty' do
-          let(:blacklisted_errors) { [] }
-
-          before { subject.with_blacklisted_errors(blacklisted_errors) }
-
-          it 'records the failure' do
-            expect(subject.data_store.get_failures(subject).size).to eql(0)
-            begin
-              subject.run
-            rescue error.class
-              nil
-            end
-            expect(subject.data_store.get_failures(subject).size).to eql(1)
+          it 'records the failure when the handler does nothing' do
+            subject.with_error_handler { |_error, _handler| }
+            expect { result }
+              .to change { subject.data_store.get_failures(subject).size }
+              .by(1)
           end
-        end
 
-        context 'when the error is both whitelisted and blacklisted' do
-          let(:whitelisted_errors) { [error.class] }
-          let(:blacklisted_errors) { [error.class] }
-
-          before do
-            subject
-              .with_whitelisted_errors(whitelisted_errors)
-              .with_blacklisted_errors(blacklisted_errors)
+          it 'records the failure when the handler calls handle' do
+            subject.with_error_handler { |error, handle| handle.call(error) }
+            expect { result }
+              .to change { subject.data_store.get_failures(subject).size }
+              .by(1)
           end
 
-          it 'does not record the failure' do
-            expect(subject.data_store.get_failures(subject).size).to eql(0)
-            begin
-              subject.run
-            rescue error.class
-              nil
-            end
-            expect(subject.data_store.get_failures(subject).size).to eql(0)
+          it 'does not record the failure when the handler raises' do
+            subject.with_error_handler { |error, _handle| raise error }
+            expect { result }
+              .to_not change { subject.data_store.get_failures(subject).size }
           end
         end
 
@@ -254,7 +200,7 @@ RSpec.describe Stoplight::Light::Runnable do
         end
 
         other = Stoplight::Failure.new(
-          error.class.name, error.message, time - subject.timeout)
+          error.class.name, error.message, time - subject.cool_off_time)
         subject.data_store.record_failure(subject, other)
       end
 

data/spec/stoplight/light_spec.rb

@@ -67,25 +67,15 @@ RSpec.describe Stoplight::Light do
     end
   end
 
-  describe '#whitelisted_errors' do
-    it 'is initially the default' do
-      expect(light.whitelisted_errors).to eql(
-        Stoplight::Default::WHITELISTED_ERRORS
-      )
+  describe '#code' do
+    it 'reads the code' do
+      expect(light.code).to eql(code)
     end
   end
 
-  describe '#blacklisted_errors' do
+  describe '#cool_off_time' do
     it 'is initially the default' do
-      expect(light.blacklisted_errors).to eql(
-        Stoplight::Default::BLACKLISTED_ERRORS
-      )
-    end
-  end
-
-  describe '#code' do
-    it 'reads the code' do
-      expect(light.code).to eql(code)
+      expect(light.cool_off_time).to eql(Stoplight::Default::COOL_OFF_TIME)
     end
   end
 
@@ -95,6 +85,12 @@ RSpec.describe Stoplight::Light do
     end
   end
 
+  describe '#error_handler' do
+    it 'it initially the default' do
+      expect(light.error_handler).to eql(Stoplight::Default::ERROR_HANDLER)
+    end
+  end
+
   describe '#error_notifier' do
     it 'it initially the default' do
       expect(light.error_notifier)
@@ -126,36 +122,11 @@ RSpec.describe Stoplight::Light do
     end
   end
 
-  describe '#timeout' do
-    it 'is initially the default' do
-      expect(light.timeout).to eql(Stoplight::Default::TIMEOUT)
-    end
-  end
-
-  describe '#with_whitelisted_errors' do
-    it 'adds the whitelisted errors to the default' do
-      whitelisted_errors = [StandardError]
-      light.with_whitelisted_errors(whitelisted_errors)
-      expect(light.whitelisted_errors)
-        .to eql(Stoplight::Default::WHITELISTED_ERRORS + whitelisted_errors)
-    end
-  end
-
-  describe '#with_allowed_errors' do
-    it 'sets whitelisted_errors' do
-      allowed_errors = [StandardError]
-      light.with_allowed_errors(allowed_errors)
-      expect(light.whitelisted_errors)
-        .to eql(Stoplight::Default::WHITELISTED_ERRORS + allowed_errors)
-    end
-  end
-
-  describe '#with_blacklisted_errors' do
-    it 'adds the blacklisted errors to the default' do
-      blacklisted_errors = [StandardError]
-      light.with_blacklisted_errors(blacklisted_errors)
-      expect(light.blacklisted_errors)
-        .to eql(Stoplight::Default::BLACKLISTED_ERRORS + blacklisted_errors)
+  describe '#with_cool_off_time' do
+    it 'sets the cool off time' do
+      cool_off_time = 1.2
+      light.with_cool_off_time(cool_off_time)
+      expect(light.cool_off_time).to eql(cool_off_time)
     end
   end
 
@@ -167,6 +138,14 @@ RSpec.describe Stoplight::Light do
     end
   end
 
+  describe '#with_error_handler' do
+    it 'sets the error handler' do
+      error_handler = -> (_, _) {}
+      light.with_error_handler(&error_handler)
+      expect(light.error_handler).to eql(error_handler)
+    end
+  end
+
   describe '#with_error_notifier' do
     it 'sets the error notifier' do
       error_notifier = -> (_) {}
@@ -198,12 +177,4 @@ RSpec.describe Stoplight::Light do
       expect(light.threshold).to eql(threshold)
     end
   end
-
-  describe '#with_timeout' do
-    it 'sets the timeout' do
-      timeout = 1.2
-      light.with_timeout(timeout)
-      expect(light.timeout).to eql(timeout)
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stoplight
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Cameron Desautels
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-01 00:00:00.000000000 Z
+date: 2016-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -46,14 +46,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -82,48 +82,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
-- !ruby/object:Gem::Dependency
-  name: guard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.13'
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.6'
-- !ruby/object:Gem::Dependency
-  name: guard-rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: hipchat
   requirement: !ruby/object:Gem::Requirement
@@ -158,14 +116,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '11.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.4'
+        version: '11.1'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -200,14 +158,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.37.0
+        version: 0.39.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.37.0
+        version: 0.39.0
 - !ruby/object:Gem::Dependency
   name: slack-notifier
   requirement: !ruby/object:Gem::Requirement
@@ -305,7 +263,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2'
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="