faulty 0.3.0 → 0.4.0

data/faulty.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   # 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 'redis', '>= 3.0'
   spec.add_development_dependency 'rspec', '~> 3.8'
   # 0.81 is the last rubocop version with Ruby 2.3 support
   spec.add_development_dependency 'rubocop', '0.81.0'

data/lib/faulty.rb

@@ -129,6 +129,10 @@ class Faulty
   #   @return [Cache::Interface] A cache backend if you want
   #     to use Faulty's cache support. Automatically wrapped in a
   #     {Cache::AutoWire}. Default `Cache::AutoWire.new`.
+  # @!attribute [r] circuit_defaults
+  #   @see Circuit::Options
+  #   @return [Hash] A hash of default options to be used when creating
+  #     new circuits. See {Circuit::Options} for a full list.
   # @!attribute [r] storage
   #   @see Storage::AutoWire
   #   @return [Storage::Interface, Array<Storage::Interface>] The storage
@@ -142,6 +146,7 @@ class Faulty
   #     ignored.
   Options = Struct.new(
     :cache,
+    :circuit_defaults,
     :storage,
     :listeners,
     :notifier
@@ -152,16 +157,17 @@ class Faulty
 
     def finalize
       self.notifier ||= Events::Notifier.new(listeners || [])
-      self.storage = Storage::AutoWire.new(storage, notifier: notifier)
-      self.cache = Cache::AutoWire.new(cache, notifier: notifier)
+      self.storage = Storage::AutoWire.wrap(storage, notifier: notifier)
+      self.cache = Cache::AutoWire.wrap(cache, notifier: notifier)
     end
 
     def required
-      %i[cache storage notifier]
+      %i[cache circuit_defaults storage notifier]
     end
 
     def defaults
       {
+        circuit_defaults: {},
         listeners: [Events::LogListener.new]
       }
     end
@@ -200,8 +206,8 @@ class Faulty
   # @return [Circuit] The new circuit or the existing circuit if it already exists
   def circuit(name, **options, &block)
     name = name.to_s
-    options = options.merge(circuit_options)
     @circuits.compute_if_absent(name) do
+      options = circuit_options.merge(options)
       Circuit.new(name, **options, &block)
     end
   end
@@ -219,6 +225,8 @@ class Faulty
   #
   # @return [Hash] The circuit options
   def circuit_options
-    @options.to_h.select { |k, _v| %i[cache storage notifier].include?(k) }
+    @options.to_h
+      .select { |k, _v| %i[cache storage notifier].include?(k) }
+      .merge(options.circuit_defaults)
   end
 end

data/lib/faulty/cache/auto_wire.rb

@@ -6,10 +6,17 @@ class Faulty
     #
     # Used by {Faulty#initialize} to setup sensible cache defaults
     class AutoWire
-      extend Forwardable
-
       # Options for {AutoWire}
+      #
+      # @!attribute [r] circuit
+      #   @return [Circuit] A circuit for {CircuitProxy} if one is created.
+      #     When modifying this, be careful to use only a reliable circuit
+      #     storage backend so that you don't introduce cascading failures.
+      # @!attribute [r] notifier
+      #   @return [Events::Notifier] A Faulty notifier. If given, listeners are
+      #     ignored.
       Options = Struct.new(
+        :circuit,
         :notifier
       ) do
         include ImmutableOptions
@@ -21,44 +28,30 @@ class Faulty
         end
       end
 
-      # Wrap a cache backend with sensible defaults
-      #
-      # If the cache is `nil`, create a new {Default}.
-      #
-      # If the backend is not fault tolerant, wrap it in {CircuitProxy} and
-      # {FaultTolerantProxy}.
-      #
-      # @param cache [Interface] A cache backend
-      # @param options [Hash] Attributes for {Options}
-      # @yield [Options] For setting options in a block
-      def initialize(cache, **options, &block)
-        @options = Options.new(options, &block)
-        @cache = if cache.nil?
-          Cache::Default.new
-        elsif cache.fault_tolerant?
-          cache
-        else
-          Cache::FaultTolerantProxy.new(
-            Cache::CircuitProxy.new(cache, notifier: @options.notifier),
-            notifier: @options.notifier
-          )
+      class << self
+        # Wrap a cache backend with sensible defaults
+        #
+        # If the cache is `nil`, create a new {Default}.
+        #
+        # If the backend is not fault tolerant, wrap it in {CircuitProxy} and
+        # {FaultTolerantProxy}.
+        #
+        # @param cache [Interface] A cache backend
+        # @param options [Hash] Attributes for {Options}
+        # @yield [Options] For setting options in a block
+        def wrap(cache, **options, &block)
+          options = Options.new(options, &block)
+          if cache.nil?
+            Cache::Default.new
+          elsif cache.fault_tolerant?
+            cache
+          else
+            Cache::FaultTolerantProxy.new(
+              Cache::CircuitProxy.new(cache, circuit: options.circuit, notifier: options.notifier),
+              notifier: options.notifier
+            )
+          end
         end
-
-        freeze
-      end
-
-      # @!method read(key)
-      #   (see Faulty::Cache::Interface#read)
-      #
-      # @!method write(key, value, expires_in: expires_in)
-      #   (see Faulty::Cache::Interface#write)
-      def_delegators :@cache, :read, :write
-
-      # Auto-wired caches are always fault tolerant
-      #
-      # @return [true]
-      def fault_tolerant?
-        true
       end
     end
   end

data/lib/faulty/events/log_listener.rb

@@ -72,11 +72,10 @@ class Faulty
       end
 
       def storage_failure(payload)
-        log(
-          :error, 'Storage failure', payload[:action],
-          circuit: payload[:circuit]&.name,
-          error: payload[:error].message
-        )
+        extra = {}
+        extra[:circuit] = payload[:circuit].name if payload.key?(:circuit)
+        extra[:error] = payload[:error].message
+        log(:error, 'Storage failure', payload[:action], extra)
       end
 
       def log(level, msg, action, extra = {})

data/lib/faulty/status.rb

@@ -144,9 +144,10 @@ class Faulty
 
     def finalize
       raise ArgumentError, "state must be a symbol in #{self.class}::STATES" unless STATES.include?(state)
-      unless lock.nil? || LOCKS.include?(state)
+      unless lock.nil? || LOCKS.include?(lock)
         raise ArgumentError, "lock must be a symbol in #{self.class}::LOCKS or nil"
       end
+      raise ArgumentError, 'opened_at is required if state is open' if state == :open && opened_at.nil?
     end
 
     def required

data/lib/faulty/storage/auto_wire.rb

@@ -6,10 +6,17 @@ class Faulty
     #
     # Used by {Faulty#initialize} to setup sensible storage defaults
     class AutoWire
-      extend Forwardable
-
       # Options for {AutoWire}
+      #
+      # @!attribute [r] circuit
+      #   @return [Circuit] A circuit for {CircuitProxy} if one is created.
+      #     When modifying this, be careful to use only a reliable circuit
+      #     storage backend so that you don't introduce cascading failures.
+      # @!attribute [r] notifier
+      #   @return [Events::Notifier] A Faulty notifier. If given, listeners are
+      #     ignored.
       Options = Struct.new(
+        :circuit,
         :notifier
       ) do
         include ImmutableOptions
@@ -21,101 +28,79 @@ class Faulty
         end
       end
 
-      # Wrap storage backends with sensible defaults
-      #
-      # If the cache is `nil`, create a new {Memory} storage.
-      #
-      # If a single storage backend is given and is fault tolerant, leave it
-      # unmodified.
-      #
-      # If a single storage backend is given and is not fault tolerant, wrap it
-      # in a {CircuitProxy} and a {FaultTolerantProxy}.
-      #
-      # If an array of storage backends is given, wrap each non-fault-tolerant
-      # entry in a {CircuitProxy} and create a {FallbackChain}. If none of the
-      # backends in the array are fault tolerant, also wrap the {FallbackChain}
-      # in a {FaultTolerantProxy}.
-      #
-      # @todo Consider using a {FallbackChain} for non-fault-tolerant storages
-      #   by default. This would fallback to a {Memory} storage. It would
-      #   require a more conservative implementation of {Memory} that could
-      #   limit the number of circuits stored. For now, users need to manually
-      #   configure fallbacks.
-      #
-      # @param storage [Interface, Array<Interface>] A storage backed or array
-      #   of storage backends to setup.
-      # @param options [Hash] Attributes for {Options}
-      # @yield [Options] For setting options in a block
-      def initialize(storage, **options, &block)
-        @options = Options.new(options, &block)
-        @storage = if storage.nil?
-          Memory.new
-        elsif storage.is_a?(Array)
-          wrap_array(storage)
-        elsif !storage.fault_tolerant?
-          wrap_one(storage)
-        else
-          storage
+      class << self
+        # Wrap storage backends with sensible defaults
+        #
+        # If the cache is `nil`, create a new {Memory} storage.
+        #
+        # If a single storage backend is given and is fault tolerant, leave it
+        # unmodified.
+        #
+        # If a single storage backend is given and is not fault tolerant, wrap it
+        # in a {CircuitProxy} and a {FaultTolerantProxy}.
+        #
+        # If an array of storage backends is given, wrap each non-fault-tolerant
+        # entry in a {CircuitProxy} and create a {FallbackChain}. If none of the
+        # backends in the array are fault tolerant, also wrap the {FallbackChain}
+        # in a {FaultTolerantProxy}.
+        #
+        # @todo Consider using a {FallbackChain} for non-fault-tolerant storages
+        #   by default. This would fallback to a {Memory} storage. It would
+        #   require a more conservative implementation of {Memory} that could
+        #   limit the number of circuits stored. For now, users need to manually
+        #   configure fallbacks.
+        #
+        # @param storage [Interface, Array<Interface>] A storage backed or array
+        #   of storage backends to setup.
+        # @param options [Hash] Attributes for {Options}
+        # @yield [Options] For setting options in a block
+        def wrap(storage, **options, &block)
+          options = Options.new(options, &block)
+          if storage.nil?
+            Memory.new
+          elsif storage.is_a?(Array)
+            wrap_array(storage, options)
+          elsif !storage.fault_tolerant?
+            wrap_one(storage, options)
+          else
+            storage
+          end
         end
 
-        freeze
-      end
-
-      # @!method entry(circuit, time, success)
-      #   (see Faulty::Storage::Interface#entry)
-      #
-      # @!method open(circuit, opened_at)
-      #   (see Faulty::Storage::Interface#open)
-      #
-      # @!method reopen(circuit, opened_at, previous_opened_at)
-      #   (see Faulty::Storage::Interface#reopen)
-      #
-      # @!method close(circuit)
-      #   (see Faulty::Storage::Interface#close)
-      #
-      # @!method lock(circuit, state)
-      #   (see Faulty::Storage::Interface#lock)
-      #
-      # @!method unlock(circuit)
-      #   (see Faulty::Storage::Interface#unlock)
-      #
-      # @!method reset(circuit)
-      #   (see Faulty::Storage::Interface#reset)
-      #
-      # @!method status(circuit)
-      #   (see Faulty::Storage::Interface#status)
-      #
-      # @!method history(circuit)
-      #   (see Faulty::Storage::Interface#history)
-      #
-      # @!method list
-      #   (see Faulty::Storage::Interface#list)
-      #
-      def_delegators :@storage,
-        :entry, :open, :reopen, :close, :lock,
-        :unlock, :reset, :status, :history, :list
-
-      def fault_tolerant?
-        true
-      end
+        private
 
-      private
+        # Wrap an array of storage backends in a fault-tolerant FallbackChain
+        #
+        # @param [Array<Storage::Interface>] The array to wrap
+        # @param options [Options]
+        # @return [Storage::Interface] A fault-tolerant fallback chain
+        def wrap_array(array, options)
+          FaultTolerantProxy.wrap(FallbackChain.new(
+            array.map { |s| s.fault_tolerant? ? s : circuit_proxy(s, options) },
+            notifier: options.notifier
+          ), notifier: options.notifier)
+        end
 
-      # Wrap an array of storage backends in a fault-tolerant FallbackChain
-      #
-      # @return [Storage::Interface] A fault-tolerant fallback chain
-      def wrap_array(array)
-        FaultTolerantProxy.wrap(FallbackChain.new(
-          array.map { |s| s.fault_tolerant? ? s : CircuitProxy.new(s, notifier: @options.notifier) },
-          notifier: @options.notifier
-        ), notifier: @options.notifier)
-      end
+        # Wrap one storage backend in fault-tolerant backends
+        #
+        # @param [Storage::Interface] The storage to wrap
+        # @param options [Options]
+        # @return [Storage::Interface] A fault-tolerant storage backend
+        def wrap_one(storage, options)
+          FaultTolerantProxy.new(
+            circuit_proxy(storage, options),
+            notifier: options.notifier
+          )
+        end
 
-      def wrap_one(storage)
-        FaultTolerantProxy.new(
-          CircuitProxy.new(storage, notifier: @options.notifier),
-          notifier: @options.notifier
-        )
+        # Wrap storage in a CircuitProxy
+        #
+        # @param [Storage::Interface] The storage to wrap
+        # @param options [Options]
+        # @return [CircuitProxy]
+        def circuit_proxy(storage, options)
+          CircuitProxy.new(storage, circuit: options.circuit, notifier: options.notifier)
+        end
       end
     end
   end

data/lib/faulty/storage/redis.rb

@@ -360,7 +360,7 @@ class Faulty
       end
 
       def check_redis_options!
-        ropts = redis { |r| r.client.options }
+        ropts = redis { |r| r.instance_variable_get(:@client).options }
 
         bad_timeouts = {}
         %i[connect_timeout read_timeout write_timeout].each do |time_opt|
@@ -384,7 +384,7 @@ class Faulty
       end
 
       def check_pool_options!
-        if options.client.is_a?(ConnectionPool)
+        if options.client.class.name == 'ConnectionPool'
           timeout = options.client.instance_variable_get(:@timeout)
           warn(<<~MSG) if timeout > 2
             Faulty recommends setting ConnectionPool timeouts <= 2 to prevent

data/lib/faulty/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faulty
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Justin Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-24 00:00:00.000000000 Z
+date: 2021-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -56,14 +56,14 @@ dependencies:
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
@@ -129,10 +129,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
 - ".yardopts"
 - CHANGELOG.md
 - Gemfile
@@ -195,7 +195,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubyforge_project: 
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Fault-tolerance tools for ruby based on circuit-breakers