faulty 0.8.0 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 815cc1b7ac571e9dc69546efd1b3892795a5ef284cc43448b8a6c1feadcf49c3
-  data.tar.gz: 575c2e0e7abb413f8866a0e159129a6f1ecc76149e8d8cb97c65c7ffd9913ba9
+  metadata.gz: 54ef7d6bc1b23815e02563c80e4c17fef2735812a8c424882e8283996506edcc
+  data.tar.gz: c4c2d074b118f3077a3cddb862fddc5c3ace18c62a206e4523cfb830b7b6e35b
 SHA512:
-  metadata.gz: 6effebfa578717256dc4ef7ec1c59a5f694eff2c78b21edb1649375a3f7ab62bbad597e3e4a0dc63cd729b4e66b4079ea9cbfd72795a1bfd34a9fab489415847
-  data.tar.gz: 2ba730eaa396ce24cb9d4eaf3a35db84180eb5c8ba4e3f3bc803d389436870480bd542aa57c93089ef33b77afe3f9b0c8614f972d232b971d8310f2dd067eb39
+  metadata.gz: 75fa840ff865e39e381894bdce59ab13f67ac001cbae57696360692c495b8d0ca2f643261a7a4ea083fdb1964d8e14ad0237815f90e9b436d17eff04a0abe0f5
+  data.tar.gz: dfcaede2d29e34bd466a21ad5037ddaeebfaa947bb44f09ef9c64b34ac0f207dd2a8e4d038067b47ce3ac76ccbba744721dc1fb4337854e7e9af0df739798169

data/.github/workflows/ci.yml

@@ -22,6 +22,11 @@ jobs:
         image: redis
         ports:
           - 6379:6379
+      elasticsearch:
+        image: elasticsearch:7.13.4
+        ports:
+          - 9200:9200
+        options: -e="discovery.type=single-node" --health-cmd="curl http://localhost:9200/_cluster/health" --health-interval=3s --health-timeout=5s --health-retries=20
     steps:
       - uses: actions/checkout@v2
       - uses: ruby/setup-ruby@v1
@@ -32,6 +37,9 @@ jobs:
           bundler-cache: true
       - run: bundle exec rubocop
         if: matrix.ruby == '2.7'
+      - run: bin/yardoc --fail-on-warning
+        if: matrix.ruby == '2.7'
+      - run: bin/check-version
       - name: start MySQL
         run: sudo /etc/init.d/mysql start
       - run: bundle exec rspec --format doc
@@ -43,7 +51,6 @@ jobs:
         with:
           project-token: ${{ secrets.CODACY_PROJECT_TOKEN }}
           coverage-reports: coverage/lcov/faulty.lcov
-      - run: bin/check-version
 
   release:
     needs: test

data/.yardopts

@@ -1,3 +1,3 @@
 --markup markdown
 --markup-provider redcarpet
