circuitbox 0.5.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Y2JjODc0MzI1ZWFmMzk3NWExN2VjMTVmYTU5MDg1ZjBlMmI1YTc3OA==
+  data.tar.gz: !binary |-
+    MTJiMjk1YWFkZThhY2FjZDdmYzA1MjUwYWY3OGNiNzE0N2JjMzM5OQ==
+SHA512:
+  metadata.gz: !binary |-
+    OTczMWYyMTZiZjQyZWQ0MmZjNTZmNjM4ZDU5MjI1NjA1YjQzYTZmMTY0OGY1
+    Y2EyYjIwNGZmYTEzMjY4MjVhYTIyODAwNDE5ZTE1Nzk2MWRiNWMyZDI3Yzgx
+    NzM4OWRhMWY1MWU0OTQzMWZiNmU4M2U3NzdiODgwOTE3MDllMmY=
+  data.tar.gz: !binary |-
+    ODA5NDcxMjk0NDI1Mzc1ODU1OWQyMDQ5ZTA5ZWE4NWRhNDczNzFmOWFkMmY4
+    ZDBlNGYzYWEzNDgzMGY0YzM4YzZiZTNjMzI4ZjE2MGFmYzYyMTJiYmViNGEx
+    NDE5YWE1N2VmNjFkZWViNDI5MTdhZWM4ODFjMzRjNDNmNDM3Y2U=

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in circuitbox.gemspec
+gemspec
+
+gem 'activesupport'
+gem 'logger'
+gem 'faraday'
+
+group :test do
+  gem 'timecop'
+  gem 'mocha'
+  gem 'minitest'
+  gem 'guard-minitest'
+  gem 'gimme'
+  gem 'terminal-notifier-guard'
+end

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)_test\.rb$})
+  watch(%r{^lib/circuitbox/([^/]+)\.rb$})     { |m| "test/#{m[1]}_test.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+end

data/LICENSE

@@ -0,0 +1,16 @@
+Copyright (c) 2014. Microsoft Corporation. All Rights Reserved
+All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY
+IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing
+permissions and limitations under the License.

data/README.md

@@ -0,0 +1,119 @@
+# 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.
+
+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)
+
+## Usage
+
+```ruby
+Circuitbox[:your_service] do
+  Net::HTTP.get URI('http://example.com/api/messages')
+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. 
+
+```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")
+    end
+  end
+end
+```
+
+## Configuration
+
+```ruby
+class ExampleServiceClient
+  def circuit
+    Circuitbox.circuit(:your_service, {
+      exceptions:       [YourCustomException],
+
+      # seconds the circuit stays open once it has passed the error threshold
+      sleep_window:     300,     
+
+      # number of requests within 1 minute before it calculates error rates
+      volume_threshold: 10,      
+
+      # exceeding this rate will open the circuit 
+      error_threshold:  50,
+
+      # seconds before the circuit times out      
+      timeout_seconds:  1        
+    })
+  end
+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, { 
+  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. 
+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. 
+
+```ruby
+require 'faraday'
+require 'circuitbox/faraday_middleware'
+
+conn = Faraday::Connection.new(:url => "http://example.com") do |builder|
+  builder.use Circuitbox::FaradayMiddleware
+end
+
+if response = conn.get("/api")
+  # success
+else
+  # failure or open circuit
+end
+```
+
+## TODO
+* Fix Faraday integration to return a Faraday response object
+* Split stats into it's own repository
+* Circuit Breaker should raise an exception by default instead of returning nil
+* Refactor to use single state variable
+* Fix the partition hack
+* Integrate with Breakerbox/Hystrix
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'circuitbox'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install circuitbox
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+require 'bundler/yammer_gem_tasks'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc "Run tests"
+task :default => :test

data/circuitbox.gemspec

@@ -0,0 +1,25 @@
+# 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", "~> 1.4"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "activesupport"
+end

data/lib/circuitbox/circuit_breaker.rb

@@ -0,0 +1,235 @@
+class Circuitbox
+  class CircuitBreaker
+    attr_accessor :service, :circuit_options, :exceptions, :partition,
+                  :logger, :stat_store, :circuit_store, :notifier
+
+    DEFAULTS = {
+      sleep_window:     300,
+      volume_threshold: 5,
+      error_threshold:  50,
+      timeout_seconds:  1
+    }
+
+    #
+    # Configuration options
+    #
+    # `sleep_window`      - seconds to sleep the circuit
+    # `volume_threshold`  - number of requests before error rate calculation occurs
+    # `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
+    #
+    def initialize(service, options = {})
+      @service = service
+      @circuit_options = options
+      @circuit_store   = options.fetch(:cache) { Circuitbox.circuit_store }
+      @notifier        = Circuitbox::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 }
+    end
+
+    def option_value(name)
+      value = circuit_options.fetch(name) { DEFAULTS.fetch(name) }
+      value.is_a?(Proc) ? value.call : value
+    end
+
+    def run(run_options = {}, &block)
+      @partition = run_options.delete(:partition) # sorry for this hack.
+      cache_key  = run_options.delete(:storage_key)
+
+      if open?
+        logger.debug "[CIRCUIT] open: skipping #{service}"
+        response = nil
+        open! unless open_flag?
+      else
+        logger.debug "[CIRCUIT] closed: querying #{service}"
+
+        begin
+          response = if exceptions.include? Timeout::Error
+            timeout_seconds = run_options.fetch(:timeout_seconds) { option_value(:timeout_seconds) }
+            timeout (timeout_seconds) { yield }
+          else
+            yield
+          end
+
+          logger.debug "[CIRCUIT] closed: #{service} querie success"
+          cache_response(cache_key, response) if cache_key
+          success!
+        rescue *exceptions => exception
+          logger.debug "[CIRCUIT] closed: detected #{service} failure"
+          failure!
+          response = cache_key ? get_cached_response(cache_key) : nil
+          open! if half_open?
+        end
+      end
+
+      return response
+    end
+
+    def open?
+      if open_flag?
+        true
+      elsif passed_volume_threshold? && passed_rate_threshold?
+        true
+      else
+        false
+      end
+    end
+
+    def stats(partition)
+      @partition = partition
+      options = { without_partition: @partition.blank? }
+
+      stats = []
+      end_time = Time.now
+      hour = 48.hours.ago.change(min: 0, sec: 0)
+      while hour <= end_time
+        time_object = hour
+
+        60.times do |i|
+          time = time_object.change(min: i, sec: 0).to_i
+          stats << stats_for_time(time, options) unless time > Time.now.to_i
+        end
+
+        hour += 3600
+      end
+      stats
+    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!
+    end
+
+    def half_open!
+      circuit_store.write(storage_key(:half_open), true)
+    end
+
+    def open_flag?
+      circuit_store.read(storage_key(:asleep)).present?
+    end
+
+    def half_open?
+      circuit_store.read(storage_key(:half_open)).present?
+    end
+
+    def passed_volume_threshold?
+      success_count + failure_count > option_value(:volume_threshold)
+    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
+    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
+    end
+
+    def success!
+      log_event :success
+      circuit_store.delete(storage_key(:half_open))
+      clear_failures!
+    end
+
+    def failure!
+      log_event :failure
+    end
+
+    # Store success/failure/open/close data in memcache
+    def log_event(event)
+      notifier.notify(event, service, partition)
+      log_event_to_process(event)
+
+      if stat_store.present?
+        log_event_to_stat_store(stat_storage_key(event))
+        log_event_to_stat_store(stat_storage_key(event, without_partition: true))
+      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)
+    end
+
+    # Logs to process memory.
+    def log_event_to_process(event)
+      key = stat_storage_key(event)
+      if circuit_store.read(key, raw: true)
+        circuit_store.increment(key)
+      else
+        circuit_store.write(key, 1, raw: true)
+      end
+    end
+
+    # Logs to Memcache.
+    def log_event_to_stat_store(key)
+      if stat_store.read(key, raw: true)
+        stat_store.increment(key)
+      else
+        stat_store.write(key, 1, raw: true)
+      end
+    end
+
+    # For returning stale responses when the circuit is open
+    def response_key(args)
+      Digest::SHA1.hexdigest(storage_key(:cache, args.inspect.to_s))
+    end
+
+    def cache_response(args, response)
+      cache.write(response_key(args), response)
+    end
+
+    def get_cached_response(args)
+      cache.read(response_key(args))
+    end
+
+    def stat_storage_key(event, options = {})
+      storage_key(:stats, Time.new.change(sec: 0).to_i, event, options)
+    end
+
+    def storage_key(*args)
+      options = args.extract_options!
+
+      key = if options[:without_partition]
+        "circuits:#{service}:#{args.join(":")}"
+      else
+        "circuits:#{service}:#{partition}:#{args.join(":")}"
+      end
+
+      return key
+    end
+
+    def timeout(timeout_seconds, &block)
+      Timeout::timeout(timeout_seconds) { block.call }
+    end
+
+    def self.reset
+      Circuitbox.reset
+    end
+
+    def stats_for_time(time, options = {})
+      stats = { time: 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

data/lib/circuitbox/faraday_middleware.rb

@@ -0,0 +1,31 @@
+require 'faraday'
+require 'circuitbox'
+
+class Circuitbox
+  class RequestError < StandardError; end
+
+  class FaradayMiddleware < Faraday::Response::Middleware
+
+    attr_accessor :identifier, :exceptions
+
+    def initialize(app, opts={})
+      @identifier = opts.fetch(:identifier) { ->(env) { env.url }}
+      @exceptions = opts.fetch(:exceptions) { [Faraday::Error::TimeoutError] }
+      super(app)
+    end
+
+    def call(env)
+      id = identifier.respond_to?(:call) ? identifier.call(env) : identifier
+      circuit = Circuitbox.circuit id, :exceptions => exceptions
+      circuit.run do
+        super(env)
+      end
+    end
+
+    def on_complete(env)
+      if !env.success?
+        raise RequestError
+      end
+    end
+  end
+end

data/lib/circuitbox/memcache_store.rb

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,12 @@
+class Circuitbox
+  class Notifier
+    def self.notify(event, service, partition = nil)
+      return unless defined? ActiveSupport::Notifications
+
+      circuit_name = service
+      circuit_name += ":#{partition}" if partition
+
+      ActiveSupport::Notifications.instrument("circuit_#{event}", circuit: circuit_name)
+    end
+  end
+end

data/lib/circuitbox/railtie.rb

@@ -0,0 +1,10 @@
+require 'circuitbox'
+require 'rails'
+
+class Circuitbox
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/circuits.rake"
+    end
+  end
+end

data/lib/circuitbox/version.rb

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

data/lib/circuitbox.rb

@@ -0,0 +1,70 @@
+require 'singleton'
+require 'active_support'
+require 'logger'
+require 'timeout'
+
+require "circuitbox/version"
+require 'circuitbox/memcache_store'
+require 'circuitbox/railtie' if defined?(Rails)  
+require 'circuitbox/circuit_breaker'
+require 'circuitbox/notifier'
+
+class Circuitbox
+  attr_accessor :circuits, :circuit_store, :stat_store
+  cattr_accessor :configure
+
+  def self.instance
+    @@instance ||= new
+  end
+
+  def initialize
+    self.instance_eval(&@@configure) if @@configure
+  end
+
+  def self.configure(&block)
+    @@configure = block if block
+  end
+
+  def self.reset
+    @@instance = nil
+    @@configure = nil
+  end
+
+  def self.circuit_store
+    self.instance.circuit_store ||= ActiveSupport::Cache::MemoryStore.new
+  end
+
+  def self.circuit_store=(store)
+    self.instance.circuit_store = store
+  end
+
+  def self.stat_store
+    self.instance.stat_store
+  end
+
+  def self.stat_store=(store)
+    self.instance.stat_store = store
+  end
+
+  def self.[](service_identifier, options = {})
+    self.circuit(service_identifier, options)
+  end
+
+  def self.circuit(service_identifier, options = {})
+    service_name = self.parameter_to_service_name(service_identifier)
+
+    self.instance.circuits ||= Hash.new
+    self.instance.circuits[service_name] ||= CircuitBreaker.new(service_name, options)
+
+    if block_given?
+      self.instance.circuits[service_name].run { yield }
+    else
+      self.instance.circuits[service_name]
+    end
+  end
+
+  def self.parameter_to_service_name(param)
+    uri = URI(param.to_s)
+    uri.host.present? ? uri.host : param.to_s
+  end
+end

data/lib/tasks/circuits.rake

@@ -0,0 +1,12 @@
+namespace :circuits do
+  task :stats => :environment do
+    service = ENV['SERVICE']
+    partition_key = ENV['PARTITION']
+
+    if service.blank?
+      raise "You must specify a SERVICE env variable, eg. `bundle exec rake circuits:stats SERVICE=yammer`"
+    else
+      pp Circuitbox::CircuitBreaker.new(service).stats(partition_key)
+    end
+  end
+end

data/test/circuit_breaker_test.rb

@@ -0,0 +1,206 @@
+require 'test_helper'
+require 'circuitbox'
+
+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
+
+  def test_goes_into_half_open_state_on_sleep
+    circuit = Circuitbox::CircuitBreaker.new(:yammer)
+    circuit.send(:open!)
+    assert circuit.send(:half_open?)
+  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
+
+  def test_notifies_on_open_circuit
+    circuit = Circuitbox::CircuitBreaker.new(:yammer)
+    Circuitbox::Notifier.expects(:notify).with(:open, :yammer, nil)
+    circuit.send(:log_event, :open)
+  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

data/test/circuitbox_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+require 'circuitbox'
+
+class Circuitbox::ExampleStore < ActiveSupport::Cache::MemoryStore; end
+
+describe Circuitbox do
+  before { Circuitbox.reset }
+  after { Circuitbox.reset }
+
+  describe "Circuitbox.configure" do
+    it "configures instance variables on init" do
+      Circuitbox.configure do
+        self.stat_store = "hello"
+      end
+
+      assert_equal "hello", Circuitbox.stat_store
+    end
+  end
+
+  describe "Circuitbox.circuit_store" do
+    it "is configurable" do
+      example_store = Circuitbox::ExampleStore.new
+      Circuitbox.circuit_store = example_store
+      assert_equal example_store, Circuitbox[:yammer].circuit_store
+    end
+  end
+
+  describe "Circuitbox.stat_store" do
+    it "is configurable" do
+      example_store = Circuitbox::ExampleStore.new
+      Circuitbox.stat_store = example_store
+      assert_equal example_store, Circuitbox[:yammer].stat_store
+    end
+  end
+
+  describe "Circuitbox[:service]" do
+    it "delegates to #circuit" do
+      Circuitbox.expects(:circuit).with(:yammer, {})
+      Circuitbox[:yammer]
+    end
+
+    it "creates a CircuitBreaker instance" do
+      assert Circuitbox[:yammer].is_a? Circuitbox::CircuitBreaker
+    end
+  end
+
+  describe "#circuit" do
+    it "returns the same circuit every time" do
+      assert_equal Circuitbox.circuit(:yammer).object_id, Circuitbox.circuit(:yammer).object_id
+    end
+
+    it "sets the circuit options the first time" do
+      circuit_one = Circuitbox.circuit(:yammer, :sleep_window => 1337)
+      circuit_two = Circuitbox.circuit(:yammer, :sleep_window => 2000)
+
+      assert_equal 1337, circuit_one.option_value(:sleep_window)
+      assert_equal 1337, circuit_two.option_value(:sleep_window)
+    end
+  end
+
+  describe "#parameter_to_service_name" do
+    it "parses out a service name from URI" do
+      service = Circuitbox.parameter_to_service_name("http://api.yammer.com/api/v1/messages")
+      assert_equal "api.yammer.com", service
+    end
+
+    it "uses the parameter as the service name if the parameter is not an URI" do
+      service = Circuitbox.parameter_to_service_name(:yammer)
+      assert_equal "yammer", service
+    end
+  end
+
+end

data/test/faraday_middleware_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+require_relative '../lib/circuitbox/faraday_middleware'
+
+class Circuitbox
+  class FaradayMiddlewareTest < Minitest::Test
+
+    def setup
+      @app = gimme
+      @env = gimme
+      give(@env).url { 'URL' }
+
+      @middleware = FaradayMiddleware.new @app,
+                                          :identifier => 'ID',
+                                          :exceptions => [StandardError]
+    end
+
+    def test_should_use_env_url_proc_if_not_provided_as_identifier
+      middleware = FaradayMiddleware.new @app, :exceptions => gimme
+      assert middleware.identifier.is_a?(Proc)
+      assert_equal 'URL', middleware.identifier.call(@env)
+    end
+
+    def test_should_use_request_error_if_not_provided_as_exception
+      middleware = FaradayMiddleware.new @app, :identifier => 'ID'
+      assert_equal [Faraday::Error::TimeoutError],
+                   middleware.exceptions
+    end
+
+    def test_successful_call
+      @middleware.call(@env)
+    end
+
+    def test_failed_call
+      assert_raises Circuitbox::RequestError do
+        give(@env).success? { false }
+        @middleware.on_complete(@env)
+      end
+    end
+
+  end
+end

data/test/notifier_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+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)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'minitest'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'mocha/mini_test'
+require 'timecop'
+require 'gimme'

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: circuitbox
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+platform: ruby
+authors:
+- Fahim Ferdous
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-13 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: 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.
+email:
+- fahimfmf@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- circuitbox.gemspec
+- lib/circuitbox.rb
+- lib/circuitbox/circuit_breaker.rb
+- lib/circuitbox/faraday_middleware.rb
+- lib/circuitbox/memcache_store.rb
+- lib/circuitbox/notifier.rb
+- lib/circuitbox/railtie.rb
+- lib/circuitbox/version.rb
+- lib/tasks/circuits.rake
+- test/circuit_breaker_test.rb
+- test/circuitbox_test.rb
+- test/faraday_middleware_test.rb
+- test/notifier_test.rb
+- test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A robust circuit breaker that manages failing external services.
+test_files:
+- test/circuit_breaker_test.rb
+- test/circuitbox_test.rb
+- test/faraday_middleware_test.rb
+- test/notifier_test.rb
+- test/test_helper.rb