faulty 0.5.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8ce491fe09e0c6224c3ecc6da2825eeff601f15f7b5bbfbff065f898860fc48
-  data.tar.gz: caf56c1bfc86511d0acb6fbd3f7507d521bcd7b8ac74b47a85ebcbd9a4fdef1b
+  metadata.gz: 6d954b29a9efe4360a4b3ab940afa5f4d9b51642c6244bcbc3875fb7bdf569c7
+  data.tar.gz: b0babca45decf10cf5b0505b301e7c89837385cd21a5727048599f2c9097549d
 SHA512:
-  metadata.gz: 89eb97edae88432ea0e6e36a9c0b0f69d4d89075193ffd5a6eb0fe10e24c0983047289ccdb8e363619c4f83b1e80baec9decc34e4fdf029cfbef24189f244138
-  data.tar.gz: 4cabda8638d452bcac0a6375b284b4465d7eb34ed5e4b546a7247c09816eae4480620d69f9777144bd3d3aa8abcc58ca83243037e5d7aac0635e6d01d45ff289
+  metadata.gz: 56c406768fe13d23cec5c56b1c6d25f278f578895c90c01731dda8f3b002f7a2ca1b06b17195cf7f86d358699b7b8fc3c9648c8aa6b0a2d30fd12f7a3a0e92e6
+  data.tar.gz: 0bfed6c5968d43262d4c1e02735339f6a9858a9bbebecbffcb8d9ed36a4bf2ea068fa5c6035675592eaaed3df267815c1e24b73a484f4aa421cac17ab602a805

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,28 @@
+## 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
+
 ## Release v0.5.0
 
 * Allow creating a new Faulty instance in Faulty#register #24 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,6 +83,7 @@ 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)
@@ -948,15 +949,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 +1008,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 +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

@@ -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

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
@@ -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
 

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faulty
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.1
 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
@@ -167,6 +154,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