circuitbox 1.1.0 → 2.0.0.pre4

data/.gitignore

@@ -1,20 +0,0 @@
-*.gem
-.vagrant
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/reports
-test/version_tmp
-tmp
-.idea

data/.ruby-version

@@ -1 +0,0 @@
-2.2.2

data/.travis.yml

@@ -1,9 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2
-  - 2.2.2
-before_install:
-   - gem install bundler

data/Gemfile

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in circuitbox.gemspec
-gemspec
-
-gem "pry"

data/Rakefile

@@ -1,18 +0,0 @@
-require 'rake/testtask'
-require "bundler/gem_version_tasks"
-
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/**/*_test.rb']
-end
-
-desc "run the circuitbox benchmark scripts"
-task :benchmark do
-  benchmark_scripts = FileList.new("./benchmark/*_benchmark.rb")
-  benchmark_scripts.each do |script|
-    system "bundle exec ruby #{script}"
-  end
-end
-
-desc "Run tests"
-task :default => :test

data/benchmark/circuit_store_benchmark.rb

@@ -1,114 +0,0 @@
-require 'circuitbox'
-require 'benchmark'
-require 'pstore'
-require 'tempfile'
-require 'tmpdir'
-require 'lmdb'
-require 'pry'
-
-
-class Circuitbox
-  class CircuitBreaker
-    # silence the circuitbreaker logger
-    DEV_NULL = (RUBY_PLATFORM =~ /mswin|mingw/ ? "NUL" : "/dev/null")
-    def logger
-      @_dev_null_logger ||= Logger.new DEV_NULL
-    end
-  end
-end
-
-def service
-  # 10% success rate to make the circuitbreaker flip flop
-  if rand(10) <= 0
-    "success"
-  else
-    raise RuntimeError, "fail"
-  end
-end
-
-def run_flip_flopping circuit
-  circuit.run { service }
-  circuit.try_close_next_time if circuit.open?
-end
-
-def without_gc
-  GC.start
-  GC.disable
-  yield
-  GC.enable
-end
-
-def benchmark_circuitbox_method_with_reporter method, reporter
-  without_gc { send(method, reporter) }
-  Circuitbox.reset
-end
-
-def circuit_with_cache cache
-  Circuitbox.circuit :performance, CIRCUIT_OPTIONS.merge(cache: cache)
-end
-
-CIRCUIT_OPTIONS = {
-  exceptions: [RuntimeError],
-  sleep_window: 0,
-  time_window: 1
-}
-
-RUNS = 10000
-
-def circuit_store_memory_one_process reporter
-  circuit = circuit_with_cache Moneta.new(:Memory)
-
-  reporter.report "memory:" do
-    RUNS.times { run_flip_flopping circuit }
-  end
-
-  circuit.circuit_store.close
-end
-
-def circuit_store_pstore_one_process reporter
-  Tempfile.create("test_circuit_store_pstore_one_process") do |dbfile|
-    circuit = circuit_with_cache Moneta.new(:PStore, file: dbfile)
-
-    reporter.report "pstore:" do
-      RUNS.times { run_flip_flopping circuit }
-    end
-
-    circuit.circuit_store.close
-  end
-end
-
-def circuit_store_lmdb_one_process reporter
-  Dir.mktmpdir("test_circuit_store_lmdb_one_process") do |dbdir|
-    circuit = circuit_with_cache Moneta.new(:LMDB, dir: dbdir, db: "circuitbox_lmdb")
-
-    reporter.report "lmdb:" do
-      RUNS.times { run_flip_flopping circuit }
-    end
-
-    circuit.circuit_store.close
-  end
-end
-
-def circuit_store_daybreak_one_process reporter
-  Tempfile.create("test_circuit_store_daybreak_one_process") do |dbfile|
-    circuit = circuit_with_cache Moneta.new(:Daybreak, file: dbfile)
-
-    reporter.report "daybreak:" do
-      RUNS.times { run_flip_flopping circuit }
-    end
-
-    circuit.circuit_store.close
-  end
-end
-
-Benchmark.bm(8) do |x|
-  benchmark_circuitbox_method_with_reporter :circuit_store_memory_one_process, x
-  benchmark_circuitbox_method_with_reporter :circuit_store_lmdb_one_process, x
-  benchmark_circuitbox_method_with_reporter :circuit_store_pstore_one_process, x
-  benchmark_circuitbox_method_with_reporter :circuit_store_daybreak_one_process, x
-end
-
-
-
-
-

data/circuitbox.gemspec

