circuitbox 0.5.2 → 0.7.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Y2JjODc0MzI1ZWFmMzk3NWExN2VjMTVmYTU5MDg1ZjBlMmI1YTc3OA==
-  data.tar.gz: !binary |-
-    MTJiMjk1YWFkZThhY2FjZDdmYzA1MjUwYWY3OGNiNzE0N2JjMzM5OQ==
+SHA1:
+  metadata.gz: 00e479410c5dfdf8769c828dfbfdcae074ee524c
+  data.tar.gz: c2f06d9ceaa7ca95c6837a7abc01e79a93ecb81c
 SHA512:
-  metadata.gz: !binary |-
-    OTczMWYyMTZiZjQyZWQ0MmZjNTZmNjM4ZDU5MjI1NjA1YjQzYTZmMTY0OGY1
-    Y2EyYjIwNGZmYTEzMjY4MjVhYTIyODAwNDE5ZTE1Nzk2MWRiNWMyZDI3Yzgx
-    NzM4OWRhMWY1MWU0OTQzMWZiNmU4M2U3NzdiODgwOTE3MDllMmY=
-  data.tar.gz: !binary |-
-    ODA5NDcxMjk0NDI1Mzc1ODU1OWQyMDQ5ZTA5ZWE4NWRhNDczNzFmOWFkMmY4
-    ZDBlNGYzYWEzNDgzMGY0YzM4YzZiZTNjMzI4ZjE2MGFmYzYyMTJiYmViNGEx
-    NDE5YWE1N2VmNjFkZWViNDI5MTdhZWM4ODFjMzRjNDNmNDM3Y2U=
+  metadata.gz: d43fff58af3f25b93be58ecaac16d7b8a815ac275d4337ff6cbf65833c9e72c3c4b1ddd930165c1393df426fa0f9250b29585e987288a4af798b951073073dcf
+  data.tar.gz: a1913c31ddc136a114ea659fe602f8358f6fecb7076cb2af6d954d04f014c70f9685c1fe871963b6cdd180e62701b9fd968aa4b5f70f5cc20ccd5e6ee8d79982

data/Gemfile

@@ -14,4 +14,5 @@ group :test do
   gem 'guard-minitest'
   gem 'gimme'
   gem 'terminal-notifier-guard'
-end
+end
+

data/README.md

@@ -1,7 +1,7 @@
-# Circuitbox
 
-Circuitbox is a Ruby circuit breaker gem. It protects your application from failures of it's service dependencies. It wraps calls to external services and monitors for failures in one minute intervals. Once more than 10 requests have been made with a 50% failure rate, Circuitbox stops sending requests to that failing service for one minute. This helps your application gracefully degrade and reduces the resources your application uses when calling failing services.
+# Circuitbox
 
+Circuitbox is a Ruby circuit breaker gem. It protects your application from failures of it's service dependencies. It wraps calls to external services and monitors for failures in one minute intervals. Once more than 10 requests have been made with a 50% failure rate, Circuitbox stops sending requests to that failing service for one minute. This helps your application gracefully degrade.
 Resources about the circuit breaker pattern:
 * [http://martinfowler.com/bliki/CircuitBreaker.html](http://martinfowler.com/bliki/CircuitBreaker.html)
 * [https://github.com/Netflix/Hystrix/wiki/How-it-Works#CircuitBreaker](https://github.com/Netflix/Hystrix/wiki/How-it-Works#CircuitBreaker)
@@ -15,14 +15,14 @@ end
 ```
 
 Circuitbox will return nil for failed requests and open circuits.
-If your HTTP client has it's own conditions for failure, you can pass an `exceptions` option. 
+If your HTTP client has it's own conditions for failure, you can pass an `exceptions` option.
 
 ```ruby
 class ExampleServiceClient
   def circuit
     Circuitbox.circuit(:yammer, exceptions: [Zephyr::FailedRequest])
   end
-  
+
   def http_get
     circuit.run do
       Zephyr.new("http://example.com").get(200, 1000, "/api/messages")
@@ -40,16 +40,16 @@ class ExampleServiceClient
       exceptions:       [YourCustomException],
 
       # seconds the circuit stays open once it has passed the error threshold
-      sleep_window:     300,     
+      sleep_window:     300,
 
       # number of requests within 1 minute before it calculates error rates
-      volume_threshold: 10,      
+      volume_threshold: 10,
 
-      # exceeding this rate will open the circuit 
+      # exceeding this rate will open the circuit
       error_threshold:  50,
 
-      # seconds before the circuit times out      
-      timeout_seconds:  1        
+      # seconds before the circuit times out
+      timeout_seconds:  1
     })
   end
 end
