faulty 0.4.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e68341d29ccefb2a4fa4c265f3f2d5ec37371d37cb41d5a186b3f25d2130b46
-  data.tar.gz: 56e659d66871738e8818c4874102de04ef97873cb0d1c444d58259c875b21378
+  metadata.gz: e07febd816231284cfdc3f2f75e05381a26fb933af81e036c24bff019dcb1f2d
+  data.tar.gz: 3804c68b52a5fca7053a94bfb533444a3bb4250fbffe5ab7e966f1246629feaa
 SHA512:
-  metadata.gz: 7db7b915923132bd1e5d234245cc5a3adb5988013f4baf8fadc59f89bacfde6828310954f0d6ea9da59ed18c97b9224e3d0f9e02ce2700ef9f6240e8b14d3706
-  data.tar.gz: 578d4f0473ff58b1a9f6aeb3d2eab4be158de92943d6147e1521212068578ecd190094e17b02838919561d43b477b197344804478aa8288e70d0c30b26f85fd9
+  metadata.gz: c8753deac6a63980050cb5a2a016515f45dafadcbebe356c8409e984ffd6d01d65f7c2b1b11c9c77bae2ff422601fd45aea7b92c77e0b82733d32cdab11ec9e2
+  data.tar.gz: 7d92e8f081b5902909709f2777d075e224700495259747701ac9a210d334b64a4c89abaf37cfd5546763216eacccb7bb4c6aa3b177e71c6cc0d852d5a245a25a

data/.github/workflows/ci.yml

@@ -25,12 +25,19 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - uses: ruby/setup-ruby@v1
+        env:
+          REDIS_VERSION: ${{ matrix.redis }}
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
       - run: bundle exec rubocop
         if: matrix.ruby == '2.7'
+      - name: start MySQL
+        run: sudo /etc/init.d/mysql start
       - run: bundle exec rspec --format doc
+        env:
+          MYSQL_USER: root
+          MYSQL_PASSWORD: root
       - name: Run codacy-coverage-reporter
         uses: codacy/codacy-coverage-reporter-action@master
         with:

data/.rubocop.yml

@@ -8,6 +8,9 @@ AllCops:
 Layout/ArgumentAlignment:
   EnforcedStyle: with_fixed_indentation
 
+Layout/CaseIndentation:
+  EnforcedStyle: end
+
 Layout/ParameterAlignment:
   EnforcedStyle: with_fixed_indentation
 

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## Release v0.7.0
+
+* Add initial benchmarks and performance improvements #36 justinhoward
+
+### Breaking Changes
+
+The `circuit_success` event no longer contains the status value. Computing this
+value was causing performance problems.
+
+## Release v0.6.0
+
+* docs, use correct state in description for skipped event #27 senny
+* Fix CI to set REDIS_VERSION correctly #31 justinhoward
+* Fix a potential memory leak in patches #32 justinhoward
+* Capture an error for BUSY redis backend when patched #30 justinhoward
+* Add a patch for mysql2 #28 justinhoward
+
+## Release v0.5.1
+
+* Fix Storage::FaultTolerantProxy to return empty history on entries fail #26 justinhoward
+
+## Release v0.5.0
+
+* Allow creating a new Faulty instance in Faulty#register #24 justinhoward
+* Add support for patches to core dependencies starting with redis #14 justinhoward
+* Improve storage #entries performance by returning entries #23 justinhoward
+
+### Breaking Changes
+
+* Faulty #[] no longer differentiates between symbols and strings when accessing
+  Faulty instances
+* Faulty::Storage::Interface must now return a history array instead of a
+  circuit status object. Custom storage backends must be updated.
+
 ## Release v0.4.0
 
 * Switch from Travis CI to GitHub actions #11 justinhoward

data/Gemfile

@@ -13,7 +13,10 @@ not_jruby = %i[ruby mingw x64_mingw].freeze
 gem 'activesupport', '>= 4.2'
 gem 'bundler', '>= 1.17', '< 3'
 gem 'byebug', platforms: not_jruby
+gem 'honeybadger', '>= 2.0'
 gem 'irb', '~> 1.0'
+# Minimum of 0.5.0 for specific error classes
+gem 'mysql2', '>= 0.5.0', platforms: not_jruby
 gem 'redcarpet', '~> 3.5', platforms: not_jruby
 gem 'rspec_junit_formatter', '~> 0.4'
 gem 'simplecov', '>= 0.17.1'

data/README.md

