faulty 0.5.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95e52bcb5c7e0ea6975567ff5d5ce3e5d00e15f0f7a4dd4c059e1998060c242e
-  data.tar.gz: 8ef55ce3375edcd1a14314baec3e3641b19a2a51da1a838e568a2dd1eff761a7
+  metadata.gz: d963d5c58861cc9e39c3222b5dc78a2a537c15fc10e0ed76d9d5b41a6704356b
+  data.tar.gz: e31811fc1b5be36975982e966106ea7f323b4e334b87cfaca85667f550245584
 SHA512:
-  metadata.gz: 7bf4a244b3d448ec4f7075e3e8eacd6d5777bdf8f3e3e5b033857876651a9be5cacb8f3b78eaabd0881cb18cfc754b0dfb39d5aad0a2105517abc9345612ec4c
-  data.tar.gz: 87f5419f6f75b4efbfeb373f1217a1a505e7d0423a19227114c8700afd1937af210d9ec81b38106f7ad6ea5e0a985d2a2b9b438db01f243d32ac2771ba34a45c
+  metadata.gz: 52aae6a3997fca7d38aebd124399747ee21a687114076e5d73c135d86ab147360e71a9f7a95ee4a5f548b6709089697e77fa472730c3fc18cb9c1d412bdac4ca
+  data.tar.gz: 56b02cad8fe96373c916746bfc7c6f83665a74e7a3771d7b761244373b1d4b79aeb44d94fbe9401f82f8671b4e21c625a079b4845a42565dfbfbdfd37a07d2bf

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/CHANGELOG.md

@@ -1,3 +1,29 @@
+## Release v0.7.2
+
+* Add Faulty.disable! for disabling globally #38 justinhoward
+* Suppress circuit_success for proxy circuits #39 justinhoward
+
+## Release v0.7.1
+
+* Fix success event crash in log listener #37 justinhoward
+
+## 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

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