@@ -1,48 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'circuitbox/version'
-
-ruby_2_2_2_plus = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.2")
-
-Gem::Specification.new do |spec|
-  spec.name          = "circuitbox"
-  spec.version       = Circuitbox::VERSION
-  spec.authors       = ["Fahim Ferdous"]
-  spec.email         = ["fahimfmf@gmail.com"]
-  spec.description   = %q{A robust circuit breaker that manages failing external services.}
-  spec.summary       = %q{A robust circuit breaker that manages failing external services.}
-  spec.homepage      = ""
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  if ruby_2_2_2_plus
-    spec.add_development_dependency "rack"
-  else
-    spec.add_development_dependency "rack", '< 2'
-  end
-  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 "excon"
-  spec.add_development_dependency "logger"
-  spec.add_development_dependency "bundler-gem_version_tasks"
-  spec.add_development_dependency "lmdb"
-  spec.add_development_dependency "daybreak"
-
-  if ruby_2_2_2_plus
-    spec.add_dependency "activesupport"
-  else
-    spec.add_dependency "activesupport", '< 5'
-  end
-  spec.add_dependency "moneta"
-end

data/lib/circuitbox/memcache_store.rb

@@ -1,31 +0,0 @@
-module ActiveSupport
-  module Cache
-    class MemcacheStore
-      def initialize(cache)
-        @cache = cache
-      end
-
-      def read(key, options = {})
-        @cache.get(key, options)
-      rescue Memcached::NotFound
-        nil
-      end
-
-      def increment(key)
-        @cache.incr(key)
-      end
-
-      def write(key, value, options = {})
-        if expires_in = options.delete(:expires_in)
-          options[:expiry] = expires_in.to_i
-        end
-
-        @cache.set(key, value, options)
-      end
-
-      def delete(key)
-        @cache.delete(key)
-      end
-    end
-  end
-end

data/lib/circuitbox/notifier.rb

@@ -1,34 +0,0 @@
-class Circuitbox
-  class Notifier
-    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

data/test/circuit_breaker_test.rb

