circuitbox 0.10.4 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5dd97fd3064e288e32ebae417b38a8e4e95439e4
-  data.tar.gz: 0b5ede74d70a2bfeffaf8178304afb24e3ac1c61
+  metadata.gz: d0fe08dafcf12318b2880700034caf98461a2f3e
+  data.tar.gz: f136784e4d4d32ffa0b53580fb64eded3bf4d5ba
 SHA512:
-  metadata.gz: 7b6dfa97e8ea99ddf7d3ff06c08460e7820a07461f8c4c9cedf84c012879ba72870ae9f032cc6047e1121024ba64329ae2f9c96929f05e90268569f6279a0c9c
-  data.tar.gz: 9870a54f290f71a377ae850cc02945d6f76eeec7c5dc3627cf710e67adeb844cc14eaaf4341683508fb9c81e1e8d35f7fc51f841874dbf5163c1bca251b49cf7
+  metadata.gz: 0e2870b5f3b3cffd2623f04937be7794fe2ee0085655b65b2533da3ba421e9e7772c4b85593097f300aa4f0984b484f590a8811eb22b667a31e7a8d81c9070d2
+  data.tar.gz: c98b3b8e64b4def135717ae7eedb833807d4a484cb6772d284c38c08cb992013a8adc64041ffaddb529fdfecda187287160216467940b63c252a5d3ce765bcb7

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
+.vagrant
 *.rbc
 .bundle
 .config
@@ -13,6 +14,7 @@ pkg
 rdoc
 spec/reports
 test/tmp
+test/reports
 test/version_tmp
 tmp
 .idea

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/.travis.yml

@@ -4,3 +4,5 @@ rvm:
   - 2.0.0
   - 2.1
   - 2.2
+before_install:
+   - gem install bundler

data/Gemfile

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

data/README.md

@@ -57,6 +57,10 @@ class ExampleServiceClient
       # number of requests within 1 minute before it calculates error rates
       volume_threshold: 10,
 
+      # the store you want to use to save the circuit state so it can be
+      # tracked, this needs to be Moneta compatible, and support increment
+      cache: Moneta.new(:Memory)
+
       # exceeding this rate will open the circuit
       error_threshold:  50,
 
@@ -75,6 +79,19 @@ Circuitbox.circuit(:yammer, {
 })
 ```
 
+## Circuit Store (:cache)
+
+Holds all the relevant data to trip the circuit if a given number of requests
+fail in a specified period of time. The store is based on
+[Moneta](https://github.com/minad/moneta) so there are a lot of stores to choose
+from. There are some pre-requisits they need to satisfy so:
+
+- Need to support increment, this is true for most but not all available stores.
+- Need to support concurrent access if you share them. For example sharing a
+  KyotoCabinet store across process fails because the store is single writer
+  multiple readers, and all circuits sharing the store need to be able to write.
+
+
 ## Monitoring & Statistics
 
 You can also run `rake circuits:stats SERVICE={service_name}` to see successes, failures and opened circuits.
@@ -136,6 +153,74 @@ end
 
 ```
 