-- guides/*
+- LICENSE.txt CHANGELOG.md

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## Release v0.8.5
+
+* Fix yard warnings #49 justinhoward
+* Fix crash in Redis storage backend if opened_at was missing #46 justinhoward
+* Add granular errors for Elasticsearch patch #48 justinhoward
+* Return status conditionally for Storage::Interface#entry #45 justinhoward
+
+## Release v0.8.4
+
+* Add Elasticsearch client patch #44 justinhoward
+
+## Release v0.8.2
+
+* Fix crash for older versions of concurrent-ruby #42 justinhoward
+
+## Release v0.8.1
+
+* Add cause message to CircuitTrippedError #40 justinhoward
+* Record failures for cache hits #41 justinhoward
+
+
 ## Release v0.8.0
 
 * Store circuit options in the backend when run #34 justinhoward

data/Gemfile

@@ -13,6 +13,8 @@ not_jruby = %i[ruby mingw x64_mingw].freeze
 gem 'activesupport', '>= 4.2'
 gem 'bundler', '>= 1.17', '< 3'
 gem 'byebug', platforms: not_jruby
+# Open source licensed elasticsearch
+gem 'elasticsearch', '> 7', '< 7.14'
 gem 'honeybadger', '>= 2.0'
 gem 'irb', '~> 1.0'
 # Minimum of 0.5.0 for specific error classes

data/README.md

@@ -84,6 +84,7 @@ Also see "Release It!: Design and Deploy Production-Ready Software" by
 * [Patches](#patches)
   + [Patch::Redis](#patchredis)
   + [Patch::Mysql2](#patchmysql2)
+  + [Patch::Elasticsearch](#patchelasticsearch)
 * [Event Handling](#event-handling)
   + [CallbackListener](#callbacklistener)
   + [Other Built-in Listeners](#other-built-in-listeners)
@@ -1046,6 +1047,38 @@ mysql = Mysql2::Client.new(host: '127.0.0.1')
 mysql.query('SELECT * FROM users') # not protected by a circuit
 ```
 
+### Patch::Elasticsearch
+
+[`Faulty::Patch::Elasticsearch`](https://www.rubydoc.info/gems/faulty/Faulty/Patch/Elasticsearch)
+protects a `Elasticsearch::Client` with an internal circuit. Pass a `:faulty` key along
+with your client options to enable the circuit breaker.
+
+```ruby
+require 'faulty/patch/elasticsearch'
+
+es = Elasticsearch::Client.new(url: 'localhost:9200', faulty: {
+  # The name for the Elasticsearch::Client circuit
+  name: 'elasticsearch'
+
+  # 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
+  # Elasticsearch::Transport::Transport::Error
+  # To disable this behavior, set patch_errors to false and Faulty
+  # will raise its default errors
+  patch_errors: true
+})
+```
+
+If you're using Searchkick, you can configure Faulty with `client_options`.
+
+```ruby
+Searchkick.client_options[:faulty] = { name: 'searchkick' }
+```
+
 ## Event Handling
 
 Faulty uses an event-dispatching model to deliver notifications of internal
@@ -1288,18 +1321,20 @@ but there are and have been many other options:
 ### Currently Active
 
 - [semian](https://github.com/Shopify/semian): A resiliency toolkit that
-  includes circuit breakers. It uses adapters to auto-wire circuits, and it has
-  only in-memory storage by design.
-- [circuitbox](https://github.com/yammer/circuitbox): Similar in design to
-  Faulty, but with a different API. It uses Moneta to abstract circuit storage
-  to allow any key-value store.
+  includes circuit breakers. It auto-wires circuits for MySQL, Net::HTTP, and
+  Redis. It has only in-memory storage by design. Its core components are
+  written in C, which allows it to be faster than pure ruby.
+- [circuitbox](https://github.com/yammer/circuitbox): Also uses a block syntax
+  to manually define circuits. It uses Moneta to abstract circuit storage to
+  allow any key-value store.
 
 ### Previous Work
 
 - [circuit_breaker-ruby](https://github.com/scripbox/circuit_breaker-ruby) (no
   recent activity)
 - [stoplight](https://github.com/orgsync/stoplight) (unmaintained)
-- [circuit_breaker](https://github.com/wooga/circuit_breaker) (archived)
+- [circuit_breaker](https://github.com/wsargent/circuit_breaker) (no recent
+activity)
 - [simple_circuit_breaker](https://github.com/soundcloud/simple_circuit_breaker)
   (unmaintained)
 - [breaker](https://github.com/ahawkins/breaker) (unmaintained)
@@ -1309,6 +1344,7 @@ but there are and have been many other options:
 
 - Simple API but configurable for advanced users
 - Pluggable storage backends (circuitbox also has this)
+- Patches for common core dependencies (semian also has this)
 - Protected storage access with fallback to safe storage
 - Global, or object-oriented configuration with multiple instances
 - Integrated caching support tailored for fault-tolerance

data/bin/benchmark

@@ -4,12 +4,13 @@
 require 'bundler/setup'
 require 'benchmark'
 require 'faulty'
+require 'redis'
+require 'json'
 
 n = 100_000
-
-puts "Starting circuit benchmarks with #{n} iterations each\n\n"
-
-Benchmark.bm(25) do |b|
+width = 25
+puts "In memory circuits x#{n}"
+Benchmark.bm(width) do |b|
   in_memory = Faulty.new(listeners: [])
   b.report('memory storage') do
     n.times { in_memory.circuit(:memory).run { true } }
@@ -31,11 +32,33 @@ Benchmark.bm(25) do |b|
   end
 end
 
-n = 1_000_000
+n = 1000
+puts "\n\Redis circuits x#{n}"
+Benchmark.bm(width) do |b|
+  redis = Faulty.new(listeners: [], storage: Faulty::Storage::Redis.new)
+  b.report('redis storage') do
+    n.times { redis.circuit(:memory).run { true } }
+  end
 
-puts "\n\nStarting extra benchmarks with #{n} iterations each\n\n"
+  b.report('redis storage failures') do
+    n.times do
+      begin
+        redis.circuit(:memory_fail, sample_threshold: n + 1).run { raise 'fail' }
+      rescue StandardError
+        # Expected to raise here
+      end
+    end
+  end
 
-Benchmark.bm(25) do |b|
+  redis_large = Faulty.new(listeners: [], storage: Faulty::Storage::Redis.new(max_sample_size: 1000))
+  b.report('large redis storage') do
+    n.times { redis_large.circuit(:memory).run { true } }
+  end
+end
+
+n = 1_000_000
+puts "\n\nExtra x#{n}"
+Benchmark.bm(width) do |b|
   in_memory = Faulty.new(listeners: [])
 
   log_listener = Faulty::Events::LogListener.new(Logger.new(File::NULL))

data/lib/faulty/circuit.rb

@@ -49,9 +49,13 @@ 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] error_mapper
+    #   @return [Module, #call] Used by patches to set the namespace module for
+    #     the faulty errors that will be raised. Should be a module or a callable.
+    #     If given a module, the circuit assumes the module has error classes
+    #     in that module. If given an object that responds to `#call` (a proc
+    #     or lambda), the return value of the callable will be used. The callable
+    #     is called with (`error_name`, `cause_error`, `circuit`). 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.
@@ -93,6 +97,7 @@ class Faulty
       :rate_threshold,
       :sample_threshold,
       :errors,
+      :error_mapper,
       :error_module,
       :exclude,
       :cache,
@@ -120,7 +125,7 @@ class Faulty
           cache_refreshes_after: 900,
           cool_down: 300,
           errors: [StandardError],
-          error_module: Faulty,
+          error_mapper: Faulty,
           exclude: [],
           evaluation_window: 60,
           rate_threshold: 0.5,
@@ -133,7 +138,7 @@ class Faulty
           cache
           cool_down
           errors
-          error_module
+          error_mapper
           exclude
           evaluation_window
           rate_threshold
@@ -153,6 +158,17 @@ class Faulty
         unless cache_refreshes_after.nil?
           self.cache_refresh_jitter = 0.2 * cache_refreshes_after
         end
+
+        deprecated_error_module
+      end
+
+      private
+
+      def deprecated_error_module
+        return unless error_module
+
+        Deprecation.method(self.class, :error_module, note: 'See :error_mapper', sunset: '0.9.0')
+        self.error_mapper = error_module
       end
     end
 
@@ -379,7 +395,7 @@ class Faulty
     # @return The result from cache if available
     def run_skipped(cached_value)
       skipped!
-      raise options.error_module::OpenCircuitError.new(nil, self) if cached_value.nil?
+      raise map_error(:OpenCircuitError) if cached_value.nil?
 
       cached_value
     end
@@ -397,10 +413,13 @@ class Faulty
     rescue *options.errors => e
       raise if options.exclude.any? { |ex| e.is_a?(ex) }
 
+      opened = failure!(status, e)
       if cached_value.nil?
-        raise options.error_module::CircuitTrippedError.new(nil, self) if failure!(status, e)
-
-        raise options.error_module::CircuitFailureError.new(nil, self)
+        if opened
+          raise map_error(:CircuitTrippedError, e)
+        else
+          raise map_error(:CircuitFailureError, e)
+        end
       else
         cached_value
       end
@@ -408,7 +427,11 @@ class Faulty
 
     # @return [Boolean] True if the circuit transitioned to closed
     def success!(status)
-      storage.entry(self, Faulty.current_time, true)
+      if deprecated_entry?
+        storage.entry(self, Faulty.current_time, true, nil)
+      else
+        storage.entry(self, Faulty.current_time, true)
+      end
       closed = close! if status.half_open?
 
       options.notifier.notify(:circuit_success, circuit: self)
@@ -417,8 +440,11 @@ class Faulty
 
     # @return [Boolean] True if the circuit transitioned to open
     def failure!(status, error)
-      entries = storage.entry(self, Faulty.current_time, false)
-      status = Status.from_entries(entries, **status.to_h)
+      status = if deprecated_entry?
+        storage.entry(self, Faulty.current_time, false, status)
+      else
+        deprecated_entry(status)
+      end
       options.notifier.notify(:circuit_failure, circuit: self, status: status, error: error)
 
       opened = if status.half_open?
@@ -432,6 +458,23 @@ class Faulty
       opened
     end
 
+    def deprecated_entry?
+      return @deprecated_entry unless @deprecated_entry.nil?
+
+      @deprecated_entry = storage.method(:entry).arity == 4
+    end
+
+    def deprecated_entry(status)
+      Faulty::Deprecation.deprecate(
+        'Returning entries array from entry',
+        note: 'see Storate::Interface#entry',
+        sunset: '0.9'
+      )
+
+      entries = storage.entry(self, Faulty.current_time, false)
+      Status.from_entries(entries, **status.to_h)
+    end
+
     def skipped!
       options.notifier.notify(:circuit_skipped, circuit: self)
     end
@@ -528,5 +571,13 @@ class Faulty
 
       @given_options.storage
     end
+
+    def map_error(error_name, cause = nil)
+      if options.error_mapper.respond_to?(:call)
+        options.error_mapper.call(error_name, cause, self)
+      else
+        options.error_mapper.const_get(error_name).new(cause&.message, self)
+      end
+    end
   end
 end

data/lib/faulty/deprecation.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Faulty
+  # Support deprecating Faulty features
+  module Deprecation
+    class << self
+      # Call to raise errors instead of logging warnings for Faulty deprecations
+      def raise_errors!(enabled = true)
+        @raise_errors = (enabled == true)
+      end
+
+      def silenced
+        @silence = true
+        yield
+      ensure
+        @silence = false
+      end
+
+      # @private
+      def method(klass, name, note: nil, sunset: nil)
+        deprecate("#{klass}##{name}", note: note, sunset: sunset)
+      end
+
+      # @private
+      def deprecate(subject, note: nil, sunset: nil)
+        return if @silence
+
+        message = "#{subject} is deprecated"
+        message += " and will be removed in #{sunset}" if sunset
+        message += " (#{note})" if note
+        raise DeprecationError, message if @raise_errors
+
+        Kernel.warn("DEPRECATION: #{message}")
+      end
+    end
+  end
+end

data/lib/faulty/error.rb

@@ -28,6 +28,9 @@ class Faulty
     end
   end
 
+  class DeprecationError < FaultyError
+  end
+
   # Included in faulty circuit errors to provide common features for
   # native and patched errors
   module CircuitErrorBase
@@ -36,10 +39,11 @@ class Faulty
     # @param message [String]
     # @param circuit [Circuit] The circuit that raised the error
     def initialize(message, circuit)
-      message ||= %(circuit error for "#{circuit.name}")
-      @circuit = circuit
+      full_message = %(circuit error for "#{circuit.name}")
+      full_message = %(#{full_message}: #{message}) if message
 
-      super(message)
+      @circuit = circuit
+      super(full_message)
     end
   end
 

data/lib/faulty/patch/elasticsearch.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'elasticsearch'
+
+class Faulty
+  module Patch
+    # Patch Elasticsearch to run requests in a circuit
+    #
+    # This module is not required by default
+    #
+    # Pass a `:faulty` key into your Elasticsearch client options to enable
+    # circuit protection. See {Patch.circuit_from_hash} for the available
+    # options.
+    #
+    # By default, all circuit errors raised by this patch inherit from
+    # `::Elasticsearch::Transport::Transport::Error`. One side effect of the way
+    # this patch wraps errors is that `host_unreachable_exceptions` raised by
+    # the inner transport adapters are converted into
+    # `Elasticsearch::Transport::Transport::Error` instead of the transport
+    # error type such as `Faraday::ConnectionFailed`.
+    #
+    # @example
+    #   require 'faulty/patch/elasticsearch'
+    #
+    #   es = Elasticsearch::Client.new(url: 'http://localhost:9200', faulty: {})
+    #   es.search(q: 'test') # raises Faulty::CircuitError if connection fails
+    #
+    #   # If the faulty key is not given, no circuit is used
+    #   es = Elasticsearch::Client.new(url: 'http://localhost:9200', faulty: {})
+    #   es.search(q: 'test') # not protected by a circuit
+    #
+    #   # With Searchkick
+    #   Searchkick.client_options[:faulty] = {}
+    #
+    # @see Patch.circuit_from_hash
+    module Elasticsearch
+      include Base
+
+      module Error; end
+      module SnifferTimeoutError; end
+      module ServerError; end
+
+      # We will freeze this after adding the dynamic error classes
+      MAPPED_ERRORS = { # rubocop:disable Style/MutableConstant
+        ::Elasticsearch::Transport::Transport::Error => Error,
+        ::Elasticsearch::Transport::Transport::SnifferTimeoutError => SnifferTimeoutError,
+        ::Elasticsearch::Transport::Transport::ServerError => ServerError
+      }
+
+      module Errors
+        ::Elasticsearch::Transport::Transport::ERRORS.each do |_code, klass|
+          MAPPED_ERRORS[klass] = const_set(klass.name.split('::').last, Module.new)
+        end
+      end
+
+      MAPPED_ERRORS.freeze
+      MAPPED_ERRORS.each do |klass, mod|
+        Patch.define_circuit_errors(mod, klass)
+      end
+
+      ERROR_MAPPER = lambda do |error_name, cause, circuit|
+        MAPPED_ERRORS.fetch(cause&.class, Error).const_get(error_name).new(cause&.message, circuit)
+      end
+      private_constant :ERROR_MAPPER, :MAPPED_ERRORS
+
+      def initialize(arguments = {}, &block)
+        super
+
+        errors = [::Elasticsearch::Transport::Transport::Error]
+        errors.concat(@transport.host_unreachable_exceptions)
+
+        @faulty_circuit = Patch.circuit_from_hash(
+          'elasticsearch',
+          arguments[:faulty],
+          errors: errors,
+          exclude: ::Elasticsearch::Transport::Transport::Errors::NotFound,
+          patched_error_mapper: ERROR_MAPPER
+        )
+      end
+
+      # Protect all elasticsearch requests
+      def perform_request(*args)
+        faulty_run { super }
+      end
+    end
+  end
+end
+
+module Elasticsearch
+  module Transport
+    class Client
+      prepend(Faulty::Patch::Elasticsearch)
+    end
+  end
+end

data/lib/faulty/patch/mysql2.rb

@@ -20,6 +20,9 @@ class Faulty
     # protected by the circuit. This is to allow open transactions to be closed
     # if possible.
     #
+    # By default, all circuit errors raised by this patch inherit from
+    # `::Mysql2::Error::ConnectionError`
+    #
     # @example
     #   require 'faulty/patch/mysql2'
     #
@@ -50,7 +53,7 @@ class Faulty
             ::Mysql2::Error::ConnectionError,
             ::Mysql2::Error::TimeoutError
           ],
-          patched_error_module: Faulty::Patch::Mysql2
+          patched_error_mapper: Faulty::Patch::Mysql2
         )
 
         super
@@ -78,4 +81,8 @@ class Faulty
   end
 end
 
-::Mysql2::Client.prepend(Faulty::Patch::Mysql2)
+module Mysql2
+  class Client
+    prepend(Faulty::Patch::Mysql2)
+  end
+end

data/lib/faulty/patch/redis.rb

@@ -12,6 +12,9 @@ class Faulty
     # circuit protection. See {Patch.circuit_from_hash} for the available
     # options.
     #
+    # By default, all circuit errors raised by this patch inherit from
+    # `::Redis::BaseConnectionError`
+    #
     # @example
     #   require 'faulty/patch/redis'
     #
@@ -40,7 +43,7 @@ class Faulty
             ::Redis::BaseConnectionError,
             BusyError
           ],
-          patched_error_module: Faulty::Patch::Redis
+          patched_error_mapper: Faulty::Patch::Redis
         )
 
         super
@@ -90,4 +93,8 @@ class Faulty
   end
 end
 
-::Redis::Client.prepend(Faulty::Patch::Redis)
+class Redis
+  class Client
+    prepend(Faulty::Patch::Redis)
+  end
+end

data/lib/faulty/patch.rb

@@ -64,14 +64,15 @@ class Faulty
       #   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
+      #   subclasses of `options[:patched_error_mapper]`. 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
+      # @option options [Module] :patched_error_mapper The namespace module
+      #   for patched errors or a mapping proc. See {Faulty::Circuit::Options}
+      #   `:error_mapper`
       # @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)
@@ -80,8 +81,8 @@ class Faulty
         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
+        error_mapper = options.delete(:patched_error_mapper)
+        hash[:error_mapper] ||= error_mapper if error_mapper && patch_errors
         faulty = resolve_instance(hash.delete(:instance))
         faulty.circuit(name, **hash, **options, &block)
       end

data/lib/faulty/storage/auto_wire.rb

@@ -69,7 +69,7 @@ class Faulty
 
         # Wrap an array of storage backends in a fault-tolerant FallbackChain
         #
-        # @param [Array<Storage::Interface>] The array to wrap
+        # @param array [Array<Storage::Interface>] The array to wrap
         # @param options [Options]
         # @return [Storage::Interface] A fault-tolerant fallback chain
         def wrap_array(array, options)
@@ -81,7 +81,7 @@ class Faulty
 
         # Wrap one storage backend in fault-tolerant backends
         #
-        # @param [Storage::Interface] The storage to wrap
+        # @param storage [Storage::Interface] The storage to wrap
         # @param options [Options]
         # @return [Storage::Interface] A fault-tolerant storage backend
         def wrap_one(storage, options)
@@ -93,7 +93,7 @@ class Faulty
 
         # Wrap storage in a CircuitProxy
         #
-        # @param [Storage::Interface] The storage to wrap
+        # @param storage [Storage::Interface] The storage to wrap
         # @param options [Options]
         # @return [CircuitProxy]
         def circuit_proxy(storage, options)

data/lib/faulty/storage/fallback_chain.rb

@@ -69,8 +69,8 @@ class Faulty
       #
       # @param (see Interface#entry)
       # @return (see Interface#entry)
-      def entry(circuit, time, success)
-        send_chain(:entry, circuit, time, success) do |e|
+      def entry(circuit, time, success, status)
+        send_chain(:entry, circuit, time, success, status) do |e|
           options.notifier.notify(:storage_failure, circuit: circuit, action: :entry, error: e)
         end
       end

data/lib/faulty/storage/fault_tolerant_proxy.rb

@@ -112,11 +112,11 @@ class Faulty
       # @see Interface#entry
       # @param (see Interface#entry)
       # @return (see Interface#entry)
-      def entry(circuit, time, success)
-        @storage.entry(circuit, time, success)
+      def entry(circuit, time, success, status)
+        @storage.entry(circuit, time, success, status)
       rescue StandardError => e
         options.notifier.notify(:storage_failure, circuit: circuit, action: :entry, error: e)
-        []
+        stub_status(circuit) if status
       end
 
       # Safely mark a circuit as open

data/lib/faulty/storage/interface.rb

@@ -21,7 +21,7 @@ class Faulty
       # They should be returned exactly as given by {#set_options}
       #
       # @param circuit [Circuit] The circuit to set options for
-      # @param options [Hash<Symbol, Object>] A hash of symbol option names to
+      # @param stored_options [Hash<Symbol, Object>] A hash of symbol option names to
       #   circuit options. These option values are guranteed to be primive
       #   values.
       # @return [void]
@@ -37,9 +37,10 @@ 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 [Array<Array>] An array of the new history tuples after adding
-      #   the new entry, see {#history}
-      def entry(circuit, time, success)
+      # @param status [Status, nil] The previous status. If given, this method must
+      #   return an updated status object from the new entry data.
+      # @return [Status, nil] If `status` is not nil, the updated status object.
+      def entry(circuit, time, success, status)
         raise NotImplementedError
       end
 

data/lib/faulty/storage/memory.rb

@@ -99,13 +99,14 @@ class Faulty
       # @see Interface#entry
       # @param (see Interface#entry)
       # @return (see Interface#entry)
-      def entry(circuit, time, success)
+      def entry(circuit, time, success, status)
         memory = fetch(circuit)
         memory.runs.borrow do |runs|
           runs.push([time, success])
           runs.shift if runs.size > options.max_sample_size
         end
-        memory.runs.value
+
+        Status.from_entries(memory.runs.value, **status.to_h) if status
       end
 
       # Mark a circuit as open

data/lib/faulty/storage/null.rb

@@ -24,8 +24,8 @@ class Faulty
 
       # @param (see Interface#entry)
       # @return (see Interface#entry)
-      def entry(_circuit, _time, _success)
-        []
+      def entry(circuit, _time, _success, status)
+        stub_status(circuit) if status
       end
 
       # @param (see Interface#open)
@@ -64,10 +64,7 @@ class Faulty
       # @param (see Interface#status)
       # @return (see Interface#status)
       def status(circuit)
-        Faulty::Status.new(
-          options: circuit.options,
-          stub: true
-        )
+        stub_status(circuit)
       end
 
       # @param (see Interface#history)
@@ -89,6 +86,15 @@ class Faulty
       def fault_tolerant?
         true
       end
+
+      private
+
+      def stub_status(circuit)
+        Faulty::Status.new(
+          options: circuit.options,
+          stub: true
+        )
+      end
     end
   end
 end

data/lib/faulty/storage/redis.rb

@@ -119,7 +119,7 @@ class Faulty
       # @see Interface#entry
       # @param (see Interface#entry)
       # @return (see Interface#entry)
-      def entry(circuit, time, success)
+      def entry(circuit, time, success, status)
         key = entries_key(circuit)
         result = pipe do |r|
           r.sadd(list_key, circuit.name)
@@ -127,9 +127,10 @@ class Faulty
           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)
+          r.lrange(key, 0, -1) if status
         end
-        map_entries(result.last)
+
+        Status.from_entries(map_entries(result.last), **status.to_h) if status
       end
 
       # Mark a circuit as open
@@ -138,11 +139,14 @@ class Faulty
       # @param (see Interface#open)
       # @return (see Interface#open)
       def open(circuit, opened_at)
-        redis do |r|
-          opened = compare_and_set(r, state_key(circuit), ['closed', nil], 'open', ex: options.circuit_ttl)
-          r.set(opened_at_key(circuit), opened_at, ex: options.circuit_ttl) if opened
-          opened
+        key = state_key(circuit)
+        ex = options.circuit_ttl
+        result = watch_exec(key, ['closed', nil]) do |m|
+          m.set(key, 'open', ex: ex)
+          m.set(opened_at_key(circuit), opened_at, ex: ex)
         end
+
+        result && result[0] == 'OK'
       end
 
       # Mark a circuit as reopened
@@ -151,9 +155,12 @@ class Faulty
       # @param (see Interface#reopen)
       # @return (see Interface#reopen)
       def reopen(circuit, opened_at, previous_opened_at)
-        redis do |r|
-          compare_and_set(r, opened_at_key(circuit), [previous_opened_at.to_s], opened_at, ex: options.circuit_ttl)
+        key = opened_at_key(circuit)
+        result = watch_exec(key, [previous_opened_at.to_s]) do |m|
+          m.set(key, opened_at, ex: options.circuit_ttl)
         end
+
+        result && result[0] == 'OK'
       end
 
       # Mark a circuit as closed
@@ -162,11 +169,14 @@ class Faulty
       # @param (see Interface#close)
       # @return (see Interface#close)
       def close(circuit)
-        redis do |r|
-          closed = compare_and_set(r, state_key(circuit), ['open'], 'closed', ex: options.circuit_ttl)
-          r.del(entries_key(circuit)) if closed
-          closed
+        key = state_key(circuit)
+        ex = options.circuit_ttl
+        result = watch_exec(key, ['open']) do |m|
+          m.set(key, 'closed', ex: ex)
+          m.del(entries_key(circuit))
         end
+
+        result && result[0] == 'OK'
       end
 
       # Lock a circuit open or closed
@@ -220,11 +230,15 @@ class Faulty
           futures[:entries] = r.lrange(entries_key(circuit), 0, -1)
         end
 
+        state = futures[:state].value&.to_sym || :closed
+        opened_at = futures[:opened_at].value ? futures[:opened_at].value.to_i : nil
+        opened_at = Faulty.current_time - options.circuit_ttl if state == :open && opened_at.nil?
+
         Faulty::Status.from_entries(
           map_entries(futures[:entries].value),
-          state: futures[:state].value&.to_sym || :closed,
+          state: state,
           lock: futures[:lock].value&.to_sym,
-          opened_at: futures[:opened_at].value ? futures[:opened_at].value.to_i : nil,
+          opened_at: opened_at,
           options: circuit.options
         )
       end
@@ -329,23 +343,28 @@ class Faulty
         (Faulty.current_time.to_f / options.list_granularity).floor
       end
 
-      # Set a value in Redis only if it matches a list of current values
+      # Watch a Redis key and exec commands only if the key matches the expected
+      # value. Internally this uses Redis transactions with WATCH/MULTI/EXEC.
       #
-      # @param redis [Redis] The redis connection
-      # @param key [String] The redis key to CAS
-      # @param old [Array<String>] A list of previous values that pass the
-      #   comparison
-      # @param new [String] The new value to set if the compare passes
-      # @return [Boolean] True if the value was set to `new`, false if the CAS
-      #   failed
-      def compare_and_set(redis, key, old, new, ex:)
-        redis.watch(key) do
-          if old.include?(redis.get(key))
-            result = redis.multi { |m| m.set(key, new, ex: ex) }
-            result && result[0] == 'OK'
-          else
-            redis.unwatch
-            false
+      # @param key [String] The redis key to watch
+      # @param old [Array<String>] A list of previous values. The block will be
+      #   run only if key is one of these values.
+      # @yield [Redis] A redis client. Commands executed using this client
+      #   will be executed inside the MULTI context and will only be run if
+      #   the watch succeeds and the comparison passes
+      # @return [Array] An array of Redis results from the commands executed
+      #   inside the block
+      def watch_exec(key, old)
+        redis do |r|
+          r.watch(key) do
+            if old.include?(r.get(key))
+              r.multi do |m|
+                yield m
+              end
+            else
+              r.unwatch
+              nil
+            end
           end
         end
       end

data/lib/faulty/version.rb

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

data/lib/faulty.rb

@@ -2,8 +2,9 @@
 
 require 'securerandom'
 require 'forwardable'
-require 'concurrent-ruby'
+require 'concurrent'
 
+require 'faulty/deprecation'
 require 'faulty/immutable_options'
 require 'faulty/cache'
 require 'faulty/circuit'
@@ -143,14 +144,14 @@ class Faulty
       @disabled = true
     end
 
-    # Re-enable Faulty if disabled with {#disable!}
+    # Re-enable Faulty if disabled with {.disable!}
     #
     # @return [void]
     def enable!
       @disabled = false
     end
 
-    # Check whether Faulty was disabled with {#disable!}
+    # Check whether Faulty was disabled with {.disable!}
     #
     # @return [Boolean] True if disabled
     def disabled?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faulty
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.5
 platform: ruby
 authors:
 - Justin Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-14 00:00:00.000000000 Z
+date: 2022-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -159,6 +159,7 @@ files:
 - lib/faulty/cache/rails.rb
 - lib/faulty/circuit.rb
 - lib/faulty/circuit_registry.rb
+- lib/faulty/deprecation.rb
 - lib/faulty/error.rb
 - lib/faulty/events.rb
 - lib/faulty/events/callback_listener.rb
@@ -170,6 +171,7 @@ files:
 - lib/faulty/immutable_options.rb
 - lib/faulty/patch.rb
 - lib/faulty/patch/base.rb
+- lib/faulty/patch/elasticsearch.rb
 - lib/faulty/patch/mysql2.rb
 - lib/faulty/patch/redis.rb
 - lib/faulty/result.rb