@@ -81,6 +81,9 @@ Also see "Release It!: Design and Deploy Production-Ready Software" by
   + [Circuit Options](#circuit-options)
   + [Listing Circuits](#listing-circuits)
   + [Locking Circuits](#locking-circuits)
+* [Patches](#patches)
+  + [Patch::Redis](#patchredis)
+  + [Patch::Mysql2](#patchmysql2)
 * [Event Handling](#event-handling)
   + [CallbackListener](#callbacklistener)
   + [Other Built-in Listeners](#other-built-in-listeners)
@@ -221,6 +224,10 @@ users = Faulty.circuit(:api).try_run do
 end.or_default([])
 ```
 
+If you want to globally wrap your core dependencies, like your cache or
+database, you may want to look at [Patches](#patches), which can automatically
+wrap your connections in a Faulty circuit.
+
 See [Running a Circuit](#running-a-circuit) for more in-depth examples. Also,
 make sure you have proper [Event Handlers](#event-handling) setup so that you
 can monitor your circuits for failures.
@@ -580,6 +587,14 @@ principal to any other registered Faulty instance:
 Faulty[:api].circuit('api_circuit').run { 'ok' }
 ```
 
+You can also create and register a Faulty instance in one step:
+
+```ruby
+Faulty.register(:api) do |config|
+  # This accepts the same options as Faulty.init
+end
+```
+
 #### Standalone Instances
 
 If you choose, you can use Faulty instances without registering them globally by
@@ -915,6 +930,121 @@ Locking or unlocking a circuit has no concurrency guarantees, so it's not
 recommended to lock or unlock circuits from production code. Instead, locks are
 intended as an emergency tool for troubleshooting and debugging.
 
+## Patches
+
+For certain core dependencies like a cache or a database connection, it is
+inconvenient to wrap every call in its own circuit. Faulty provides some patches
+to wrap these calls in a circuit automatically. To use a patch, it first needs
+to be loaded. Since patches modify third-party code, they are not automatically
+required with the Faulty gem, so they need to be required individually.
+
+```ruby
+require 'faulty'
+require 'faulty/patch/redis'
+```
+
+Or require them in your `Gemfile`
+
+```ruby
+gem 'faulty', require: %w[faulty faulty/patch/redis]
+```
+
+For core dependencies you'll most likely want to use the in-memory circuit
+storage adapter and not the Redis storage adapter. That way if Redis fails, your
+circuit storage doesn't also fail, causing cascading failures.
+
+For example, you can use a separate Faulty instance to manage your Mysql2
+circuit:
+
+```ruby
+# Setup your default config. This can use the Redis backend if you prefer
+Faulty.init do |config|
+  # ...
+end
+
+Faulty.register(:mysql) do |config|
+  # Here we decide to set some circuit defaults more useful for
+  # frequent database calls
+  config.circuit_defaults = {
+    cool_down: 20.0,
+    evaluation_window: 40,
+    sample_threshold: 25
+  }
+end
+
+# Now we can use our "mysql" faulty instance when constructing a Mysql2 client
+Mysql2::Client.new(host: '127.0.0.1', faulty: { instance: 'mysql2' })
+```
+
+### Patch::Redis
+
+[`Faulty::Patch::Redis`](https://www.rubydoc.info/gems/faulty/Faulty/Patch/Redis)
+protects a Redis client with an internal circuit. Pass a `:faulty` key along
+with your connection options to enable the circuit breaker.
+
+The Redis patch supports the Redis gem versions 3 and 4.
+
+```ruby
+require 'faulty/patch/redis'
+
+redis = Redis.new(url: 'redis://localhost:6379', faulty: {
+  # The name for the redis circuit
+  name: 'redis'
+
+  # The faulty instance to use
+  # This can also be a registered faulty instance or a constant name. See API
+  # docs for more details
+  instance: Faulty.default
+
+  # By default, circuit errors will be subclasses of Redis::BaseError
+  # To disable this behavior, set patch_errors to false and Faulty
+  # will raise its default errors
+  patch_errors: true
+})
+redis.connect # raises Faulty::CircuitError if connection fails
+
+# If the faulty key is not given, no circuit is used
+redis = Redis.new(url: 'redis://localhost:6379')
+redis.connect # not protected by a circuit
+```
+
+### Patch::Mysql2
+
+[`Faulty::Patch::Mysql2`](https://www.rubydoc.info/gems/faulty/Faulty/Patch/Mysql2)
+protects a `Mysql2::Client` with an internal circuit. Pass a `:faulty` key along
+with your connection options to enable the circuit breaker.
+
+Faulty supports the mysql2 gem versions 0.5 and greater.
+
+Note: Although Faulty supports Ruby 2.3 in general, the Mysql2 patch is not
+fully supported on Ruby 2.3. It may work for you, but use it at your own risk.
+
+```ruby
+require 'faulty/patch/mysql2'
+
+mysql = Mysql2::Client.new(host: '127.0.0.1', faulty: {
+  # The name for the Mysql2 circuit
+  name: 'mysql2'
+
+  # The faulty instance to use
+  # This can also be a registered faulty instance or a constant name. See API
+  # docs for more details
+  instance: Faulty.default
+
+  # By default, circuit errors will be subclasses of
+  # Mysql2::Error::ConnectionError
+  # To disable this behavior, set patch_errors to false and Faulty
+  # will raise its default errors
+  patch_errors: true
+})
+
+mysql.query('SELECT * FROM users') # raises Faulty::CircuitError if connection fails
+
+# If the faulty key is not given, no circuit is used
+mysql = Mysql2::Client.new(host: '127.0.0.1')
+mysql.query('SELECT * FROM users') # not protected by a circuit
+```
+
 ## Event Handling
 
 Faulty uses an event-dispatching model to deliver notifications of internal
@@ -933,9 +1063,8 @@ events. The full list of events is available from
 - `circuit_reopened` - A circuit execution cause the circuit to reopen from
   half-open. Payload: `circuit`, `error`.
 - `circuit_skipped` - A circuit execution was skipped because the circuit is
-  closed. Payload: `circuit`
-- `circuit_success` - A circuit execution was successful. Payload: `circuit`,
-  `status`
+  open. Payload: `circuit`
+- `circuit_success` - A circuit execution was successful. Payload: `circuit`
 - `storage_failure` - A storage backend raised an error. Payload `circuit` (can
   be nil), `action`, `error`
 

data/bin/benchmark

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'benchmark'
+require 'faulty'
+
+n = 100_000
+
+puts "Starting circuit benchmarks with #{n} iterations each\n\n"
+
+Benchmark.bm(25) do |b|
+  in_memory = Faulty.new(listeners: [])
+  b.report('memory storage') do
+    n.times { in_memory.circuit(:memory).run { true } }
+  end
+
+  b.report('memory storage failures') do
+    n.times do
+      begin
+        in_memory.circuit(:memory_fail, sample_threshold: n + 1).run { raise 'fail' }
+      rescue StandardError
+        # Expected to raise here
+      end
+    end
+  end
+
+  in_memory_large = Faulty.new(listeners: [], storage: Faulty::Storage::Memory.new(max_sample_size: 1000))
+  b.report('large memory storage') do
+    n.times { in_memory_large.circuit(:memory_large).run { true } }
+  end
+end
+
+n = 1_000_000
+
+puts "\n\nStarting extra benchmarks with #{n} iterations each\n\n"
+
+Benchmark.bm(25) do |b|
+  in_memory = Faulty.new(listeners: [])
+
+  log_listener = Faulty::Events::LogListener.new(Logger.new(File::NULL))
+  log_circuit = in_memory.circuit(:log_listener)
+  log_status = log_circuit.status
+  b.report('log listener success') do
+    n.times { log_listener.handle(:circuit_success, circuit: log_circuit, status: log_status) }
+  end
+
+  log_error = StandardError.new('test error')
+  b.report('log listener failure') do
+    n.times { log_listener.handle(:circuit_failure, error: log_error, circuit: log_circuit, status: log_status) }
+  end
+end

data/faulty.gemspec

@@ -26,7 +26,6 @@ Gem::Specification.new do |spec|
   # Only essential development tools and dependencies go here.
   # Other non-essential development dependencies go in the Gemfile.
   spec.add_development_dependency 'connection_pool', '~> 2.0'
-  spec.add_development_dependency 'honeybadger', '>= 2.0'
   spec.add_development_dependency 'redis', '>= 3.0'
   spec.add_development_dependency 'rspec', '~> 3.8'
   # 0.81 is the last rubocop version with Ruby 2.3 support

data/lib/faulty/circuit.rb

@@ -50,6 +50,9 @@ class Faulty
     # @!attribute [r] cool_down
     #   @return [Integer] The number of seconds the circuit will
     #     stay open after it is tripped. Default 300.
+    # @!attribute [r] error_module
+    #   @return [Module] Used by patches to set the namespace module for
+    #     the faulty errors that will be raised. Default `Faulty`
     # @!attribute [r] evaluation_window
     #   @return [Integer] The number of seconds of history that
     #     will be evaluated to determine the failure rate for a circuit.
@@ -88,6 +91,7 @@ class Faulty
       :rate_threshold,
       :sample_threshold,
       :errors,
+      :error_module,
       :exclude,
       :cache,
       :notifier,
@@ -103,6 +107,7 @@ class Faulty
           cache_refreshes_after: 900,
           cool_down: 300,
           errors: [StandardError],
+          error_module: Faulty,
           exclude: [],
           evaluation_window: 60,
           rate_threshold: 0.5,
@@ -115,6 +120,7 @@ class Faulty
           cache
           cool_down
           errors
+          error_module
           exclude
           evaluation_window
           rate_threshold
@@ -213,9 +219,11 @@ class Faulty
       cached_value = cache_read(cache)
       # return cached unless cached.nil?
       return cached_value if !cached_value.nil? && !cache_should_refresh?(cache)
-      return run_skipped(cached_value) unless status.can_run?
 
-      run_exec(cached_value, cache, &block)
+      current_status = status
+      return run_skipped(cached_value) unless current_status.can_run?
+
+      run_exec(current_status, cached_value, cache, &block)
     end
 
     # Force the circuit to stay open until unlocked
@@ -282,7 +290,7 @@ class Faulty
     # @return The result from cache if available
     def run_skipped(cached_value)
       skipped!
-      raise OpenCircuitError.new(nil, self) if cached_value.nil?
+      raise options.error_module::OpenCircuitError.new(nil, self) if cached_value.nil?
 
       cached_value
     end
@@ -292,36 +300,36 @@ class Faulty
     # @param cached_value The cached value if one is available
     # @param cache_key [String, nil] The cache key if one is given
     # @return The run result
-    def run_exec(cached_value, cache_key)
+    def run_exec(status, cached_value, cache_key)
       result = yield
-      success!
+      success!(status)
       cache_write(cache_key, result)
       result
     rescue *options.errors => e
       raise if options.exclude.any? { |ex| e.is_a?(ex) }
 
       if cached_value.nil?
-        raise CircuitTrippedError.new(nil, self) if failure!(e)
+        raise options.error_module::CircuitTrippedError.new(nil, self) if failure!(status, e)
 
-        raise CircuitFailureError.new(nil, self)
+        raise options.error_module::CircuitFailureError.new(nil, self)
       else
         cached_value
       end
     end
 
     # @return [Boolean] True if the circuit transitioned to closed
-    def success!
-      status = storage.entry(self, Faulty.current_time, true)
-      closed = false
-      closed = close! if should_close?(status)
+    def success!(status)
+      storage.entry(self, Faulty.current_time, true)
+      closed = close! if status.half_open?
 
-      options.notifier.notify(:circuit_success, circuit: self, status: status)
+      options.notifier.notify(:circuit_success, circuit: self)
       closed
     end
 
     # @return [Boolean] True if the circuit transitioned to open
-    def failure!(error)
-      status = storage.entry(self, Faulty.current_time, false)
+    def failure!(status, error)
+      entries = storage.entry(self, Faulty.current_time, false)
+      status = Status.from_entries(entries, **status.to_h)
       options.notifier.notify(:circuit_failure, circuit: self, status: status, error: error)
 
       opened = if status.half_open?
@@ -360,16 +368,6 @@ class Faulty
       closed
     end
 
-    # Test whether we should close after a successful run
-    #
-    # Currently this is always true if the circuit is half-open, which is the
-    # traditional behavior for a circuit-breaker
-    #
-    # @return [Boolean] True if we should close the circuit from half-open
-    def should_close?(status)
-      status.half_open?
-    end
-
     # Read from the cache if it is configured
     #
     # @param key The key to read from the cache

data/lib/faulty/error.rb

@@ -28,11 +28,13 @@ class Faulty
     end
   end
 
-  # The base error for all errors raised during circuit runs
-  #
-  class CircuitError < FaultyError
+  # Included in faulty circuit errors to provide common features for
+  # native and patched errors
+  module CircuitErrorBase
     attr_reader :circuit
 
+    # @param message [String]
+    # @param circuit [Circuit] The circuit that raised the error
     def initialize(message, circuit)
       message ||= %(circuit error for "#{circuit.name}")
       @circuit = circuit
@@ -41,6 +43,12 @@ class Faulty
     end
   end
 
+  # The base error for all errors raised during circuit runs
+  #
+  class CircuitError < FaultyError
+    include CircuitErrorBase
+  end
+
   # Raised when running a circuit that is already open
   class OpenCircuitError < CircuitError; end
 

data/lib/faulty/events/callback_listener.rb

@@ -23,7 +23,7 @@ class Faulty
       # @param (see ListenerInterface#handle)
       # @return [void]
       def handle(event, payload)
-        return unless EVENTS.include?(event)
+        return unless EVENT_SET.include?(event)
         return unless @handlers.key?(event)
 
         @handlers[event].each do |handler|

data/lib/faulty/events/honeybadger_listener.rb

@@ -8,11 +8,19 @@ class Faulty
     #
     # The honeybadger gem must be available.
     class HoneybadgerListener
+      HONEYBADGER_EVENTS = Set[
+        :circuit_failure,
+        :circuit_opened,
+        :circuit_reopened,
+        :cache_failure,
+        :storage_failure
+      ].freeze
+
       # (see ListenerInterface#handle)
       def handle(event, payload)
-        return unless EVENTS.include?(event)
+        return unless HONEYBADGER_EVENTS.include?(event)
 
-        send(event, payload) if respond_to?(event, true)
+        send(event, payload)
       end
 
       private

data/lib/faulty/events/log_listener.rb

@@ -16,9 +16,9 @@ class Faulty
 
       # (see ListenerInterface#handle)
       def handle(event, payload)
-        return unless EVENTS.include?(event)
+        return unless EVENT_SET.include?(event)
 
-        send(event, payload) if respond_to?(event, true)
+        send(event, payload)
       end
 
       private
@@ -79,8 +79,10 @@ class Faulty
       end
 
       def log(level, msg, action, extra = {})
-        extra_str = extra.map { |k, v| "#{k}=#{v}" }.join(' ')
-        logger.public_send(level, "#{msg}: #{action} #{extra_str}")
+        @logger.public_send(level) do
+          extra_str = extra.map { |k, v| "#{k}=#{v}" }.join(' ')
+          "#{msg}: #{action} #{extra_str}"
+        end
       end
     end
   end

data/lib/faulty/events.rb

@@ -17,6 +17,8 @@ class Faulty
       circuit_success
       storage_failure
     ].freeze
+
+    EVENT_SET = Set.new(EVENTS)
   end
 end
 

data/lib/faulty/patch/base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Faulty
+  module Patch
+    # Can be included in patch modules to provide common functionality
+    #
+    # The patch needs to set `@faulty_circuit`
+    #
+    # @example
+    #   module ThingPatch
+    #     include Faulty::Patch::Base
+    #
+    #     def initialize(options = {})
+    #       @faulty_circuit = Faulty::Patch.circuit_from_hash('thing', options[:faulty])
+    #     end
+    #
+    #     def do_something
+    #       faulty_run { super }
+    #     end
+    #   end
+    #
+    #   Thing.prepend(ThingPatch)
+    module Base
+      # Run a block wrapped by `@faulty_circuit`
+      #
+      # If `@faulty_circuit` is not set, the block will be run with no
+      # circuit.
+      #
+      # Nested calls to this method will only cause the circuit to be triggered
+      # once.
+      #
+      # @yield A block to run inside the circuit
+      # @return The block return value
+      def faulty_run
+        faulty_running_key = "faulty_running_#{object_id}"
+        return yield unless @faulty_circuit
+        return yield if Thread.current[faulty_running_key]
+
+        Thread.current[faulty_running_key] = true
+        @faulty_circuit.run { yield }
+      ensure
+        Thread.current[faulty_running_key] = nil
+      end
+    end
+  end
+end

data/lib/faulty/patch/mysql2.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'mysql2'
+
+if Gem::Version.new(Mysql2::VERSION) < Gem::Version.new('0.5.0')
+  raise NotImplementedError, 'The faulty mysql2 patch requires mysql2 0.5.0 or later'
+end
+
+class Faulty
+  module Patch
+    # Patch Mysql2 to run connections and queries in a circuit
+    #
+    # This module is not required by default
+    #
+    # Pass a `:faulty` key into your MySQL connection options to enable
+    # circuit protection. See {Patch.circuit_from_hash} for the available
+    # options.
+    #
+    # COMMIT, ROLLBACK, and RELEASE SAVEPOINT queries are intentionally not
+    # protected by the circuit. This is to allow open transactions to be closed
+    # if possible.
+    #
+    # @example
+    #   require 'faulty/patch/mysql2'
+    #
+    #   mysql = Mysql2::Client.new(host: '127.0.0.1', faulty: {})
+    #   mysql.query('SELECT * FROM users') # raises Faulty::CircuitError if connection fails
+    #
+    #   # If the faulty key is not given, no circuit is used
+    #   mysql = Mysql2::Client.new(host: '127.0.0.1')
+    #   mysql.query('SELECT * FROM users') # not protected by a circuit
+    #
+    # @see Patch.circuit_from_hash
+    module Mysql2
+      include Base
+
+      Patch.define_circuit_errors(self, ::Mysql2::Error::ConnectionError)
+
+      QUERY_WHITELIST = [
+        %r{\A(?:/\*.*?\*/)?\s*ROLLBACK}i,
+        %r{\A(?:/\*.*?\*/)?\s*COMMIT}i,
+        %r{\A(?:/\*.*?\*/)?\s*RELEASE\s+SAVEPOINT}i
+      ].freeze
+
+      def initialize(opts = {})
+        @faulty_circuit = Patch.circuit_from_hash(
+          'mysql2',
+          opts[:faulty],
+          errors: [
+            ::Mysql2::Error::ConnectionError,
+            ::Mysql2::Error::TimeoutError
+          ],
+          patched_error_module: Faulty::Patch::Mysql2
+        )
+
+        super
+      end
+
+      # Protect manual connection pings
+      def ping
+        faulty_run { super }
+      rescue Faulty::Patch::Mysql2::FaultyError
+        false
+      end
+
+      # Protect the initial connnection
+      def connect(*args)
+        faulty_run { super }
+      end
+
+      # Protect queries unless they are whitelisted
+      def query(*args)
+        return super if QUERY_WHITELIST.any? { |r| !r.match(args.first).nil? }
+
+        faulty_run { super }
+      end
+    end
+  end
+end
+
+::Mysql2::Client.prepend(Faulty::Patch::Mysql2)

data/lib/faulty/patch/redis.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'redis'
+
+class Faulty
+  module Patch
+    # Patch Redis to run all network IO in a circuit
+    #
+    # This module is not required by default
+    #
+    # Pass a `:faulty` key into your MySQL connection options to enable
+    # circuit protection. See {Patch.circuit_from_hash} for the available
+    # options.
+    #
+    # @example
+    #   require 'faulty/patch/redis'
+    #
+    #   redis = Redis.new(url: 'redis://localhost:6379', faulty: {})
+    #   redis.connect # raises Faulty::CircuitError if connection fails
+    #
+    #   # If the faulty key is not given, no circuit is used
+    #   redis = Redis.new(url: 'redis://localhost:6379')
+    #   redis.connect # not protected by a circuit
+    #
+    # @see Patch.circuit_from_hash
+    module Redis
+      include Base
+
+      Patch.define_circuit_errors(self, ::Redis::BaseConnectionError)
+
+      class BusyError < ::Redis::CommandError
+      end
+
+      # Patches Redis to add the `:faulty` key
+      def initialize(options = {})
+        @faulty_circuit = Patch.circuit_from_hash(
+          'redis',
+          options[:faulty],
+          errors: [
+            ::Redis::BaseConnectionError,
+            BusyError
+          ],
+          patched_error_module: Faulty::Patch::Redis
+        )
+
+        super
+      end
+
+      # The initial connection is protected by a circuit
+      def connect
+        faulty_run { super }
+      end
+
+      # Protect command calls
+      def call(command)
+        faulty_run { super }
+      end
+
+      # Protect command_loop calls
+      def call_loop(command, timeout = 0)
+        faulty_run { super }
+      end
+
+      # Protect pipelined commands
+      def call_pipelined(commands)
+        faulty_run { super }
+      end
+
+      # Inject specific error classes if client is patched
+      #
+      # This method does not raise errors, it returns them
+      # as exception objects, so we simply modify that error if necessary and
+      # return it.
+      #
+      # The call* methods above will then raise that error, so we are able to
+      # capture it with faulty_run.
+      def io(&block)
+        return super unless @faulty_circuit
+
+        reply = super
+        if reply.is_a?(::Redis::CommandError)
+          if reply.message.start_with?('BUSY')
+            reply = BusyError.new(reply.message)
+          end
+        end
+
+        reply
+      end
+    end
+  end
+end
+
+::Redis::Client.prepend(Faulty::Patch::Redis)

data/lib/faulty/patch.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'faulty/patch/base'
+
+class Faulty
+  # Automatic wrappers for common core dependencies like database connections
+  # or caches
+  module Patch
+    class << self
+      # Create a circuit from a configuration hash
+      #
+      # This is intended to be used in contexts where the user passes in
+      # something like a connection hash to a third-party library. For example
+      # the Redis patch hooks into the normal Redis connection options to add
+      # a `:faulty` key, which is a hash of faulty circuit options. This is
+      # slightly different from the normal Faulty circuit options because
+      # we also accept an `:instance` key which is a faulty instance.
+      #
+      # @example
+      #   # We pass in a faulty instance along with some circuit options
+      #   Patch.circuit_from_hash(
+      #     :mysql,
+      #     { host: 'localhost', faulty: {
+      #       name: 'my_mysql', # A custom circuit name can be included
+      #       instance: Faulty.new,
+      #       sample_threshold: 5
+      #       }
+      #     }
+      #   )
+      #
+      # @example
+      #   # instance can be a registered faulty instance referenced by a string
+      #   or symbol
+      #   Faulty.register(:db_faulty, Faulty.new)
+      #   Patch.circuit_from_hash(
+      #     :mysql,
+      #     { host: 'localhost', faulty: { instance: :db_faulty } }
+      #   )
+      # @example
+      #   # If instance is a hash with the key :constant, the value can be
+      #   # a global constant name containing a Faulty instance
+      #   DB_FAULTY = Faulty.new
+      #   Patch.circuit_from_hash(
+      #     :mysql,
+      #     { host: 'localhost', faulty: { instance: { constant: 'DB_FAULTY' } } }
+      #   )
+      #
+      # @example
+      #   # Certain patches may want to enforce certain options like :errors
+      #   # This can be done via hash or the usual block syntax
+      #   Patch.circuit_from_hash(:mysql,
+      #     { host: 'localhost', faulty: {} }
+      #     errors: [Mysql2::Error]
+      #   )
+      #
+      #   Patch.circuit_from_hash(:mysql,
+      #     { host: 'localhost', faulty: {} }
+      #   ) do |conf|
+      #     conf.errors = [Mysql2::Error]
+      #   end
+      #
+      # @param default_name [String] The default name for the circuit
+      # @param hash [Hash] A hash of user-provided options. Supports any circuit
+      #   option and these additional options
+      # @option hash [String] :name The circuit name. Defaults to `default_name`
+      # @option hash [Boolean] :patch_errors By default, circuit errors will be
+      #   subclasses of `options[:patched_error_module]`. The user can disable
+      #   this by setting this option to false.
+      # @option hash [Faulty, String, Symbol, Hash{ constant: String }] :instance
+      #   A reference to a faulty instance. See examples.
+      # @param options [Hash] Additional override options. Supports any circuit
+      #   option and these additional ones.
+      # @option options [Module] :patched_error_module The namespace module
+      #   for patched errors
+      # @yield [Circuit::Options] For setting override options in a block
+      # @return [Circuit, nil] The circuit if one was created
+      def circuit_from_hash(default_name, hash, **options, &block)
+        return unless hash
+
+        hash = symbolize_keys(hash)
+        name = hash.delete(:name) || default_name
+        patch_errors = hash.delete(:patch_errors) != false
+        error_module = options.delete(:patched_error_module)
+        hash[:error_module] ||= error_module if error_module && patch_errors
+        faulty = resolve_instance(hash.delete(:instance))
+        faulty.circuit(name, **hash, **options, &block)
+      end
+
+      # Create a full set of {CircuitError}s with a given base error class
+      #
+      # For patches that need their errors to be subclasses of a common base.
+      #
+      # @param namespace [Module] The module to define the error classes in
+      # @param base [Class] The base class for the error classes
+      # @return [void]
+      def define_circuit_errors(namespace, base)
+        circuit_error = Class.new(base) { include CircuitErrorBase }
+        namespace.const_set('CircuitError', circuit_error)
+        namespace.const_set('OpenCircuitError', Class.new(circuit_error))
+        namespace.const_set('CircuitFailureError', Class.new(circuit_error))
+        namespace.const_set('CircuitTrippedError', Class.new(circuit_error))
+      end
+
+      private
+
+      # Resolves a constant from a constant name or returns a default
+      #
+      # - If value is a string or symbol, gets a registered Faulty instance with that name
+      # - If value is a Hash with a key `:constant`, resolves the value to a global constant
+      # - If value is nil, gets Faulty.default
+      # - Otherwise, return value directly
+      #
+      # @param value [String, Symbol, Faulty, nil] The object or constant name to resolve
+      # @return [Object] The resolved Faulty instance
+      def resolve_instance(value)
+        case value
+        when String, Symbol
+          result = Faulty[value]
+          raise NameError, "No Faulty instance for #{value}" unless result
+
+          result
+        when Hash
+          const_name = value[:constant]
+          raise ArgumentError 'Missing hash key :constant for Faulty instance' unless const_name
+
+          Kernel.const_get(const_name)
+        when nil
+          Faulty.default
+        else
+          value
+        end
+      end
+
+      # Some config files may not suport symbol keys, so we convert the hash
+      # to use symbols so that users can pass in strings
+      #
+      # We cannot use transform_keys since we support Ruby < 2.5
+      #
+      # @param hash [Hash] A hash to convert
+      # @return [Hash] The hash with keys as symbols
+      def symbolize_keys(hash)
+        result = {}
+        hash.each do |key, val|
+          result[key.to_sym] = if val.is_a?(Hash)
+            symbolize_keys(val)
+          else
+            val
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/faulty/status.rb

@@ -64,10 +64,17 @@ class Faulty
     #   sample_size
     # @return [Status]
     def self.from_entries(entries, **hash)
+      window_start = Faulty.current_time - hash[:options].evaluation_window
+      size = entries.size
+      i = 0
       failures = 0
       sample_size = 0
-      entries.each do |(time, success)|
-        next unless time > Faulty.current_time - hash[:options].evaluation_window
+
+      # This is a hot loop, and while is slightly faster than each
+      while i < size
+        time, success = entries[i]
+        i += 1
+        next unless time > window_start
 
         sample_size += 1
         failures += 1 unless success

data/lib/faulty/storage/fault_tolerant_proxy.rb

@@ -94,7 +94,7 @@ class Faulty
         @storage.entry(circuit, time, success)
       rescue StandardError => e
         options.notifier.notify(:storage_failure, circuit: circuit, action: :entry, error: e)
-        stub_status(circuit)
+        []
       end
 
       # Safely mark a circuit as open

data/lib/faulty/storage/interface.rb

@@ -14,7 +14,8 @@ class Faulty
       # @param circuit [Circuit] The circuit that ran
       # @param time [Integer] The unix timestamp for the run
       # @param success [Boolean] True if the run succeeded
-      # @return [Status] The circuit status after the run is added
+      # @return [Array<Array>] An array of the new history tuples after adding
+      #   the new entry, see {#history}
       def entry(circuit, time, success)
         raise NotImplementedError
       end

data/lib/faulty/storage/memory.rb

@@ -89,7 +89,7 @@ class Faulty
           runs.push([time, success])
           runs.shift if runs.size > options.max_sample_size
         end
-        memory.status(circuit.options)
+        memory.runs.value
       end
 
       # Mark a circuit as open

data/lib/faulty/storage/redis.rb

@@ -95,15 +95,15 @@ class Faulty
       # @return (see Interface#entry)
       def entry(circuit, time, success)
         key = entries_key(circuit)
-        pipe do |r|
+        result = pipe do |r|
           r.sadd(list_key, circuit.name)
           r.expire(list_key, options.circuit_ttl + options.list_granularity) if options.circuit_ttl
           r.lpush(key, "#{time}#{ENTRY_SEPARATOR}#{success ? 1 : 0}")
           r.ltrim(key, 0, options.max_sample_size - 1)
           r.expire(key, options.sample_ttl) if options.sample_ttl
+          r.lrange(key, 0, -1)
         end
-
-        status(circuit)
+        map_entries(result.last)
       end
 
       # Mark a circuit as open

data/lib/faulty/version.rb

@@ -3,6 +3,6 @@
 class Faulty
   # The current Faulty version
   def self.version
-    Gem::Version.new('0.4.0')
+    Gem::Version.new('0.7.0')
   end
 end

data/lib/faulty.rb

@@ -9,6 +9,7 @@ require 'faulty/cache'
 require 'faulty/circuit'
 require 'faulty/error'
 require 'faulty/events'
+require 'faulty/patch'
 require 'faulty/result'
 require 'faulty/status'
 require 'faulty/storage'
@@ -66,7 +67,7 @@ class Faulty
     def [](name)
       raise UninitializedError unless @instances
 
-      @instances[name]
+      @instances[name.to_s]
     end
 
     # Register an instance to the global Faulty state
@@ -75,13 +76,22 @@ class Faulty
     # return value if you need to know whether the instance already existed.
     #
     # @param name [Symbol] The name of the instance to register
-    # @param instance [Faulty] The instance to register
+    # @param instance [Faulty] The instance to register. If nil, a new instance
+    #   will be created from the given options or block.
+    # @param config [Hash] Attributes for {Faulty::Options}
+    # @yield [Faulty::Options] For setting options in a block
     # @return [Faulty, nil] The previously-registered instance of that name if
     #   it already existed, otherwise nil.
-    def register(name, instance)
+    def register(name, instance = nil, **config, &block)
       raise UninitializedError unless @instances
 
-      @instances.put_if_absent(name, instance)
+      if instance
+        raise ArgumentError, 'Do not give config options if an instance is given' if !config.empty? || block
+      else
+        instance = new(**config, &block)
+      end
+
+      @instances.put_if_absent(name.to_s, instance)
     end
 
     # Get the options for the default instance

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faulty
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Justin Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-19 00:00:00.000000000 Z
+date: 2021-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -38,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: honeybadger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -138,6 +124,7 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- bin/benchmark
 - bin/check-version
 - bin/console
 - bin/rspec
@@ -165,6 +152,10 @@ files:
 - lib/faulty/events/log_listener.rb
 - lib/faulty/events/notifier.rb
 - lib/faulty/immutable_options.rb
+- lib/faulty/patch.rb
+- lib/faulty/patch/base.rb
+- lib/faulty/patch/mysql2.rb
+- lib/faulty/patch/redis.rb
 - lib/faulty/result.rb
 - lib/faulty/status.rb
 - lib/faulty/storage.rb
@@ -195,8 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Fault-tolerance tools for ruby based on circuit-breakers