switch_gear 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6790aad189ffd50ac181d5e5e75fb5bf97e34d4c
+  data.tar.gz: 9486ddff0840167fa1e62ad3f9c63a4ff8d0d90e
+SHA512:
+  metadata.gz: 124441bce6d533ef404e3cdae2f6278182be8586bf069373e3c3ac377ede0a705fe7b408850b21245ac0338c00e4e40f6d42209eed795ad7c397971b95feb095
+  data.tar.gz: 75807a66c3c9b49e8e38cf083b24400a14d60b432bab458407575d0cb714a82473a028dd3ff2d9042aa178d649cad4796767abcd69f824ad80caaa2530406602

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.ruby-version
+Gemfile.lock
+*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.13.7

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at anthony.ross@validic.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Anthony Ross
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# SwitchGear
+
+>In an electric power system, switchgear is the combination of electrical disconnect switches, fuses or circuit breakers used to control, protect and isolate electrical equipment. Switchgears are used both to de-energize equipment to allow work to be done and to clear faults downstream. This type of equipment is directly linked to the reliability of the electricity supply.
+
+SwitchGear is a module that will implement various failover protection layers for deploying apps at scale.  The first module is a lightweight implementation of the famous [Michael Nygard](https://www.martinfowler.com/bliki/CircuitBreaker.html) circuit breaker pattern.
+
+## Installation
+
+This gem is in alpha and is on RubyGems.org. I'm still finalizing the API, but if you wish to help me get to it's first stable release, please do!
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'switch_gear'
+```
+
+And then execute:
+
+    $ bundle install
+
+## Usage
+
+### CircuitBreaker
+
+#### In Memory
+
+Here's an example of how you could use the breaker while making routine calls to a third party service such as Twitter:
+
+```ruby
+require 'switch_gear/circuit_breaker'
+require 'logger'
+
+@logger = Logger.new(STDOUT)
+
+handles = ["joe", "jane", "mary", "steve"]
+
+def get_tweets(twitter_handle)
+  http_result = ["Success!", "Fail"].sample
+  raise RuntimeError.new("Failed to fetch tweets for #{twitter_handle}") if http_result == "Fail"
+  @logger.info "#{http_result} getting tweets for #{twitter_handle}"
+end
+
+breaker = SwitchGear::CircuitBreaker::Memory.new do |cb|
+  cb.circuit = -> (twitter_handle) { get_tweets(twitter_handle) }
+  cb.failure_limit = 2
+  cb.reset_timeout = 5
+end
+
+handles.each do |handle|
+  begin
+    breaker.call(handle)
+  rescue SwitchGear::CircuitBreaker::OpenError
+    @logger.warn "Circuit is open - unable to make calls for #{handle}"
+    sleep breaker.reset_timeout
+  end
+end
+```
+
+You will see output similar to:
+```
+W, [2017-02-12T20:49:12.374971 #85900]  WARN -- : [RuntimeError] - Failed to fetch tweets for joe
+W, [2017-02-12T20:49:12.375049 #85900]  WARN -- : [RuntimeError] - Failed to fetch tweets for jane
+I, [2017-02-12T20:49:17.380771 #85900]  INFO -- : Success! getting tweets for steve
+I, [2017-02-12T20:49:17.380865 #85900]  INFO -- : Circuit closed
+```
+
+Notice that we had two failures in a row for joe and jane.  The circuit breaker was configured to only allow for 2 failures via the `failuire_limit` method.  If another call comes in after two failures, it will raise a `SwitchGear::CircuitBreaker::OpenError` error.  The only way the circuit breaker will be closed again is if the `reset_timeout` period has lapsed.  In our loop we catch the `SwitchGear::CircuitBreaker::OpenError` exception and sleep (don't sleep in production - this is just an example) to allow the Circuit to close.  You can see the timestamp of this log,
+
+```
+I, [2017-02-12T20:49:17.380771 #85900]  INFO -- : Success! getting tweets for steve
+```
+is 5+ seconds after the last error which exceeds the `reset_timeout` - that's why the breaker allowed the method invocation to go get steve's tweets.
+
+
+#### Redis
+
+In an distributed environment the in memory solution of the circuit breaker creates quite a bit of unnecessary work.  If you can imagine 5 servers all running their own circuit breakers, the `failure_limit` has just increased by a factor of 5. Ideally, we want server1's failures and server2's failures to be included for similar breakers.  We do this by using redis where the state of the breaker and the failures are persisted.  Redis is a great choice for this especially since most distributed systems have a redis instance in use.
+
+You can visualize a few servers that were originally in a closed state moving to open upon failures as such:
+
+![img](https://s3.postimg.org/stxckap03/ezgif_com_video_to_gif.gif)
+
+You can set up the `CircuitBreaker` to use the redis adapter like this:
+
+```ruby
+breaker = SwitchGear::CircuitBreaker::Redis.new do |cb|
+  cb.circuit = -> (twitter_handle) { get_tweets(twitter_handle) }
+  cb.client = redis
+  cb.namespace = "get_tweets"
+  cb.failure_limit = 2
+  cb.reset_timeout = 5
+end
+```
+
+You need 2 additional parameters(compared to the `Memory` adapter), they are defined as such:
+
+- `client` - an instance of a `Redis` client.  This gem does not have a hard dependency on a particular redis client but for testing I've used [redis-rb](https://github.com/redis/redis-rb).  Whatever you pass in here simply has to implement a few redis commands such as `sadd`, `del`, `smembers`, `get` and `set`.  The client will ensure these exist before the breaker can be instantiated.
+- `namespace` - A unique name that will be used across servers to sync `state` and `failures`.  I'd recommend `class_name:some_method` or whatever is special about what's being invoked in the `circuit`.
+
+#### Roll Your Own Circuit Breaker
+
+The goal of this project is to help you implement a circuit breaker pattern and be agnostic to the persistence layer.  I did it in memory and in redis both as working implementations to make the gem usable out of the box.  There are other in memory data stores that would work really well with this and so you can easily implement your own.
+
+```ruby
+class MyPreferredAdapter
+  include SwitchGear::CircuitBreaker
+end
+```
+
+## Forthcoming
+
+1. A middleware in Sidekiq using this gem
+2. Better in memory support for async tasks
+3. More examples
+4. More documentation
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/allcentury/circuit_breaker. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "switch_gear"
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/examples/example.rb

@@ -0,0 +1,27 @@
+require 'switch_gear/circuit_breaker'
+require 'logger'
+
+@logger = Logger.new(STDOUT)
+
+handles = ["joe", "jane", "mary", "steve"]
+
+def get_tweets(twitter_handle)
+  http_result = ["Success!", "Fail"].sample
+  raise RuntimeError.new("Failed to fetch tweets for #{twitter_handle}") if http_result == "Fail"
+  @logger.info "#{http_result} getting tweets for #{twitter_handle}"
+end
+
+breaker = SwitchGear::CircuitBreaker::Memory.new do |cb|
+  cb.circuit = -> (twitter_handle) { get_tweets(twitter_handle) }
+  cb.failure_limit = 2
+  cb.reset_timeout = 5
+end
+
+handles.each do |handle|
+  begin
+    breaker.call(handle)
+  rescue SwitchGear::CircuitBreaker::OpenError
+    @logger.warn "Circuit is open - unable to make calls for #{handle}"
+    sleep breaker.reset_timeout
+  end
+end

data/examples/example_redis.rb

@@ -0,0 +1,32 @@
+require 'switch_gear/circuit_breaker'
+require 'logger'
+require 'redis'
+
+@logger = Logger.new(STDOUT)
+
+handles = ["joe", "jane", "mary", "steve"]
+
+def get_tweets(twitter_handle)
+  http_result = ["Success!", "Fail"].sample
+  raise RuntimeError.new("Failed to fetch tweets for #{twitter_handle}") if http_result == "Fail"
+  @logger.info "#{http_result} getting tweets for #{twitter_handle}"
+end
+
+redis = Redis.new
+
+breaker = SwitchGear::CircuitBreaker::Redis.new do |cb|
+  cb.circuit = -> (twitter_handle) { get_tweets(twitter_handle) }
+  cb.client = redis
+  cb.namespace = "get_tweets"
+  cb.failure_limit = 2
+  cb.reset_timeout = 5
+end
+
+handles.each do |handle|
+  begin
+    breaker.call(handle)
+  rescue SwitchGear::CircuitBreaker::OpenError
+    @logger.warn "Circuit is open - unable to make calls for #{handle}"
+    sleep breaker.reset_timeout
+  end
+end

data/lib/switch_gear/circuit_breaker/failure.rb

@@ -0,0 +1,37 @@
+require 'json'
+module SwitchGear
+  module CircuitBreaker
+    class Failure
+      def self.from_json(json)
+        failure = JSON.parse(json)
+        error = Object.const_get(failure["error"])
+        error = error.new(failure["message"])
+        new(error, Time.parse(failure["timestamp"]))
+      end
+
+      def initialize(error, recorded = Time.now.utc)
+        @error = error
+        @recorded = recorded
+      end
+
+      def timestamp
+        recorded
+      end
+
+      def to_s
+        "[#{error.class}] - #{error.message}"
+      end
+
+      def to_json
+        JSON.generate({
+          error: error.class,
+          message: error.message,
+          timestamp: timestamp.to_s
+        })
+      end
+
+      private
+      attr_reader :error, :recorded
+    end
+  end
+end

data/lib/switch_gear/circuit_breaker/memory.rb

@@ -0,0 +1,55 @@
+module SwitchGear
+  module CircuitBreaker
+    class Memory
+      include CircuitBreaker
+
+      # The main runner, must respond to #call
+      # @return [Proc/Lambda] the runner
+      attr_accessor :circuit
+      # The count of failures
+      # @return [Integer] the amount of failures to permit.  Defaults to 10 seconds
+      attr_accessor :failure_limit
+      # The amount of time in seconds before a breaker should reset if currently open.  Defaults to 5
+      # @return [Integer]
+      attr_accessor :reset_timeout
+      # The current logger
+      # @return [Object] - The logger sent in at initialization.  Defaults to ruby's std Logger class
+      attr_accessor :logger
+      # The current state
+      # @return [Symbol] should always return either :open, :closed or :half-open.
+      #   Use the helper methods in lib/circuit_breaker.rb for more readable code.
+      attr_accessor :state
+      # The current failures
+      # @return [Array<CircuitBreaker::Failure>] - a list of failures serialized.
+      attr_accessor :failures
+      #
+      # @example create a new breaker
+      #   breaker = SwitchGear::CircuitBreaker::Memory.new do |cb|
+      #     cb.circuit = -> (arg) { my_method(arg) }
+      #     cb.failure_limit = 2
+      #     cb.reset_timeout = 5
+      #   end
+      #
+      # @yieldparam circuit - (look to {#circuit})
+      # @yieldparam failure_limit - (look to {#failure_limit})
+      # @yieldparam reset_timeout - (look to {#reset_timeout})
+      # @yieldparam logger - (look to {#logger})
+      # @return [SwitchGear::CircuitBreaker::Memory] the object.
+      def initialize(&block)
+        yield self
+        @failure_limit ||= 5
+        @reset_timeout ||= 10
+        @logger ||= Logger.new(STDOUT)
+        @state = :closed
+        @failures = []
+        run_validations
+      end
+
+      # (look to {SwitchGear::CircuitBreaker::add_failure})
+      def add_failure(failure)
+        failures << failure
+      end
+
+    end
+  end
+end

data/lib/switch_gear/circuit_breaker/open_error.rb

@@ -0,0 +1,6 @@
+module SwitchGear
+  module CircuitBreaker
+    class OpenError < StandardError
+    end
+  end
+end

data/lib/switch_gear/circuit_breaker/redis.rb

@@ -0,0 +1,113 @@
+module SwitchGear
+  module CircuitBreaker
+    class Redis
+      include CircuitBreaker
+      # (look to {SwitchGear::CircuitBreaker::Memory#circuit})
+      attr_accessor :circuit
+      # (look to {SwitchGear::CircuitBreaker::Memory#failure_limit})
+      attr_accessor :failure_limit
+      # (look to {SwitchGear::CircuitBreaker::Memory#reset_timeout})
+      attr_accessor :reset_timeout
+      # (look to {SwitchGear::CircuitBreaker::Memory#logger})
+      attr_accessor :logger
+      # (look to {SwitchGear::CircuitBreaker::Memory#state})
+      attr_accessor :state
+      # (look to {SwitchGear::CircuitBreaker::Memory#failures})
+      attr_accessor :failures
+      # A unique name that will be used across servers to
+      # sync state and failures.  I'd recommend `your_class.name:your_method_name` or whatever
+      # is special about what's being invoked in the `circuit`.  See examples/example_redis.rb
+      # @return [String] - namespace given
+      attr_accessor :namespace
+
+      # An instance of an redis client.  This library does not have a
+      # hard dependency on a particular redis client but for testing I've used
+      # [redis-rb](https://github.com/redis/redis-rb).  Whatever you pass in here simply has to
+      # implement a few redis commands such as `sadd`, `del`, `smembers`, `get` and `set`.
+      # The client will ensure these exist before the breaker can be instantiated.
+      # @return [Object] - redis client given
+      attr_accessor :client
+
+      # The main class to instantiate the CircuitBraker class.
+      #
+      # @example create a new breaker
+      #   breaker = SwitchGear::CircuitBreaker::Redis.new do |cb|
+      #     cb.circuit = -> (arg) { my_method(arg) }
+      #     cb.failure_limit = 2
+      #     cb.reset_timeout = 5
+      #     cb.client = redis_client
+      #     cb.namespace = "some_key"
+      #   end
+      #
+      # @yieldparam circuit - (look to {#circuit})
+      # @yieldparam failure_limit - (look to {#failure_limit})
+      # @yieldparam reset_timeout - (look to {#reset_timeout})
+      # @yieldparam logger - (look to {#logger})
+      # @yieldparam client - (look to {#client})
+      # @yieldparam namespace - (look to {#namespace})
+      # @return [SwitchGear::CircuitBreaker::Redis] the object.
+      def initialize
+        yield self
+        @client = client
+        @namespace = namespace
+        @failure_limit ||= 5
+        @reset_timeout ||= 10
+        @logger = Logger.new(STDOUT)
+        run_validations
+        @namespace = "circuit_breaker:#{namespace}"
+      end
+
+      def state
+        redis_state = client.get(state_namespace)
+        return redis_state.to_sym if redis_state
+        # if there is no state stored in redis, set it.
+        self.state = :closed
+      end
+
+      def state=(state)
+        client.set(state_namespace, state.to_s)
+      end
+
+      def failures
+        redis_fails = client.smembers(fail_namespace)
+        return redis_fails.map { |f| Failure.from_json(f) } if redis_fails
+        # if there are no failures in redis, set it to empty
+        self.failures = []
+        []
+      end
+
+      def add_failure(failure)
+        client.sadd(fail_namespace, failure.to_json)
+      end
+
+      # failures= requires we replace what is currently in redis
+      # with the new value so we delete all entries first then add
+      def failures=(failures)
+        client.del(fail_namespace)
+        failures.each { |f| client.sadd(fail_namespace, f.to_json) }
+      end
+
+      private
+
+      def fail_namespace
+        "#{namespace}:failures"
+      end
+
+      def state_namespace
+        "#{namespace}:state"
+      end
+
+      def run_validations
+        # call super to ensure module has what it needs
+        super
+        redis_commands = [:smembers, :get, :set, :sadd, :del]
+        if !redis_commands.all? { |c| client.respond_to?(c) }
+          raise NotImplementedError.new("Missing Methods.  Your client must implement: #{redis_commands}")
+        end
+        if !namespace
+          raise NotImplementedError.new("Missing namespace")
+        end
+      end
+    end
+  end
+end

data/lib/switch_gear/circuit_breaker.rb

@@ -0,0 +1,118 @@
+require "switch_gear/circuit_breaker/failure"
+require 'switch_gear/circuit_breaker/open_error'
+require 'switch_gear/circuit_breaker/memory'
+require 'switch_gear/circuit_breaker/redis'
+require 'logger'
+
+module SwitchGear
+  module CircuitBreaker
+    # Calls the circuit proc/lambda if the circuit is closed or half-open
+    #
+    # @param args [Array<Object>] Any number of Objects to be called with the circuit block.
+    # @return [Void, SwitchGear::CircuitBreaker::Open] No usable return value if successful, but will raise an error if failure_limit is reached or if the circuit is open
+    def call(*args)
+      check_reset_timeout
+      raise OpenError if open?
+      do_run(args, &circuit)
+    end
+
+    # @return [Integer] The count of current failures
+    def failure_count
+      failures.size
+    end
+
+    # @return [Boolean] Whether the circuit is open
+    def open?
+      state == :open
+    end
+
+    # @return [Boolean] Whether the circuit is closed
+    def closed?
+      state == :closed
+    end
+
+    # @return [Boolean] Whether the circuit is half-open
+    def half_open?
+      state == :half_open
+    end
+
+    # @return [Array<SwitchGear::CircuitBreaker::Failure>] a list of current failures
+    def failures
+      must_implement(:failures)
+    end
+
+    # @param failure [Array<SwitchGear::CircuitBreaker::Failure>] a list of failures
+    # @return [void]
+    def failures=(failure)
+      must_implement(:failures=)
+    end
+
+    # @param failure [SwitchGear::CircuitBreaker::Failure] a list of failures
+    # @return [void]
+    def add_failure(failure)
+      must_implement(:add_failure)
+    end
+
+    # @return [Symbol] - either :open, :closed, :half-open
+    def state
+      must_implement(:state)
+    end
+
+    # @param state [Symbol] - either :open, :closed, :half-open
+    # @return [void]
+    def state=(state)
+      must_implement(:state=)
+    end
+
+    private
+
+    def must_implement(arg)
+      raise NotImplementedError.new("You must implement #{arg}.")
+    end
+
+    def do_run(args)
+      yield *args
+      reset_failures
+    rescue => e
+      handle_failure(e)
+    end
+
+    def check_reset_timeout
+      return if !open?
+      if reset_period_lapsed?
+        self.state = :half_open
+      end
+    end
+
+    def reset_period_lapsed?
+      (Time.now.utc - failures.last.timestamp) > reset_timeout
+    end
+
+    def reset_failures
+      self.failures = []
+      self.state = :closed
+      logger.info "Circuit closed"
+    end
+
+    def handle_failure(e)
+      failure = Failure.new(e)
+      add_failure(failure)
+      logger.warn failure.to_s
+      if half_open? || failures.size >= failure_limit
+        self.state = :open
+      else
+        self.state = :closed
+      end
+    end
+
+    def run_validations
+      logger_methods = [:debug, :info, :warn, :error]
+      if !logger_methods.all? { |e| logger.respond_to?(e) }
+        raise NotImplementedError.new("Your logger must respond to #{logger_methods}")
+      end
+      if !circuit.respond_to?(:call)
+        raise NotImplementedError.new("Your circuit must respond to #call")
+      end
+    end
+  end
+end

data/lib/switch_gear/version.rb

@@ -0,0 +1,3 @@
+module SwitchGear
+  VERSION = "0.2.0"
+end

data/lib/switch_gear.rb

@@ -0,0 +1,3 @@
+require_relative 'switch_gear/circuit_breaker'
+module SwitchGear
+end

data/switch_gear.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'switch_gear/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "switch_gear"
+  spec.version       = SwitchGear::VERSION
+  spec.authors       = ["Anthony Ross"]
+  spec.email         = ["anthony.s.ross@gmail.com"]
+
+  spec.summary       = %q{SwitchGear is a library containing the Circuit Breaker pattern}
+  spec.description   = %q{SwitchGear is a library which contains the Circuit Breaker pattern.  It is used to prevent constant fail-over from spotty remote systems}
+  spec.homepage      = "https://github.com/allcentury/switch_gear"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.metadata["yard.run"] = "yri"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "timecop", "~> 0.8"
+  spec.add_development_dependency "simplecov", "~> 0.13"
+  spec.add_development_dependency "yard", "~> 0.9"
+  spec.add_development_dependency "redis", "~> 3.3"
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: switch_gear
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Anthony Ross
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: SwitchGear is a library which contains the Circuit Breaker pattern.  It
+  is used to prevent constant fail-over from spotty remote systems
+email:
+- anthony.s.ross@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/example.rb
+- examples/example_redis.rb
+- lib/switch_gear.rb
+- lib/switch_gear/circuit_breaker.rb
+- lib/switch_gear/circuit_breaker/failure.rb
+- lib/switch_gear/circuit_breaker/memory.rb
+- lib/switch_gear/circuit_breaker/open_error.rb
+- lib/switch_gear/circuit_breaker/redis.rb
+- lib/switch_gear/version.rb
+- remote-loop.gif
+- remote.gif
+- switch_gear.gemspec
+homepage: https://github.com/allcentury/switch_gear
+licenses:
+- MIT
+metadata:
+  yard.run: yri
+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.6.8
+signing_key: 
+specification_version: 4
+summary: SwitchGear is a library containing the Circuit Breaker pattern
+test_files: []