circuitbox 1.0.3 → 2.0.0.pre3

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.1.5

data/.travis.yml

@@ -1,8 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 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,38 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'circuitbox/version'
-
-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"
-  spec.add_development_dependency "rack"
-  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"
-
-  spec.add_dependency "activesupport"
-  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,449 +0,0 @@
-require 'test_helper'
-require 'ostruct'
-
-class CircuitBreakerTest < Minitest::Test
-  SUCCESSFUL_RESPONSE_STRING = "Success!"
-  RequestFailureError = Timeout::Error
-  class ConnectionError < StandardError; end;
-  class SomeOtherError < StandardError; end;
-
-  def setup
-    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 'exceptions' do
-    before do
-      Circuitbox::CircuitBreaker.reset
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer, exceptions: [SomeOtherError])
-    end
-
-    it 'raises exception when circuit is open' do
-      @circuit.stubs(open_flag?: true)
-      -> { @circuit.run! {} }.must_raise Circuitbox::OpenCircuitError
-    end
-
-    it 'raises exception when service fails' do
-      err = -> { @circuit.run! { raise SomeOtherError } }.must_raise Circuitbox::ServiceFailureError
-      err.original.must_be_instance_of SomeOtherError
-    end
-  end
-
-  describe 'closing the circuit after sleep' do
-    def cb_options
-      {
-        sleep_window:     1,
-        time_window:      2,
-        volume_threshold: 5,
-        error_threshold:  5,
-        timeout_seconds:  1
-      }
-    end
-
-    def setup
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer, cb_options)
-    end
-
-    it 'close the circuit after sleeping time' do
-      # lets open the circuit
-      (cb_options[:error_threshold] + 1).times { @circuit.run { raise RequestFailureError } }
-      run_count = 0
-      @circuit.run { run_count += 1 }
-      assert_equal 0, run_count, 'circuit is not open'
-      # it is + 2 on purpose, because + 1 is flaky here
-      sleep cb_options[:sleep_window] + 2
-
-      @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
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    end
-
-    it "opens circuit on next failed request" do
-      @circuit.stubs(half_open?: true)
-      @circuit.expects(:open!)
-      @circuit.run { raise RequestFailureError }
-    end
-
-    it "closes circuit on successful request" do
-      @circuit.send(:half_open!)
-      @circuit.run { 'success' }
-      assert !@circuit.send(:half_open?)
-      assert !@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, SUCCESSFUL_RESPONSE_STRING)
-    assert_equal SUCCESSFUL_RESPONSE_STRING, 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
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [ConnectionError, RequestFailureError])
-
-    assert_raises SomeOtherError do
-      emulate_circuit_run(circuit, :failure, SomeOtherError)
-    end
-  end
-
-  def test_records_response_failure
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [RequestFailureError])
-    circuit.expects(:log_event).with(:failure)
-    emulate_circuit_run(circuit, :failure, RequestFailureError)
-  end
-
-  def test_records_response_success
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    circuit.expects(:log_event).with(:success)
-    emulate_circuit_run(circuit, :success, SUCCESSFUL_RESPONSE_STRING)
-  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, RequestFailureError)
-    assert_equal nil, response
-  end
-
-  def test_returns_nil_response_on_failed_request
-    circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    response = emulate_circuit_run(circuit, :failure, RequestFailureError)
-    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, RequestFailureError)
-    assert circuit.send(:open_flag?)
-
-    circuit.expects(:open!).never
-    emulate_circuit_run(circuit, :failure, RequestFailureError)
-  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
-
-  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
-      when :failure
-        raise response_value
-      when :success
-        response_value
-      end
-    end
-  rescue RequestFailureError
-    nil
-  end
-end