@@ -1,428 +0,0 @@
-require 'test_helper'
-
-class CircuitBreakerTest < Minitest::Test
-  class ConnectionError < StandardError; end;
-
-  def setup
-    Circuitbox::CircuitBreaker.reset
-  end
-
-  def test_sleep_window_is_forced_to_equal_time_window
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, sleep_window: 1, time_window: 10)
-    assert_equal circuit.option_value(:sleep_window), circuit.option_value(:time_window)
-  end
-
-  def test_goes_into_half_open_state_on_sleep
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.send(:open!)
-    assert circuit.send(:half_open?)
-  end
-
-  class Ratio < Minitest::Test
-    def setup
-      Circuitbox::CircuitBreaker.reset
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer, 
-                                                sleep_window: 300,
-                                                volume_threshold: 5,
-                                                error_threshold: 33,
-                                                timeout_seconds: 1)
-    end
-
-    def test_open_circuit_on_100_percent_failure
-      run_counter = 0
-      10.times do
-        @circuit.run do
-          run_counter += 1
-          raise Timeout::Error
-        end
-      end
-      assert_equal 6, run_counter, 'the circuit did not open after 6 failures (5 failures + 10%)'
-    end
-
-    def test_keep_circuit_closed_on_success
-      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
-
-    def test_open_circuit_on_low_success_rate_below_limit
-      run_counter = 0
-      5.times do
-        @circuit.run do
-          run_counter += 1
-          raise Timeout::Error
-        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 Timeout::Error
-        end
-      end
-      assert_equal 5, run_counter, 'the circuit did not open after 5 failures (5 failures + 10%)'
-    end
-
-    def test_keep_circuit_closed_on_low_failure_rate_below_failure_limit
-      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 Timeout::Error
-        end
-      end
-      assert_equal 10, run_counter, 'block was not executed 10 times'
-      assert @circuit.error_rate < 33, 'error_rate pass over 33%'
-    end
-
-    def test_open_circuit_on_high_failure_rate_exceeding_failure_limit
-      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 Timeout::Error
-        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
-
-  class Exceptions < Minitest::Test
-    class SentinalError < StandardError; end
-    
-    def setup
-      Circuitbox::CircuitBreaker.reset
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer, exceptions: [SentinalError])
-    end
-
-    def test_raises_when_circuit_is_open
-      @circuit.stubs(open_flag?: true)
-      assert_raises(Circuitbox::OpenCircuitError) { @circuit.run! {} }
-    end
-
-    def test_raises_on_service_failure
-      assert_raises(Circuitbox::ServiceFailureError) { @circuit.run! { raise SentinalError } }
-    end
-
-    def test_sets_original_error_on_service_failure
-      @circuit.run! { raise SentinalError }
-    rescue Circuitbox::ServiceFailureError => service_failure_error
-      assert_instance_of SentinalError, service_failure_error.original
-    end
-  end
-
-  class CloseAfterSleep < Minitest::Test
-    def setup
-      Circuitbox::CircuitBreaker.reset
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer,
-                                                sleep_window: 1,
-                                                time_window: 2,
-                                                volume_threshold: 5,
-                                                error_threshold: 5,
-                                                timeout_seconds: 1)
-    end
-
-    def test_circuit_closes_after_sleep_time_window
-      open_circuit!
-      run_count = 0
-      @circuit.run { run_count += 1 }
-      assert_equal 0, run_count, 'circuit has not opened prior'
-      # it is + 2 on purpose, because + 1 is flaky here
-      sleep @circuit.option_value(:sleep_window) + 2
-
-      @circuit.run { run_count += 1 }
-      assert_equal 1, run_count, 'circuit did not close after sleep'
-    end
-
-    def open_circuit!
-      (@circuit.option_value(:error_threshold) + 1).times { @circuit.run { raise Timeout::Error } }
-    end
-  end
-
-  class HalfOpenState < Minitest::Test
-    def setup
-      Circuitbox::CircuitBreaker.reset
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    end
-
-    def test_when_in_half_open_state_circuit_opens_on_failure
-      @circuit.stubs(half_open?: true)
-      @circuit.expects(:open!)
-      @circuit.run { raise Timeout::Error }
-    end
-
-    def test_when_in_half_open_state_circuit_closes_on_success
-      @circuit.send(:half_open!)
-      @circuit.run { 'success' }
-      refute @circuit.send(:half_open?)
-      refute @circuit.send(:open?)
-    end
-  end
-
-  def test_should_use_timeout_class_if_exceptions_are_not_defined
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, timeout_seconds: 45)
-    circuit.expects(:timeout).with(45).once
-    emulate_circuit_run(circuit, :success, StandardError)
-  end
-
-  def test_should_not_use_timeout_class_if_custom_exceptions_are_defined
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, exceptions: [ConnectionError])
-    circuit.expects(:timeout).never
-    emulate_circuit_run(circuit, :success, StandardError)
-  end
-
-  def test_should_return_response_if_it_doesnt_timeout
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    response = emulate_circuit_run(circuit, :success, "success")
-    assert_equal "success", response
-  end
-
-  def test_timeout_seconds_run_options_overrides_circuit_options
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, timeout_seconds: 60)
-    circuit.expects(:timeout).with(30).once
-    circuit.run(timeout_seconds: 30) { true }
-  end
-
-  def test_catches_connection_error_failures_if_defined
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [ConnectionError])
-    response = emulate_circuit_run(circuit, :failure, ConnectionError)
-    assert_equal nil, response
-  end
-
-  def test_doesnt_catch_out_of_scope_exceptions
-    sentinal = Class.new(StandardError)
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [ConnectionError, Timeout::Error])
-
-    assert_raises(sentinal) do
-      emulate_circuit_run(circuit, :failure, sentinal)
-    end
-  end
-
-  def test_records_response_failure
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [Timeout::Error])
-    circuit.expects(:log_event).with(:failure)
-    emulate_circuit_run(circuit, :failure, Timeout::Error)
-  end
-
-  def test_records_response_success
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.expects(:log_event).with(:success)
-    emulate_circuit_run(circuit, :success, "success")
-  end
-
-  def test_does_not_send_request_if_circuit_is_open
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:open? => true)
-    circuit.expects(:yield).never
-    response = emulate_circuit_run(circuit, :failure, Timeout::Error)
-    assert_equal nil, response
-  end
-
-  def test_returns_nil_response_on_failed_request
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    response = emulate_circuit_run(circuit, :failure, Timeout::Error)
-    assert_equal nil, response
-  end
-
-  def test_puts_circuit_to_sleep_once_opened
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:open? => true)
-
-    assert !circuit.send(:open_flag?)
-    emulate_circuit_run(circuit, :failure, Timeout::Error)
-    assert circuit.send(:open_flag?)
-
-    circuit.expects(:open!).never
-    emulate_circuit_run(circuit, :failure, Timeout::Error)
-  end
-
-  def test_open_is_true_if_open_flag
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:open_flag? => true)
-    assert circuit.open?
-  end
-
-  def test_open_checks_if_volume_threshold_has_passed
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:open_flag? => false)
-
-    circuit.expects(:passed_volume_threshold?).once
-    circuit.open?
-  end
-
-  def test_open_checks_error_rate_threshold
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:open_flag? => false,
-                  :passed_volume_threshold? => true)
-
-    circuit.expects(:passed_rate_threshold?).once
-    circuit.open?
-  end
-
-  def test_open_is_false_if_awake_and_under_rate_threshold
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:open_flag? => false,
-                  :passed_volume_threshold? => false,
-                  :passed_rate_threshold => false)
-
-    assert !circuit.open?
-  end
-
-  def test_error_rate_threshold_calculation
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.stubs(:failure_count => 3, :success_count => 2)
-    assert circuit.send(:passed_rate_threshold?)
-
-    circuit.stubs(:failure_count => 2, :success_count => 3)
-    assert !circuit.send(:passed_rate_threshold?)
-  end
-
-  def test_logs_and_retrieves_success_events
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    5.times { circuit.send(:log_event, :success) }
-    assert_equal 5, circuit.send(:success_count)
-  end
-
-  def test_logs_and_retrieves_failure_events
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    5.times { circuit.send(:log_event, :failure) }
-    assert_equal 5, circuit.send(:failure_count)
-  end
-
-  def test_logs_events_by_minute
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-
-    Timecop.travel(Time.now.change(sec: 5))
-    4.times { circuit.send(:log_event, :success) }
-    assert_equal 4, circuit.send(:success_count)
-
-    Timecop.travel(1.minute.from_now)
-    7.times { circuit.send(:log_event, :success) }
-    assert_equal 7, circuit.send(:success_count)
-
-    Timecop.travel(30.seconds.from_now)
-    circuit.send(:log_event, :success)
-    assert_equal 8, circuit.send(:success_count)
-
-    Timecop.travel(50.seconds.from_now)
-    assert_equal 0, circuit.send(:success_count)
-  end
-
-  class Notifications < Minitest::Test
-    def setup
-      Circuitbox::CircuitBreaker.reset
-    end
-
-    def test_notification_on_open
-      notifier = gimme_notifier
-      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)
-      10.times { circuit.run { raise Timeout::Error }}
-      assert notifier.notified?, 'no notification sent'
-    end
-
-    def test_notification_on_close
-      notifier = gimme_notifier
-      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)      
-      5.times { circuit.run { raise Timeout::Error }}
-      notifier.clear_notified!
-      10.times { circuit.run { 'success' }}
-      assert notifier.notified?, 'no notification sent'
-    end
-
-    def test_warning_when_sleep_window_is_shorter_than_time_window
-      notifier = gimme_notifier
-      Circuitbox::CircuitBreaker.new(:yammer,
-                                     notifier_class: notifier,
-                                     sleep_window: 1,
-                                     time_window: 10)
-      assert notifier.notified?, 'no notification sent'
-    end
-
-    def test_does_not_warn_on_sleep_window_being_correctly_sized
-      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
-
-    def test_notifies_on_success_rate_calculation
-      notifier = gimme_notifier(metric: :error_rate, metric_value: 0.0)
-      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)      
-      10.times { circuit.run { "success" } }
-      assert notifier.notified?, "no notification sent"
-    end
-
-    def test_notifies_on_error_rate_calculation
-      notifier = gimme_notifier(metric: :failure_count, metric_value: 1)
-      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)
-      10.times { circuit.run { raise Timeout::Error  }}
-      assert notifier.notified?, 'no notification sent'
-    end
-
-    def test_success_count_on_error_rate_calculation
-      notifier = gimme_notifier(metric: :success_count, metric_value: 6)
-      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)      
-      10.times { circuit.run { 'success' }}
-      assert notifier.notified?, 'no notification sent'
-    end
-
-    def gimme_notifier(opts={})
-      metric = opts.fetch(:metric,:error_rate)
-      metric_value = opts.fetch(:metric_value, 0.0)
-      warning_msg = opts.fetch(:warning_msg, '')
-      fake_notifier = gimme
-      notified = false
-      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 }
-      give(fake_notifier_class).clear_notified! { notified = false }
-      fake_notifier_class
-    end
-  end
-
-  def emulate_circuit_run(circuit, response_type, response_value)
-    circuit.run do
-      case response_type
-      when :failure
-        raise response_value
-      when :success
-        response_value
-      end
-    end
-  rescue Timeout::Error
-    nil
-  end
-end