@@ -83,10 +83,12 @@ Also see "Release It!: Design and Deploy Production-Ready Software" by
   + [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)
   + [Custom Listeners](#custom-listeners)
+* [Disabling Faulty Globally](#disabling-faulty-globally)
 * [How it Works](#how-it-works)
   + [Caching](#caching)
   + [Fault Tolerance](#fault-tolerance)
@@ -948,15 +950,40 @@ Or require them in your `Gemfile`
 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.
 
-Keep in mind that when using this patch, 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.
+The Redis patch supports the Redis gem versions 3 and 4.
 
 ```ruby
 require 'faulty/patch/redis'
@@ -982,6 +1009,43 @@ 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
@@ -1000,9 +1064,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`
 
@@ -1062,6 +1125,21 @@ Faulty.init do |config|
 end
 ```
 
+## Disabling Faulty Globally
+
+For testing or for some environments, you may wish to disable Faulty circuits
+at a global level.
+
+```ruby
+Faulty.disable!
+```
+
+This only affects the process where you run the `#disable!` method and it does
+not affect the stored state of circuits.
+
+Faulty will **still use the cache** even when disabled. If you also want to
+disable the cache, configure Faulty to use a `Faulty::Cache::Null` cache.
+
 ## How it Works
 
 Faulty implements a version of circuit breakers inspired by "Release It!: Design

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/cache/circuit_proxy.rb

@@ -33,7 +33,7 @@ class Faulty
 
           self.circuit ||= Circuit.new(
             Faulty::Storage::CircuitProxy.name,
-            notifier: notifier,
+            notifier: Events::FilterNotifier.new(notifier, exclude: %i[circuit_success]),
             cache: Cache::Null.new
           )
         end

data/lib/faulty/circuit.rb

@@ -319,12 +319,10 @@ class Faulty
 
     # @return [Boolean] True if the circuit transitioned to closed
     def success!(status)
-      entries = storage.entry(self, Faulty.current_time, true)
-      status = Status.from_entries(entries, **status.to_h)
-      closed = false
-      closed = close! if should_close?(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
 
@@ -370,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
@@ -445,6 +433,8 @@ class Faulty
     #
     # @return [Storage::Interface]
     def storage
+      return Faulty::Storage::Null.new if Faulty.disabled?
+
       options.storage
     end
   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/filter_notifier.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class Faulty
+  module Events
+    # Wraps a Notifier and filters events by name
+    class FilterNotifier
+      # @param notifier [Notifier] The internal notifier to filter events for
+      # @param events [Array, nil] An array of events to allow. If nil, all
+      #   {EVENTS} will be used
+      # @param exclude [Array, nil] An array of events to disallow. If nil,
+      #   no events will be disallowed. Takes priority over `events`.
+      def initialize(notifier, events: nil, exclude: nil)
+        @notifier = notifier
+        @events = Set.new(events || EVENTS)
+        exclude&.each { |e| @events.delete(e) }
+      end
+
+      # Notify all listeners of an event
+      #
+      # If a listener raises an error while handling an event, that error will
+      # be captured and written to STDERR.
+      #
+      # @param (see Notifier)
+      def notify(event, payload)
+        return unless @events.include?(event)
+
+        @notifier.notify(event, payload)
+      end
+    end
+  end
+end

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
@@ -36,7 +36,7 @@ class Faulty
       end
 
       def circuit_success(payload)
-        log(:debug, 'Circuit succeeded', payload[:circuit].name, state: payload[:status].state)
+        log(:debug, 'Circuit succeeded', payload[:circuit].name)
       end
 
       def circuit_failure(payload)
@@ -79,8 +79,12 @@ 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(' ')
+          extra_str = " #{extra_str}" unless extra_str.empty?
+
+          "#{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
 
@@ -24,3 +26,4 @@ require 'faulty/events/callback_listener'
 require 'faulty/events/honeybadger_listener'
 require 'faulty/events/log_listener'
 require 'faulty/events/notifier'
+require 'faulty/events/filter_notifier'

data/lib/faulty/patch/base.rb

@@ -39,7 +39,7 @@ class Faulty
         Thread.current[faulty_running_key] = true
         @faulty_circuit.run { yield }
       ensure
-        Thread.current[faulty_running_key] = false
+        Thread.current[faulty_running_key] = nil
       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

@@ -8,13 +8,9 @@ class Faulty
     #
     # This module is not required by default
     #
-    # Pass a `:faulty` key into your redis connection options to enable
-    # circuit protection. This hash is a hash of circuit options for the
-    # internal circuit. The hash may also have a `:instance` key, which is the
-    # faulty instance to create the circuit from. `Faulty.default` will be
-    # used if no instance is given. The `:instance` key can also reference a
-    # registered Faulty instance or a global constantso that it can be set
-    # from config files. See {Patch.circuit_from_hash}.
+    # 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'
@@ -32,12 +28,18 @@ class Faulty
 
       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],
+          errors: [
+            ::Redis::BaseConnectionError,
+            BusyError
+          ],
           patched_error_module: Faulty::Patch::Redis
         )
 
@@ -49,10 +51,41 @@ class Faulty
         faulty_run { super }
       end
 
-      # Reads/writes to redis are protected
-      def io(&block)
+      # 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

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/circuit_proxy.rb

@@ -33,7 +33,7 @@ class Faulty
 
           self.circuit ||= Circuit.new(
             Faulty::Storage::CircuitProxy.name,
-            notifier: notifier,
+            notifier: Events::FilterNotifier.new(notifier, exclude: %i[circuit_success]),
             cache: Cache::Null.new
           )
         end

data/lib/faulty/storage/null.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+class Faulty
+  module Storage
+    # A no-op backend for disabling circuits
+    class Null
+      # Define a single global instance
+      @instance = new
+
+      def self.new
+        @instance
+      end
+
+      # @param (see Interface#entry)
+      # @return (see Interface#entry)
+      def entry(_circuit, _time, _success)
+        []
+      end
+
+      # @param (see Interface#open)
+      # @return (see Interface#open)
+      def open(_circuit, _opened_at)
+        true
+      end
+
+      # @param (see Interface#reopen)
+      # @return (see Interface#reopen)
+      def reopen(_circuit, _opened_at, _previous_opened_at)
+        true
+      end
+
+      # @param (see Interface#close)
+      # @return (see Interface#close)
+      def close(_circuit)
+        true
+      end
+
+      # @param (see Interface#lock)
+      # @return (see Interface#lock)
+      def lock(_circuit, _state)
+      end
+
+      # @param (see Interface#unlock)
+      # @return (see Interface#unlock)
+      def unlock(_circuit)
+      end
+
+      # @param (see Interface#reset)
+      # @return (see Interface#reset)
+      def reset(_circuit)
+      end
+
+      # @param (see Interface#status)
+      # @return (see Interface#status)
+      def status(circuit)
+        Faulty::Status.new(
+          options: circuit.options,
+          stub: true
+        )
+      end
+
+      # @param (see Interface#history)
+      # @return (see Interface#history)
+      def history(_circuit)
+        []
+      end
+
+      # @param (see Interface#list)
+      # @return (see Interface#list)
+      def list
+        []
+      end
+
+      # This backend is fault tolerant
+      #
+      # @param (see Interface#fault_tolerant?)
+      # @return (see Interface#fault_tolerant?)
+      def fault_tolerant?
+        true
+      end
+    end
+  end
+end

data/lib/faulty/storage.rb

@@ -10,5 +10,6 @@ require 'faulty/storage/auto_wire'
 require 'faulty/storage/circuit_proxy'
 require 'faulty/storage/fallback_chain'
 require 'faulty/storage/fault_tolerant_proxy'
+require 'faulty/storage/null'
 require 'faulty/storage/memory'
 require 'faulty/storage/redis'

data/lib/faulty/version.rb

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

data/lib/faulty.rb

@@ -128,6 +128,33 @@ class Faulty
     def current_time
       Time.now.to_i
     end
+
+    # Disable Faulty circuits
+    #
+    # This allows circuits to run as if they were always closed. Does
+    # not disable caching.
+    #
+    # Intended for use in tests, or to disable Faulty entirely for an
+    # environment.
+    #
+    # @return [void]
+    def disable!
+      @disabled = true
+    end
+
+    # Re-enable Faulty if disabled with {#disable!}
+    #
+    # @return [void]
+    def enable!
+      @disabled = false
+    end
+
+    # Check whether Faulty was disabled with {#disable!}
+    #
+    # @return [Boolean] True if disabled
+    def disabled?
+      @disabled == true
+    end
   end
 
   attr_reader :options

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faulty
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Justin Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-28 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
@@ -160,6 +147,7 @@ files:
 - lib/faulty/error.rb
 - lib/faulty/events.rb
 - lib/faulty/events/callback_listener.rb
+- lib/faulty/events/filter_notifier.rb
 - lib/faulty/events/honeybadger_listener.rb
 - lib/faulty/events/listener_interface.rb
 - lib/faulty/events/log_listener.rb
@@ -167,6 +155,7 @@ files:
 - 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
@@ -177,6 +166,7 @@ files:
 - lib/faulty/storage/fault_tolerant_proxy.rb
 - lib/faulty/storage/interface.rb
 - lib/faulty/storage/memory.rb
+- lib/faulty/storage/null.rb
 - lib/faulty/storage/redis.rb
 - lib/faulty/version.rb
 homepage: https://github.com/ParentSquare/faulty