+### Multi process Circuits
+
+`circuit_store` is backed by [Moneta](https://github.com/minad/moneta) which
+supports multiple backends. This can be configured by passing `cache:
+Moneta.new(:PStore, file: "myfile.store")` to use for example the built in
+PStore ruby library for persisted store, which can be shared cross process.
+
+Depending on your requirements different stores can make sense, see the
+benchmarks and [moneta
+feature](https://github.com/minad/moneta#backend-feature-matrix) matrix for
+details.
+
+```
+user     system      total        real
+memory:    1.440000   0.140000   1.580000 (  1.579244)
+lmdb:      4.330000   3.280000   7.610000 ( 13.086398)
+pstore:   23.680000   4.350000  28.030000 ( 28.094312)
+daybreak:  2.270000   0.450000   2.720000 (  2.626748)
+```
+
+You can run the benchmarks yourself by running `rake benchmark`.
+
+### Memory
+
+An in memory store, which is local to the process. This is not threadsafe so it
+is not useable with multithreaded webservers for example. It is always going to
+be the fastest option if no multi-process or thread is required, like in
+development on Webbrick.
+
+This is the default.
+
+```ruby
+Circuitbox.circuit :identifier, cache: Moneta.new(:Memory)
+```
+
+### LMDB
+
+An persisted directory backed store, which is thread and multi process save.
+depends on the `lmdb` gem. It is slower than Memory or Daybreak, but can be
+used in multi thread and multi process environments like like Puma.
+
+```ruby
+require "lmdb"
+Circuitbox.circuit :identifier, cache: Moneta.new(:LMDB, dir: "./", db: "mydb")
+```
+
+### PStore
+
+An persisted file backed store, which comes with the ruby
+[stdlib](http://ruby-doc.org/stdlib-2.3.0/libdoc/pstore/rdoc/PStore.html). It
+has no external dependecies and works on every ruby implementation. Due to it
+being file backed it is multi process save, good for development using Unicorn.
+
+```ruby
+Circuitbox.circuit :identifier, cache: Moneta.new(:PStore, file: "db.pstore")
+```
+
+### Daybreak
+
+Persisted, file backed key value store in pure ruby. It is process save and
+outperforms most other stores in circuitbox. This is recommended for production
+use with Unicorn. It depends on the `daybreak` gem.
+
+```ruby
+require "daybreak"
+Circuitbox.circuit :identifier, cache: Moneta.new(:Daybreak, file: "db.daybreak")
+```
+
 ## Faraday
 
 Circuitbox ships with [Faraday HTTP client](https://github.com/lostisland/faraday) middleware.
@@ -212,6 +297,8 @@ c.use Circuitbox::FaradayMiddleware, open_circuit: lambda { |response| response.
 ## CHANGELOG
 
 ### version next
+- fix URI require missing (https://github.com/yammer/circuitbox/pull/42 @gottfrois)
+- configurable circuitbox store backend via Moneta supporting multi process circuits
 
 ### v0.10.4
 - Issue #39, keep the original backtrace for the wrapped exception around when

data/Rakefile

@@ -6,5 +6,13 @@ Rake::TestTask.new do |t|
   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

@@ -0,0 +1,116 @@
+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
+  before = circuit.open?
+  circuit.run { service }
+  after = circuit.open?
+  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

@@ -27,8 +27,12 @@ Gem::Specification.new do |spec|
   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/circuit_breaker.rb

@@ -118,11 +118,11 @@ class Circuitbox
     end
 
     def failure_count
-      circuit_store.read(stat_storage_key(:failure)).to_i
+      circuit_store.load(stat_storage_key(:failure), raw: true).to_i
     end
 
     def success_count
-      circuit_store.read(stat_storage_key(:success)).to_i
+      circuit_store.load(stat_storage_key(:success), raw: true).to_i
     end
 
     def try_close_next_time
@@ -133,7 +133,7 @@ class Circuitbox
     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)
+      circuit_store.store(storage_key(:asleep), true, expires_in: option_value(:sleep_window).seconds)
       half_open!
       was_open!
     end
@@ -145,24 +145,24 @@ class Circuitbox
     end
 
     def was_open!
-      circuit_store.write(storage_key(:was_open), true)
+      circuit_store.store(storage_key(:was_open), true)
     end
 
     def was_open?
-      circuit_store.read(storage_key(:was_open)).present?
+      circuit_store[storage_key(:was_open)].present?
     end
     ### END
 
     def half_open!
-      circuit_store.write(storage_key(:half_open), true)
+      circuit_store.store(storage_key(:half_open), true)
     end
 
     def open_flag?
-      circuit_store.read(storage_key(:asleep)).present?
+      circuit_store[storage_key(:asleep)].present?
     end
 
     def half_open?
-      circuit_store.read(storage_key(:half_open)).present?
+      circuit_store[storage_key(:half_open)].present?
     end
 
     def passed_volume_threshold?
@@ -219,16 +219,17 @@ class Circuitbox
 
     # 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)
+      circuit_store.store(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)
+      if circuit_store.load(key, raw: true)
         circuit_store.increment(key)
       else
-        circuit_store.write(key, 1, raw: true)
+        # yes we want a string here, as the underlying stores impement this as a native type.
+        circuit_store.store(key, "1", raw: true)
       end
     end
 
@@ -237,7 +238,7 @@ class Circuitbox
       if stat_store.read(key, raw: true)
         stat_store.increment(key)
       else
-        stat_store.write(key, 1, raw: true)
+        stat_store.store(key, 1)
       end
     end
 

data/lib/circuitbox/excon_middleware.rb

@@ -0,0 +1,111 @@
+require 'excon'
+require 'circuitbox'
+
+class Circuitbox
+  class ExconMiddleware < Excon::Middleware::Base
+    class RequestFailed < StandardError; end
+
+    DEFAULT_EXCEPTIONS = [
+      Excon::Errors::Timeout,
+      RequestFailed
+    ]
+
+    class NullResponse < Excon::Response
+      def initialize(response, exception)
+        @original_response = response
+        @original_exception = exception
+        super(status: 503, response_headers: {})
+      end
+
+      def []=(key, value)
+        @data[key] = value
+      end
+    end
+
+    attr_reader :opts
+
+    def initialize(stack, opts = {})
+      @stack = stack
+      default_options = { open_circuit: lambda { |response| response[:status] >= 400 } }
+      @opts = default_options.merge(opts)
+      super(stack)
+    end
+
+    def error_call(datum)
+      circuit(datum).run!(run_options(datum)) do
+        raise RequestFailed
+      end
+    rescue Circuitbox::Error => exception
+      circuit_open_value(datum, datum[:response], exception)
+    end
+
+    def request_call(datum)
+      circuit(datum).run!(run_options(datum)) do
+        @stack.request_call(datum)
+      end
+    end
+
+    def response_call(datum)
+      circuit(datum).run!(run_options(datum)) do
+        raise RequestFailed if open_circuit?(datum[:response])
+      end
+      @stack.response_call(datum)
+    rescue Circuitbox::Error => exception
+      circuit_open_value(datum, datum[:response], exception)
+    end
+
+    def identifier
+      @identifier ||= opts.fetch(:identifier, ->(env) { env[:path] })
+    end
+
+    def exceptions
+      circuit_breaker_options[:exceptions]
+    end
+
+    private
+
+    def circuit(datum)
+      id = identifier.respond_to?(:call) ? identifier.call(datum) : identifier
+      circuitbox.circuit id, circuit_breaker_options
+    end
+
+    def run_options(datum)
+      opts.merge(datum)[:circuit_breaker_run_options] || {}
+    end
+
+    def open_circuit?(response)
+      opts[:open_circuit].call(response)
+    end
+
+    def circuitbox
+      @circuitbox ||= opts.fetch(:circuitbox, Circuitbox)
+    end
+
+    def circuit_open_value(env, response, exception)
+      env[:circuit_breaker_default_value] || default_value.call(response, exception)
+    end
+
+    def circuit_breaker_options
+      return @circuit_breaker_options if @current_adapter
+
+      @circuit_breaker_options = opts.fetch(:circuit_breaker_options, {})
+      @circuit_breaker_options.merge!(
+        exceptions: opts.fetch(:exceptions, DEFAULT_EXCEPTIONS)
+      )
+    end
+
+    def default_value
+      return @default_value if @default_value
+
+      default = opts.fetch(:default_value) do
+        lambda { |response, exception| NullResponse.new(response, exception) }
+      end
+
+      @default_value = if default.respond_to?(:call)
+                         default
+                       else
+                         lambda { |*| default }
+                       end
+    end
+  end
+end

data/lib/circuitbox/version.rb

@@ -1,3 +1,3 @@
 class Circuitbox
-VERSION='0.10.4'
+VERSION='0.11.0'
 end

data/lib/circuitbox.rb

@@ -1,11 +1,13 @@
+require 'uri'
 require 'singleton'
 require 'active_support'
 require 'logger'
 require 'timeout'
+require 'moneta'
 
 require 'circuitbox/version'
 require 'circuitbox/memcache_store'
-require 'circuitbox/railtie' if defined?(Rails)  
+require 'circuitbox/railtie' if defined?(Rails)
 require 'circuitbox/circuit_breaker'
 require 'circuitbox/notifier'
 
@@ -35,7 +37,7 @@ class Circuitbox
   end
 
   def self.circuit_store
-    self.instance.circuit_store ||= ActiveSupport::Cache::MemoryStore.new
+    self.instance.circuit_store ||= Moneta.new(:Memory)
   end
 
   def self.circuit_store=(store)

data/test/excon_middleware_test.rb

@@ -0,0 +1,131 @@
+require 'test_helper'
+require 'circuitbox/excon_middleware'
+
+class SentialException < StandardError; end
+
+class Circuitbox
+  class ExconMiddlewareTest < Minitest::Test
+
+    attr_reader :app
+
+    def setup
+      @app = gimme
+    end
+
+    def test_default_identifier
+      env = { path: "sential" }
+      assert_equal "sential", ExconMiddleware.new(app).identifier.call(env)
+    end
+
+    def test_overwrite_identifier
+      middleware = ExconMiddleware.new(app, identifier: "sential")
+      assert_equal middleware.identifier, "sential"
+    end
+
+    def test_overwrite_default_value_generator_lambda
+      stub_circuitbox
+      env = { path: "path" }
+      give(circuitbox).circuit("path", anything) { circuit }
+      give(circuit).run!(anything) { raise Circuitbox::Error }
+      default_value_generator = lambda { |_, _| :sential }
+      middleware = ExconMiddleware.new(app,
+                                         circuitbox: circuitbox,
+                                         default_value: default_value_generator)
+      assert_equal :sential, middleware.error_call(env)
+    end
+
+    def test_overwrite_default_value_generator_static_value
+      stub_circuitbox
+      env = { path: "path" }
+      give(circuitbox).circuit("path", anything) { circuit }
+      give(circuit).run!(anything) { raise Circuitbox::Error }
+      middleware = ExconMiddleware.new(app, circuitbox: circuitbox, default_value: :sential)
+      assert_equal :sential, middleware.error_call(env)
+    end
+
+    def test_default_exceptions
+      middleware = ExconMiddleware.new(app)
+      assert_includes middleware.exceptions, Excon::Errors::Timeout
+      assert_includes middleware.exceptions, ExconMiddleware::RequestFailed
+    end
+
+    def test_overridde_success_response
+      env = { path: "path", response: { status: 400 } }
+      error_response = lambda { |r| r[:status] >= 500 }
+      give(app).response_call(anything) { Excon::Response.new(status: 400) }
+      mw = ExconMiddleware.new(app, open_circuit: error_response)
+      response = mw.response_call(env)
+      assert_kind_of Excon::Response, response
+      assert_equal response.status, 400
+    end
+
+    def test_default_success_response
+      env = { path: "path", response: { status: 400 } }
+      app = gimme
+      give(app).response_call(anything) { Excon::Response.new(status: 400) }
+      response = nil
+
+      mw = ExconMiddleware.new(app)
+      response = mw.response_call(env)
+
+      assert_kind_of Excon::Response, response
+      assert_equal response.status, 503
+    end
+
+    def test_overwrite_exceptions
+      middleware = ExconMiddleware.new(app, exceptions: [SentialException])
+      assert_includes middleware.exceptions, SentialException
+    end
+
+    def test_pass_circuit_breaker_run_options
+      stub_circuitbox
+      give(circuit).run!(:sential)
+      give(circuitbox).circuit("path", anything) { circuit }
+      env = { path: "path", circuit_breaker_run_options: :sential }
+      middleware = ExconMiddleware.new(app, circuitbox: circuitbox)
+      middleware.request_call(env)
+      verify(circuit, 1.times).run!(:sential)
+    end
+
+    def test_pass_circuit_breaker_options
+      stub_circuitbox
+      env = { path: "path" }
+      expected_circuit_breaker_options = {
+        sential: :sential,
+        exceptions: ExconMiddleware::DEFAULT_EXCEPTIONS
+      }
+      give(circuitbox).circuit("path", expected_circuit_breaker_options) { circuit }
+      options = { circuitbox: circuitbox, circuit_breaker_options: { sential: :sential } }
+      middleware = ExconMiddleware.new(app, options)
+      middleware.request_call(env)
+
+      verify(circuitbox, 1.times).circuit("path", expected_circuit_breaker_options)
+    end
+
+    def test_overwrite_circuitbreaker_default_value
+      stub_circuitbox
+      env = { path: "path", circuit_breaker_default_value: :sential }
+      give(circuitbox).circuit("path", anything) { circuit }
+      give(circuit).run!(anything) { raise Circuitbox::Error }
+      middleware = ExconMiddleware.new(app, circuitbox: circuitbox)
+      assert_equal middleware.error_call(env), :sential
+    end
+
+    def test_return_null_response_for_open_circuit
+      stub_circuitbox
+      env = { path: "path" }
+      give(circuit).run!(anything) { raise Circuitbox::Error }
+      give(circuitbox).circuit("path", anything) { circuit }
+      mw = ExconMiddleware.new(app, circuitbox: circuitbox)
+      response = mw.error_call(env)
+      assert_kind_of Excon::Response, response
+      assert_equal response.status, 503
+    end
+
+    attr_reader :circuitbox, :circuit
+    def stub_circuitbox
+      @circuitbox = gimme
+      @circuit = gimme
+    end
+  end
+end

data/test/integration/circuitbox_cross_process_open_test.rb

@@ -0,0 +1,55 @@
+require "integration_helper"
+require "tempfile"
+require "typhoeus/adapters/faraday"
+require "pstore"
+
+class Circuitbox
+
+  class CrossProcessTest < Minitest::Test
+    include IntegrationHelpers
+
+    attr_reader :connection, :failure_url, :dbfile
+
+    @@only_once = false
+    def setup
+      if !@@only_once
+        @dbfile = Tempfile.open("circuitbox_test_cross_process")
+      end
+
+      @connection = Faraday.new do |c|
+        c.use FaradayMiddleware, identifier: "circuitbox_test_cross_process",
+          circuit_breaker_options: { cache: Moneta.new(:PStore, file: dbfile) }
+        c.adapter :typhoeus # support in_parallel
+      end
+      @failure_url = "http://localhost:4713"
+
+      if !@@only_once
+        thread = Thread.new do
+          Rack::Handler::WEBrick.run(Proc.new { |env| ["Failure"] },
+                                     Port: 4713,
+                                     AccessLog: [],
+                                     Logger: WEBrick::Log.new(DEV_NULL))
+        end
+        Minitest.after_run { thread.exit }
+      end
+    end
+
+    def teardown
+      Circuitbox.reset
+    end
+
+    def test_circuit_opens_cross_process
+      # Open the circuit via a different process
+      pid = fork do
+        con = Faraday.new do |c|
+          c.use FaradayMiddleware, identifier: "circuitbox_test_cross_process",
+            circuit_breaker_options: { cache: Moneta.new(:PStore, file: dbfile) }
+        end
+        open_circuit(con)
+      end
+      Process.wait pid
+      response = connection.get(failure_url)
+      assert response.original_response.nil?, "opening the circuit from a different process should be respected in the main process"
+    end
+  end
+end

data/test/integration_helper.rb

@@ -40,9 +40,9 @@ class FakeServer
 end
 
 module IntegrationHelpers
-  def open_circuit
-    volume_threshold = Circuitbox['test'].option_value(:volume_threshold)
-    (volume_threshold + 1).times { connection.get(failure_url) }
+  def open_circuit(c = connection)
+    volume_threshold = Circuitbox::CircuitBreaker::DEFAULTS[:volume_threshold]
+    (volume_threshold + 1).times { c.get(failure_url) }
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: circuitbox
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.11.0
 platform: ruby
 authors:
 - Fahim Ferdous
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-03 00:00:00.000000000 Z
+date: 2016-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  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: logger
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +178,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: lmdb
+  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: daybreak
+  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
@@ -178,6 +220,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: moneta
+  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
@@ -186,17 +242,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/circuit_store_benchmark.rb
 - circuitbox.gemspec
 - lib/circuitbox.rb
 - lib/circuitbox/circuit_breaker.rb
 - lib/circuitbox/errors/error.rb
 - lib/circuitbox/errors/open_circuit_error.rb
 - lib/circuitbox/errors/service_failure_error.rb
+- lib/circuitbox/excon_middleware.rb
 - lib/circuitbox/faraday_middleware.rb
 - lib/circuitbox/memcache_store.rb
 - lib/circuitbox/notifier.rb
@@ -205,7 +264,9 @@ files:
 - lib/tasks/circuits.rake
 - test/circuit_breaker_test.rb
 - test/circuitbox_test.rb
+- test/excon_middleware_test.rb
 - test/faraday_middleware_test.rb
+- test/integration/circuitbox_cross_process_open_test.rb
 - test/integration/faraday_middleware_test.rb
 - test/integration_helper.rb
 - test/notifier_test.rb
@@ -238,7 +299,9 @@ summary: A robust circuit breaker that manages failing external services.
 test_files:
 - test/circuit_breaker_test.rb
 - test/circuitbox_test.rb
+- test/excon_middleware_test.rb
 - test/faraday_middleware_test.rb
+- test/integration/circuitbox_cross_process_open_test.rb
 - test/integration/faraday_middleware_test.rb
 - test/integration_helper.rb
 - test/notifier_test.rb