@@ -58,20 +58,20 @@ end
 You can also pass a Proc as an option value which will evaluate each time the circuit breaker is used. This lets you configure the circuit breaker without having to restart the processes.
 
 ```ruby
-Circuitbox.circuit(:yammer, { 
+Circuitbox.circuit(:yammer, {
   sleep_window: Proc.new { Configuration.get(:sleep_window) }
 })
 ```
 
 ## Monitoring & Statistics
 
-You can also run `rake circuits:stats SERVICE={service_name}` to see successes, failures and opened circuits. 
+You can also run `rake circuits:stats SERVICE={service_name}` to see successes, failures and opened circuits.
 Add `PARTITION={partition_key}` to see the circuit for a particular partition.
 The stats are aggregated into 1 minute intervals.
 
 ## Faraday (Caveat: Open circuits return a nil response object)
 
-Circuitbox ships with [Faraday HTTP client](https://github.com/lostisland/faraday) middleware. 
+Circuitbox ships with [Faraday HTTP client](https://github.com/lostisland/faraday) middleware.
 
 ```ruby
 require 'faraday'

data/Rakefile

@@ -1,5 +1,5 @@
 require 'rake/testtask'
-require 'bundler/yammer_gem_tasks'
+require "bundler/gem_version_tasks"
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
@@ -7,4 +7,4 @@ Rake::TestTask.new do |t|
 end
 
 desc "Run tests"
-task :default => :test
+task :default => :test

data/circuitbox.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.4"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency 'bundler-gem_version_tasks'
 
   spec.add_dependency "activesupport"
 end

data/lib/circuitbox/circuit_breaker.rb

@@ -7,7 +7,8 @@ class Circuitbox
       sleep_window:     300,
       volume_threshold: 5,
       error_threshold:  50,
-      timeout_seconds:  1
+      timeout_seconds:  1,
+      time_window:      60,
     }
 
     #
@@ -18,18 +19,21 @@ class Circuitbox
     # `error_threshold`   - percentage of failed requests needed to trip circuit
     # `timeout_seconds`   - seconds until it will timeout the request
     # `exceptions`        - exceptions other than Timeout::Error that count as failures
+    # `time_window`       - interval of time used to calculate error_rate (in seconds) - default is 60s
     #
     def initialize(service, options = {})
       @service = service
       @circuit_options = options
       @circuit_store   = options.fetch(:cache) { Circuitbox.circuit_store }
-      @notifier        = Circuitbox::Notifier
+      @notifier        = options.fetch(:notifier_class) { Notifier }
 
       @exceptions = options.fetch(:exceptions) { [] }
       @exceptions = [Timeout::Error] if @exceptions.blank?
 
       @logger     = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
       @stat_store = options.fetch(:stat_store) { Circuitbox.stat_store }
+      @time_class   = options.fetch(:time_class) { Time }
+      sanitize_options
     end
 
     def option_value(name)
@@ -46,6 +50,7 @@ class Circuitbox
         response = nil
         open! unless open_flag?
       else
+        close! if was_open?
         logger.debug "[CIRCUIT] closed: querying #{service}"
 
         begin
@@ -100,14 +105,48 @@ class Circuitbox
       stats
     end
 
+    def error_rate(failures = failure_count, success = success_count)
+      all_count = failures + success
+      return 0.0 unless all_count > 0
+      failure_count.to_f / all_count.to_f * 100
+    end
+
+    def failure_count
+      circuit_store.read(stat_storage_key(:failure)).to_i
+    end
+
+    def success_count
+      circuit_store.read(stat_storage_key(:success)).to_i
+    end
+
+    def try_close_next_time
+      circuit_store.delete(storage_key(:asleep))
+    end
+
   private
     def open!
       log_event :open
       logger.debug "[CIRCUIT] opening #{service} circuit"
       circuit_store.write(storage_key(:asleep), true, expires_in: option_value(:sleep_window).seconds)
       half_open!
+      was_open!
     end
 
+    ### BEGIN - all this is just here to produce a close notification
+    def close!
+      log_event :close
+      circuit_store.delete(storage_key(:was_open))
+    end
+
+    def was_open!
+      circuit_store.write(storage_key(:was_open), true)
+    end
+
+    def was_open?
+      circuit_store.read(storage_key(:was_open)).present?
+    end
+    ### END
+
     def half_open!
       circuit_store.write(storage_key(:half_open), true)
     end
@@ -125,27 +164,20 @@ class Circuitbox
     end
 
     def passed_rate_threshold?
-      error_rate >= option_value(:error_threshold)
-    end
-
-    def failure_count
-      circuit_store.read(stat_storage_key(:failure)).to_i
-    end
-
-    def success_count
-      circuit_store.read(stat_storage_key(:success)).to_i
+      read_and_log_error_rate >= option_value(:error_threshold)
     end
 
-    def error_rate
-      all_count = failure_count + success_count
-      return 0.0 unless all_count > 0
-      failure_count.to_f / all_count.to_f * 100
+    def read_and_log_error_rate
+      failures = failure_count
+      success  = success_count
+      rate = error_rate(failures, success)
+      log_metrics(rate, failures, success)
+      rate
     end
 
     def success!
       log_event :success
       circuit_store.delete(storage_key(:half_open))
-      clear_failures!
     end
 
     def failure!
@@ -154,7 +186,7 @@ class Circuitbox
 
     # Store success/failure/open/close data in memcache
     def log_event(event)
-      notifier.notify(event, service, partition)
+      notifier.new(service,partition).notify(event)
       log_event_to_process(event)
 
       if stat_store.present?
@@ -163,6 +195,22 @@ class Circuitbox
       end
     end
 
+    def log_metrics(error_rate, failures, successes)
+      n = notifier.new(service,partition)
+      n.metric_gauge(:error_rate, error_rate)
+      n.metric_gauge(:failure_count, failures)
+      n.metric_gauge(:success_count, successes)
+    end
+
+    def sanitize_options
+      sleep_window = option_value(:sleep_window)
+      time_window  = option_value(:time_window)
+      if sleep_window < time_window
+        notifier.new(service,partition).notify_warning("sleep_window:#{sleep_window} is shorter than time_window:#{time_window}, the error_rate could not be reset properly after a sleep. sleep_window as been set to equal time_window.")
+        @circuit_options[:sleep_window] = option_value(:time_window)
+      end
+    end
+
     # When there is a successful response within a stat interval, clear the failures.
     def clear_failures!
       circuit_store.write(stat_storage_key(:failure), 0, raw: true)
@@ -201,7 +249,14 @@ class Circuitbox
     end
 
     def stat_storage_key(event, options = {})
-      storage_key(:stats, Time.new.change(sec: 0).to_i, event, options)
+      storage_key(:stats, align_time_on_minute, event, options)
+    end
+
+    # return time representation in seconds
+    def align_time_on_minute(time=nil)
+      time      ||= @time_class.now.to_i
+      time_window = option_value(:time_window)
+      time - ( time % time_window ) # remove rest of integer division
     end
 
     def storage_key(*args)
@@ -225,11 +280,11 @@ class Circuitbox
     end
 
     def stats_for_time(time, options = {})
-      stats = { time: time }
+      stats = { time: align_time_on_minute(time) }
       [:success, :failure, :open].each do |event|
         stats[event] = stat_store.read(storage_key(:stats, time, event, options), raw: true) || 0
       end
       stats
     end
   end
-end
+end

data/lib/circuitbox/notifier.rb

@@ -1,12 +1,34 @@
 class Circuitbox
   class Notifier
-    def self.notify(event, service, partition = nil)
-      return unless defined? ActiveSupport::Notifications
-
-      circuit_name = service
-      circuit_name += ":#{partition}" if partition
+    def initialize(service, partition=nil)
+      @service   = service
+      @partition = partition
+    end
 
+    def notify(event)
+      return unless notification_available?
       ActiveSupport::Notifications.instrument("circuit_#{event}", circuit: circuit_name)
     end
+
+    def notify_warning(message)
+      return unless notification_available?
+      ActiveSupport::Notifications.instrument("circuit_warning", { circuit: circuit_name, message: message})
+    end
+
+    def metric_gauge(gauge, value)
+      return unless notification_available?
+      ActiveSupport::Notifications.instrument("circuit_gauge", { circuit: circuit_name, gauge: gauge.to_s, value: value })
+    end
+
+    private
+    def circuit_name
+      circuit_name = @service.to_s
+      circuit_name += ":#{@partition}" if @partition
+      circuit_name
+    end
+
+    def notification_available?
+      defined? ActiveSupport::Notifications
+    end
   end
-end
+end

data/lib/circuitbox/version.rb

@@ -1,3 +1,3 @@
 class Circuitbox
-  VERSION = '0.5.2'
+VERSION='0.7.0'
 end

data/test/circuit_breaker_test.rb

@@ -1,5 +1,6 @@
 require 'test_helper'
 require 'circuitbox'
+require 'ostruct'
 
 class CircuitBreakerTest < Minitest::Test
   SUCCESSFUL_RESPONSE_STRING = "Success!"
@@ -11,12 +12,183 @@ class CircuitBreakerTest < Minitest::Test
     Circuitbox::CircuitBreaker.reset
   end
 
+  describe 'initialize' do
+    it 'force sleep_window to equal time_window if it is too short' do
+      circuit = Circuitbox::CircuitBreaker.new(:yammer,
+                                     :sleep_window   =>  1,
+                                     :time_window    => 10
+                                    )
+      assert_equal circuit.option_value(:sleep_window),
+        circuit.option_value(:time_window),
+        'sleep_window has not been corrected properly'
+    end
+  end
+
   def test_goes_into_half_open_state_on_sleep
     circuit = Circuitbox::CircuitBreaker.new(:yammer)
     circuit.send(:open!)
     assert circuit.send(:half_open?)
   end
 
+
+  describe 'ratio' do
+    def cb_options
+      {
+        sleep_window:     300,
+        volume_threshold: 5,
+        error_threshold:  33,
+        timeout_seconds:  1
+      }
+    end
+
+    def setup
+      Circuitbox::CircuitBreaker.reset
+      @circuit = Circuitbox::CircuitBreaker.new(:yammer, cb_options)
+    end
+
+
+    it 'open the circuit on 100% failure' do
+      run_counter = 0
+      10.times do
+        @circuit.run do
+          run_counter += 1
+          raise RequestFailureError
+        end
+      end
+      assert_equal 6, run_counter, 'the circuit did not open after 6 failures (5 failures + 10%)'
+    end
+
+    it 'keep circuit closed on 0% failure' do
+      run_counter = 0
+      10.times do
+        @circuit.run do
+          run_counter += 1
+          'sucess'
+        end
+      end
+      assert_equal 10, run_counter, 'run block was not executed 10 times'
+    end
+
+    it 'open the circuit even after 1 success' do
+      run_counter = 0
+      5.times do
+        @circuit.run do
+          run_counter += 1
+          raise RequestFailureError
+        end
+      end
+
+      # one success
+      @circuit.run { 'success'}
+      assert_equal 5, @circuit.failure_count, 'the total count of failures is not 5'
+
+      5.times do
+        @circuit.run do
+          run_counter += 1
+          raise RequestFailureError
+        end
+      end
+      assert_equal 5, run_counter, 'the circuit did not open after 5 failures (5 failures + 10%)'
+    end
+
+    it 'keep circuit closed when failure ratio do not exceed limit' do
+      run_counter = 0
+      7.times do
+        @circuit.run do
+          run_counter += 1
+          'sucess'
+        end
+      end
+      assert_equal 0, @circuit.failure_count, 'some errors were counted'
+
+      3.times do
+        @circuit.run do
+          run_counter += 1
+          raise RequestFailureError
+        end
+      end
+      assert_equal 10, run_counter, 'block was not executed 10 times'
+      assert @circuit.error_rate < 33, 'error_rate pass over 33%'
+    end
+
+    it 'circuit open when failure ratio exceed limit' do
+      run_counter = 0
+      10.times do
+        @circuit.run do
+          run_counter += 1
+          'sucess'
+        end
+      end
+      assert_equal 0, @circuit.failure_count, 'some errors were counted'
+
+      10.times do
+        @circuit.run do
+          run_counter += 1
+          raise RequestFailureError
+        end
+      end
+      # 5 failure on 15 run is 33%
+      assert_equal 15, run_counter, 'block was not executed 10 times'
+      assert @circuit.error_rate >= 33, 'error_rate pass over 33%'
+    end
+
+  end
+
+  describe 'closing the circuit after sleep' do
+    class GodTime < SimpleDelegator
+      def now
+        self
+      end
+
+      def initialize(now=nil)
+        @now = now || Time.now
+        super(@now)
+      end
+
+      def __getobj__
+        @now
+      end
+
+      def __setobj__(obj)
+        @now = obj
+      end
+
+      def jump(interval)
+        __setobj__ @now + interval
+      end
+    end
+
+    def cb_options
+      {
+        sleep_window:     70,
+        time_window:      60,
+        volume_threshold: 5,
+        error_threshold:  33,
+        timeout_seconds:  1,
+        time_class: @timer
+      }
+    end
+
+    def setup
+      @timer   = GodTime.new
+      @circuit = Circuitbox::CircuitBreaker.new(:yammer, cb_options)
+    end
+
+
+    it 'close the circuit after sleeping time' do
+      # lets open the circuit
+      10.times { @circuit.run { raise RequestFailureError } }
+      run_count = 0
+      @circuit.run { run_count += 1 }
+      assert_equal 0, run_count, 'circuit is not open'
+
+      @timer.jump(cb_options[:sleep_window] + 1)
+      @circuit.try_close_next_time
+      @circuit.run { run_count += 1 }
+      assert_equal 1, run_count, 'circuit is not closed'
+    end
+  end
+
   describe "when in half open state" do
     before do
       Circuitbox::CircuitBreaker.reset
@@ -129,7 +301,7 @@ class CircuitBreakerTest < Minitest::Test
 
   def test_open_checks_error_rate_threshold
     circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:open_flag? => false, 
+    circuit.stubs(:open_flag? => false,
                   :passed_volume_threshold? => true)
 
     circuit.expects(:passed_rate_threshold?).once
@@ -138,7 +310,7 @@ class CircuitBreakerTest < Minitest::Test
 
   def test_open_is_false_if_awake_and_under_rate_threshold
     circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:open_flag? => false, 
+    circuit.stubs(:open_flag? => false,
                   :passed_volume_threshold? => false,
                   :passed_rate_threshold => false)
 
@@ -185,12 +357,93 @@ class CircuitBreakerTest < Minitest::Test
     assert_equal 0, circuit.send(:success_count)
   end
 
-  def test_notifies_on_open_circuit
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    Circuitbox::Notifier.expects(:notify).with(:open, :yammer, nil)
-    circuit.send(:log_event, :open)
+  describe 'notifications' do
+
+    def setup
+      Circuitbox::CircuitBreaker.reset
+    end
+
+    def circuit
+      Circuitbox::CircuitBreaker.new(:yammer, :notifier_class => @notifier)
+    end
+
+
+    it 'notifies on open circuit' do
+      @notifier = gimme_notifier
+      c = circuit
+      10.times { c.run { raise RequestFailureError }}
+      assert @notifier.notified?, 'no notification sent'
+    end
+
+    it 'notifies on close circuit' do
+      @notifier = gimme_notifier
+      c = circuit
+      5.times { c.run { raise RequestFailureError }}
+      clear_notified!
+      10.times { c.run { 'success' }}
+      assert @notifier.notified?, 'no notification sent'
+    end
+
+    it 'notifies warning if sleep_window is shorter than time_window' do
+      @notifier = gimme_notifier
+      Circuitbox::CircuitBreaker.new(:yammer,
+                                     :notifier_class => @notifier,
+                                     :sleep_window   =>  1,
+                                     :time_window    => 10
+                                    )
+      assert @notifier.notified?, 'no notification sent'
+    end
+
+    it 'DO NOT notifies warning if sleep_window is longer than time_window' do
+      @notifier = gimme_notifier
+      Circuitbox::CircuitBreaker.new(:yammer,
+                                     :notifier_class => @notifier,
+                                     :sleep_window   => 11,
+                                     :time_window    => 10
+                                    )
+      assert_equal false, @notifier.notified?, 'no notification sent'
+    end
+
+
+    it 'notifies error_rate on error_rate calculation' do
+      @notifier = gimme_notifier(metric: :error_rate, metric_value: 0.0)
+      10.times { circuit.run {'success' }}
+      assert @notifier.notified?, 'no notification sent'
+    end
+
+    it 'notifies failure_count on error_rate calculation' do
+      @notifier = gimme_notifier(metric: :failure_count, metric_value: 1)
+      10.times { circuit.run { raise RequestFailureError  }}
+      assert @notifier.notified?, 'no notification sent'
+    end
+
+    it 'notifies success_count on error_rate calculation' do
+      @notifier = gimme_notifier(metric: :success_count, metric_value: 6)
+      10.times { circuit.run { 'success' }}
+      assert @notifier.notified?, 'no notification sent'
+    end
+
+    def clear_notified!
+      @notified = false
+    end
+
+    def gimme_notifier(opts={})
+      clear_notified!
+      metric       = opts.fetch(:metric,:error_rate)
+      metric_value = opts.fetch(:metric_value, 0.0)
+      warning_msg  = opts.fetch(:warning_msg, '')
+      fake_notifier = gimme
+      give(fake_notifier).notify(:open) { @notified=true }
+      give(fake_notifier).notify(:close) { @notified=true }
+      give(fake_notifier).notify_warning(Gimme::Matchers::Anything.new) { @notified = true }
+      give(fake_notifier).metric_gauge(metric, metric_value) { @notified=true }
+      fake_notifier_class = gimme
+      give(fake_notifier_class).new(:yammer,nil) { fake_notifier }
+      give(fake_notifier_class).notified? { @notified }
+      fake_notifier_class
+    end
   end
-  
+
   def emulate_circuit_run(circuit, response_type, response_value)
     circuit.run do
       case response_type

data/test/notifier_test.rb

@@ -3,8 +3,19 @@ require 'circuitbox/notifier'
 require 'active_support/notifications'
 
 describe Circuitbox::Notifier do
-  it "sends an ActiveSupport::Notification" do
-    ActiveSupport::Notifications.expects(:instrument).with("circuit_open", circuit: :yammer)
-    Circuitbox::Notifier.notify(:open, :yammer)
+  it "[notify] sends an ActiveSupport::Notification" do
+    ActiveSupport::Notifications.expects(:instrument).with("circuit_open", circuit: 'yammer:12')
+    Circuitbox::Notifier.new(:yammer, 12).notify(:open)
   end
-end
+
+  it "[notify_warning] sends an ActiveSupport::Notification" do
+    ActiveSupport::Notifications.expects(:instrument).with("circuit_warning", { circuit: 'yammer:12', message: 'hello'})
+    Circuitbox::Notifier.new(:yammer, 12).notify_warning('hello')
+  end
+
+  it '[gauge] sends an ActiveSupport::Notifier' do
+    ActiveSupport::Notifications.expects(:instrument).with("circuit_gauge", { circuit: 'yammer:12', gauge: 'ratio', value: 12})
+    Circuitbox::Notifier.new(:yammer, 12).metric_gauge(:ratio, 12)
+
+  end
+end

metadata

@@ -1,55 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: circuitbox
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Fahim Ferdous
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-13 00:00:00.000000000 Z
+date: 2014-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rake
   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: bundler-gem_version_tasks
+  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: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A robust circuit breaker that manages failing external services.
@@ -59,7 +73,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - Guardfile
 - LICENSE
@@ -89,12 +103,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []