faulty 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9af8f5d6a81fdf1b625c2d588f2d9f6f55380ebaf00c398d5ed29454bfafea48
-  data.tar.gz: 2d15beb6ffec3967bb740a3567245fe40e7b381408b7203f7cb2cce020802f89
+  metadata.gz: 55bf688c3615a59f51103633db0902abf3458324945ab855894e5975981868f5
+  data.tar.gz: dab412aad317a79364782a85c2a6a184e55fa2214cd966655d74eeab69e248c0
 SHA512:
-  metadata.gz: 4d1a6b24d30ceac93393aef209ac8acb9b24648698aa1f046d32f9e181e3e7208829c62b235139e34cbbf6d4fa3528a9aef24ed48ff359d3b2bc29cd27205165
-  data.tar.gz: a95a10dfdc4ea878a35c1955a6c586ecf254f0fc6c02e02b5aab5cb2da09e5bd3ea4181a8fd652877a213cb0c519eee39735e6da3092cfc270a20832979f3ebc
+  metadata.gz: 7527a23df0c042ea317e99b8fafdf8c8f96ac5f9f68323ba4c4a2901f8e32dc7ca2b7c62b6b7197e446985eab6901f85dd41c6463407ae3632d86e022626d733
+  data.tar.gz: 7e3d48b82905b0ad2303449a532e85736a0681fa4dcb8a5f9ee64e6ffd10c76fdc760ac97aa9dd882f7a019d335440f9d91f0ba1efbb92f978c5e9e43c5b977a

data/.rubocop.yml

@@ -62,6 +62,9 @@ Metrics/BlockLength:
 Metrics/MethodLength:
   Max: 30
 
+Naming/MethodParameterName:
+  MinNameLength: 1
+
 Style/Documentation:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## Release v0.2.0
+
+* Remove Scopes and replace them with Faulty instances #9
+
+### Breaking Changes
+
+* `Faulty::Scope` has been removed. Use `Faulty.new` instead.
+* `Faulty` is now a class, not a module
+
+## Release v0.1.5
+
+* Fix redis storage to expire state key when using CAS #8
+
 ## Release v0.1.4
 
 * Improve spec coverage for supporting classes #6

data/README.md

@@ -203,11 +203,12 @@ In addition to the classic circuit breaker design, Faulty implements caching
 that is integrated with the circuit state. See [Caching](#caching) for more
 detail.
 
-## Global Configuration
+## Configuration
 
-`Faulty.init` can set the following global configuration options. This example
-illustrates the default values. It is also possible to define multiple
-non-global configuration scopes (see [Scopes](#scopes)).
+Faulty can be configured with the following configuration options. This example
+illustrates the default values. In the first example, we configure Faulty
+globally. The second example shows the same configuration using an instance of
+Faulty instead of global configuration.
 
 ```ruby
 Faulty.init do |config|
@@ -233,6 +234,25 @@ Faulty.init do |config|
 end
 ```
 
+Here is the same configuration using an instance of `Faulty`. This is a more
+object-oriented approach.
+
+```ruby
+faulty = Faulty.new do |config|
+  config.cache = Faulty::Cache::Default.new
+  config.storage = Faulty::Storage::Memory.new
+  config.listeners = [Faulty::Events::LogListener.new]
+  config.notifier = Faulty::Events::Notifier.new(config.listeners)
+end
+```
+
+Most of the examples in this README use the global Faulty class methods, but
+they work the same way when using an instance. Just substitute your instance
+instead of `Faulty`. There is no preferred way to use Faulty. Choose whichever
+configuration mechanism works best for your application. Also see
+[Multiple Configurations](#multiple-configurations) if your application needs
+to set different options in different scenarios.
+
 For all Faulty APIs that have configuration, you can also pass in an options
 hash. For example, `Faulty.init` could be called like this:
 
@@ -244,9 +264,9 @@ Faulty.init(cache: Faulty::Cache::Null.new)
 
 A circuit can be created with the following configuration options. Those options
 are only set once, synchronized across threads, and will persist in-memory until
-the process exits. If you're using [scopes](#scopes), the options are retained
-within the context of each scope. All options given after the first call to
-`Faulty.circuit` (or `Scope.circuit`) are ignored.
+the process exits. If you're using [multiple configurations](#multiple-configurations),
+the options are retained within the context of each instance. All options given
+after the first call to `Faulty.circuit` (or `Faulty#circuit`) are ignored.
 
 This is because the circuit objects themselves are internally memoized, and are
 read-only once created.
@@ -307,8 +327,8 @@ Faulty.circuit(:api, cache_expires_in: 1800)
 
 Faulty integrates caching into it's circuits in a way that is particularly
 suited to fault-tolerance. To make use of caching, you must specify the `cache`
-configuration option when initializing Faulty or creating a scope. If you're
-using Rails, this is automatically set to the Rails cache.
+configuration option when initializing Faulty or creating a new Faulty instance.
+If you're using Rails, this is automatically set to the Rails cache.
 
 Once your cache is configured, you can use the `cache` parameter when running
 a circuit to specify a cache key:
@@ -480,8 +500,8 @@ end
 ## Listing Circuits
 
 For monitoring or debugging, you may need to retrieve a list of all circuit
-names. This is possible with `Faulty.list_circuits` (or the equivalent method on
-your [scope](#scopes)).
+names. This is possible with `Faulty.list_circuits` (or `Faulty#list_circuits`
+if you're using an instance).
 
 You can get a list of all circuit statuses by mapping those names to their
 status objects. Be careful though, since this could cause performance issues for
@@ -523,73 +543,73 @@ Locking or unlocking a circuit has no concurrency guarantees, so it's not
 recommended to lock or unlock circuits from production code. Instead, locks are
 intended as an emergency tool for troubleshooting and debugging.
 
-## Scopes
+## Multiple Configurations
 
 It is possible to have multiple configurations of Faulty running within the same
-process. The most common configuration is to simply use `Faulty.init` to
+process. The most common setup is to simply use `Faulty.init` to
 configure Faulty globally, however it is possible to have additional
-configurations using scopes.
+configurations.
 
-### The default scope
+### The default instance
 
-When you call `Faulty.init`, you are actually creating the default scope. You
-can access this scope directly by calling `Faulty.default`.
+When you call `Faulty.init`, you are actually creating the default instance of
+`Faulty`. You can access this instance directly by calling `Faulty.default`.
 
 ```ruby
-# We create the default scope
+# We create the default instance
 Faulty.init
 
-# Access the default scope
-scope = Faulty.default
+# Access the default instance
+faulty = Faulty.default
 
-# Alternatively, access the scope by name
-scope = Faulty[:default]
+# Alternatively, access the instance by name
+faulty = Faulty[:default]
 ```
 
-You can rename the default scope if desired:
+You can rename the default instance if desired:
 
 ```ruby
 Faulty.init(:custom_default)
 
-scope = Faulty.default
-scope = Faulty[:custom_default]
+instance = Faulty.default
+instance = Faulty[:custom_default]
 ```
 
-### Multiple Scopes
+### Multiple Instances
 
-If you want multiple scopes, but want global, thread-safe access to
+If you want multiple instance, but want global, thread-safe access to
 them, you can use `Faulty.register`:
 
 ```ruby
-api_scope = Faulty::Scope.new do |config|
+api_faulty = Faulty.new do |config|
   # This accepts the same options as Faulty.init
 end
 
-Faulty.register(:api, api_scope)
+Faulty.register(:api, api_faulty)
 
-# Now access the scope globally
+# Now access the instance globally
 Faulty[:api]
 ```
 
 When you call `Faulty.circuit`, that's the same as calling
-`Faulty.default.circuit`, so you can apply the same API to any other Faulty
-scope:
+`Faulty.default.circuit`, so you can apply the same principal to any other
+registered Faulty instance:
 
 ```ruby
 Faulty[:api].circuit(:api_circuit).run { 'ok' }
 ```
 
-### Standalone Scopes
+### Standalone Instances
 
-If you choose, you can use Faulty scopes without registering them globally. This
-could be useful if you prefer dependency injection over global state.
+If you choose, you can use Faulty instances without registering them globally.
+This is more object-oriented and is necessary if you use dependency injection.
 
 ```ruby
-faulty = Faulty::Scope.new
+faulty = Faulty.new
 faulty.circuit(:standalone_circuit)
 ```
 
-Calling `circuit` on the scope still has the same memoization behavior that
+Calling `#circuit` on the instance still has the same memoization behavior that
 `Faulty.circuit` has, so subsequent calls to the same circuit will return a
 memoized circuit object.
 
@@ -660,7 +680,7 @@ but there are and have been many other options:
 
 - Simple API but configurable for advanced users
 - Pluggable storage backends (circuitbox also has this)
-- Global, or local configuration with scopes
+- Global, or object-oriented configuration with multiple instances
 - Integrated caching support tailored for fault-tolerance
 - Manually lock circuits open or closed
 

data/lib/faulty.rb

@@ -9,14 +9,16 @@ require 'faulty/circuit'
 require 'faulty/error'
 require 'faulty/events'
 require 'faulty/result'
-require 'faulty/scope'
 require 'faulty/status'
 require 'faulty/storage'
 
-# The top-level namespace for Faulty
+# The {Faulty} class has class-level methods for global state or can be
+# instantiated to create an independent configuration.
 #
-# Fault-tolerance tools for ruby based on circuit-breakers
-module Faulty
+# If you are using global state, call {Faulty#init} during your application's
+# initialization. This is the simplest way to use {Faulty}. If you prefer, you
+# can also call {Faulty.new} to create independent {Faulty} instances.
+class Faulty
   class << self
     # Start the Faulty environment
     #
@@ -27,78 +29,79 @@ module Faulty
     # are spawned.
     #
     # If you prefer dependency-injection instead of global state, you can skip
-    # init and pass a {Scope} directly to your dependencies.
+    # `init` and use {Faulty.new} to pass an instance directoy to your
+    # dependencies.
     #
-    # @param scope_name [Symbol] The name of the default scope. Can be set to
-    #   `nil` to skip creating a default scope.
-    # @param config [Hash] Attributes for {Scope::Options}
-    # @yield [Scope::Options] For setting options in a block
+    # @param default_name [Symbol] The name of the default instance. Can be set
+    # to `nil` to skip creating a default instance.
+    # @param config [Hash] Attributes for {Faulty::Options}
+    # @yield [Faulty::Options] For setting options in a block
     # @return [self]
-    def init(scope_name = :default, **config, &block)
-      raise AlreadyInitializedError if @scopes
+    def init(default_name = :default, **config, &block)
+      raise AlreadyInitializedError if @instances
 
-      @default_scope = scope_name
-      @scopes = Concurrent::Map.new
-      register(scope_name, Scope.new(**config, &block)) unless scope_name.nil?
+      @default_instance = default_name
+      @instances = Concurrent::Map.new
+      register(default_name, new(**config, &block)) unless default_name.nil?
       self
     rescue StandardError
-      @scopes = nil
+      @instances = nil
       raise
     end
 
-    # Get the default scope given during {.init}
+    # Get the default instance given during {.init}
     #
-    # @return [Scope, nil] The default scope if it is registered
+    # @return [Faulty, nil] The default instance if it is registered
     def default
-      raise UninitializedError unless @scopes
-      raise MissingDefaultScopeError unless @default_scope
+      raise UninitializedError unless @instances
+      raise MissingDefaultInstanceError unless @default_instance
 
-      self[@default_scope]
+      self[@default_instance]
     end
 
-    # Get a scope by name
+    # Get an instance by name
     #
-    # @return [Scope, nil] The named scope if it is registered
-    def [](scope_name)
-      raise UninitializedError unless @scopes
+    # @return [Faulty, nil] The named instance if it is registered
+    def [](name)
+      raise UninitializedError unless @instances
 
-      @scopes[scope_name]
+      @instances[name]
     end
 
-    # Register a scope to the global Faulty state
+    # Register an instance to the global Faulty state
     #
-    # Will not replace an existing scope with the same name. Check the
-    # return value if you need to know whether the scope already existed.
+    # Will not replace an existing instance with the same name. Check the
+    # return value if you need to know whether the instance already existed.
     #
-    # @param name [Symbol] The name of the scope to register
-    # @param scope [Scope] The scope to register
-    # @return [Scope, nil] The previously-registered scope of that name if
+    # @param name [Symbol] The name of the instance to register
+    # @param instance [Faulty] The instance to register
+    # @return [Faulty, nil] The previously-registered instance of that name if
     #   it already existed, otherwise nil.
-    def register(name, scope)
-      raise UninitializedError unless @scopes
+    def register(name, instance)
+      raise UninitializedError unless @instances
 
-      @scopes.put_if_absent(name, scope)
+      @instances.put_if_absent(name, instance)
     end
 
-    # Get the options for the default scope
+    # Get the options for the default instance
     #
-    # @raise MissingDefaultScopeError If the default scope has not been created
-    # @return [Scope::Options]
+    # @raise MissingDefaultInstanceError If the default instance has not been created
+    # @return [Faulty::Options]
     def options
       default.options
     end
 
-    # Get or create a circuit for the default scope
+    # Get or create a circuit for the default instance
     #
-    # @raise UninitializedError If the default scope has not been created
-    # @param (see Scope#circuit)
-    # @yield (see Scope#circuit)
-    # @return (see Scope#circuit)
+    # @raise UninitializedError If the default instance has not been created
+    # @param (see Faulty#circuit)
+    # @yield (see Faulty#circuit)
+    # @return (see Faulty#circuit)
     def circuit(name, **config, &block)
       default.circuit(name, **config, &block)
     end
 
-    # Get a list of all circuit names for the default scope
+    # Get a list of all circuit names for the default instance
     #
     # @return [Array<String>] The circuit names
     def list_circuits
@@ -115,4 +118,113 @@ module Faulty
       Time.now.to_i
     end
   end
+
+  attr_reader :options
+
+  # Options for {Faulty}
+  #
+  # @!attribute [r] cache
+  #   @return [Cache::Interface] A cache backend if you want
+  #     to use Faulty's cache support. Automatically wrapped in a
+  #     {Cache::FaultTolerantProxy}. Default `Cache::Default.new`.
+  # @!attribute [r] storage
+  #   @return [Storage::Interface] The storage backend.
+  #     Automatically wrapped in a {Storage::FaultTolerantProxy}.
+  #     Default `Storage::Memory.new`.
+  # @!attribute [r] listeners
+  #   @return [Array] listeners Faulty event listeners
+  # @!attribute [r] notifier
+  #   @return [Events::Notifier] A Faulty notifier. If given, listeners are
+  #     ignored.
+  Options = Struct.new(
+    :cache,
+    :storage,
+    :listeners,
+    :notifier
+  ) do
+    include ImmutableOptions
+
+    private
+
+    def finalize
+      self.notifier ||= Events::Notifier.new(listeners || [])
+
+      self.storage ||= Storage::Memory.new
+      unless storage.fault_tolerant?
+        self.storage = Storage::FaultTolerantProxy.new(storage, notifier: notifier)
+      end
+
+      self.cache ||= Cache::Default.new
+      unless cache.fault_tolerant?
+        self.cache = Cache::FaultTolerantProxy.new(cache, notifier: notifier)
+      end
+    end
+
+    def required
+      %i[cache storage notifier]
+    end
+
+    def defaults
+      {
+        listeners: [Events::LogListener.new]
+      }
+    end
+  end
+
+  # Create a new {Faulty} instance
+  #
+  # Note, the process of creating a new instance is not thread safe,
+  # so make sure instances are setup during your application's initialization
+  # phase.
+  #
+  # For the most part, {Faulty} instances are independent, however for some
+  # cache and storage backends, you will need to ensure that the cache keys
+  # and circuit names don't overlap between instances. For example, if using the
+  # {Storage::Redis} storage backend, you should specify different key
+  # prefixes for each instance.
+  #
+  # @see Options
+  # @param options [Hash] Attributes for {Options}
+  # @yield [Options] For setting options in a block
+  def initialize(**options, &block)
+    @circuits = Concurrent::Map.new
+    @options = Options.new(options, &block)
+  end
+
+  # Create or retrieve a circuit
+  #
+  # Within an instance, circuit instances have unique names, so if the given circuit
+  # name already exists, then the existing circuit will be returned, otherwise
+  # a new circuit will be created. If an existing circuit is returned, then
+  # the {options} param and block are ignored.
+  #
+  # @param name [String] The name of the circuit
+  # @param options [Hash] Attributes for {Circuit::Options}
+  # @yield [Circuit::Options] For setting options in a block
+  # @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
+      Circuit.new(name, **options, &block)
+    end
+  end
+
+  # Get a list of all circuit names
+  #
+  # @return [Array<String>] The circuit names
+  def list_circuits
+    options.storage.list
+  end
+
+  private
+
+  # Get circuit options from the {Faulty} options
+  #
+  # @return [Hash] The circuit options
+  def circuit_options
+    options = @options.to_h
+    options.delete(:listeners)
+    options
+  end
 end

data/lib/faulty/cache.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # The namespace for Faulty caching
   module Cache
   end

data/lib/faulty/cache/default.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Cache
     # The default cache implementation
     #

data/lib/faulty/cache/fault_tolerant_proxy.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Cache
     # A wrapper for cache backends that may raise errors
     #
-    # {Scope} automatically wraps all non-fault-tolerant cache backends with
+    # {Faulty#initialize} automatically wraps all non-fault-tolerant cache backends with
     # this class.
     #
     # If the cache backend raises a `StandardError`, it will be captured and

data/lib/faulty/cache/interface.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Cache
     # The interface required for a cache backend implementation
     #

data/lib/faulty/cache/mock.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Cache
     # A mock cache for testing
     #

data/lib/faulty/cache/null.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Cache
     # A cache backend that does nothing
     #

data/lib/faulty/cache/rails.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Cache
     # A wrapper for a Rails or ActiveSupport cache
     #

data/lib/faulty/circuit.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # Runs code protected by a circuit breaker
   #
   # https://www.martinfowler.com/bliki/CircuitBreaker.html

data/lib/faulty/error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # The base error for all Faulty errors
   class FaultyError < StandardError; end
 
@@ -20,10 +20,10 @@ module Faulty
     end
   end
 
-  # Raised if getting the default scope without initializing one
-  class MissingDefaultScopeError < FaultyError
+  # Raised if getting the default instance without initializing one
+  class MissingDefaultInstanceError < FaultyError
     def initialize(message = nil)
-      message ||= 'No default scope. Create one with init or get your scope with Faulty[:scope_name]'
+      message ||= 'No default instance. Create one with init or get your instance with Faulty[:name]'
       super(message)
     end
   end

data/lib/faulty/events.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # The namespace for Faulty events and event listeners
   module Events
     # All possible events that can be raised by Faulty

data/lib/faulty/events/callback_listener.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Events
     # A simple listener implementation that uses callback blocks as handlers
     #

data/lib/faulty/events/honeybadger_listener.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Events
     # Reports circuit errors to Honeybadger
     #

data/lib/faulty/events/listener_interface.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Events
     # The interface required to implement a event listener
     #

data/lib/faulty/events/log_listener.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Events
     # A default listener that logs Faulty events
     class LogListener

data/lib/faulty/events/notifier.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Events
     # The default event dispatcher for Faulty
     class Notifier

data/lib/faulty/immutable_options.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # A struct that cannot be modified after initialization
   module ImmutableOptions
     # @param hash [Hash] A hash of attributes to initialize with

data/lib/faulty/result.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # An approximation of the `Result` type from some strongly-typed languages.
   #
   # F#: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/results
@@ -53,7 +53,7 @@ module Faulty
     #
     # @param ok An ok value
     # @param error [Error] An error instance
-    def initialize(ok: NOTHING, error: NOTHING) # rubocop:disable Naming/MethodParameterName
+    def initialize(ok: NOTHING, error: NOTHING)
       if ok.equal?(NOTHING) && error.equal?(NOTHING)
         raise ArgumentError, 'Result must have an ok or error value'
       end

data/lib/faulty/status.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # The status of a circuit
   #
   # Includes information like the state and locks. Also calculates

data/lib/faulty/storage.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # The namespace for Faulty storage
   module Storage
   end

data/lib/faulty/storage/fault_tolerant_proxy.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Storage
     # A wrapper for storage backends that may raise errors
     #
-    # {Scope} automatically wraps all non-fault-tolerant storage backends with
+    # {Faulty#initialize} automatically wraps all non-fault-tolerant storage backends with
     # this class.
     #
     # If the storage backend raises a `StandardError`, it will be captured and

data/lib/faulty/storage/interface.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Storage
     # The interface required for a storage backend implementation
     #

data/lib/faulty/storage/memory.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Storage
     # The default in-memory storage for circuits
     #

data/lib/faulty/storage/redis.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   module Storage
     class Redis # rubocop:disable Metrics/ClassLength
       # Separates the time/status for history entry strings
@@ -97,7 +97,7 @@ module Faulty
       # @return (see Interface#open)
       def open(circuit, opened_at)
         redis do |r|
-          opened = compare_and_set(r, state_key(circuit), ['closed', nil], 'open')
+          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
         end
@@ -110,7 +110,7 @@ module Faulty
       # @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)
+          compare_and_set(r, opened_at_key(circuit), [previous_opened_at.to_s], opened_at, ex: options.circuit_ttl)
         end
       end
 
@@ -121,7 +121,7 @@ module Faulty
       # @return (see Interface#close)
       def close(circuit)
         redis do |r|
-          closed = compare_and_set(r, state_key(circuit), ['open'], 'closed')
+          closed = compare_and_set(r, state_key(circuit), ['open'], 'closed', ex: options.circuit_ttl)
           r.del(entries_key(circuit)) if closed
           closed
         end
@@ -287,10 +287,10 @@ module Faulty
       # @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)
+      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) }
+            result = redis.multi { |m| m.set(key, new, ex: ex) }
             result && result[0] == 'OK'
           else
             redis.unwatch

data/lib/faulty/version.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Faulty
+class Faulty
   # The current Faulty version
   def self.version
-    Gem::Version.new('0.1.4')
+    Gem::Version.new('0.2.0')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faulty
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Justin Howard
@@ -164,7 +164,6 @@ files:
 - lib/faulty/events/notifier.rb
 - lib/faulty/immutable_options.rb
 - lib/faulty/result.rb
-- lib/faulty/scope.rb
 - lib/faulty/status.rb
 - lib/faulty/storage.rb
 - lib/faulty/storage/fault_tolerant_proxy.rb

data/lib/faulty/scope.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module Faulty
-  # A {Scope} is a group of options and circuits
-  #
-  # For most use-cases the default scope should be used, however, it's possible
-  # to create any number of scopes for applications that require a more complex
-  # configuration or for testing.
-  #
-  # For the most part, scopes are independent, however for some cache and
-  # storage backends, you will need to ensure that the cache keys and circuit
-  # names don't overlap between scopes. For example, if using the Redis storage
-  # backend, you should specify different key prefixes for each scope.
-  class Scope
-    attr_reader :options
-
-    # Options for {Scope}
-    #
-    # @!attribute [r] cache
-    #   @return [Cache::Interface] A cache backend if you want
-    #     to use Faulty's cache support. Automatically wrapped in a
-    #     {Cache::FaultTolerantProxy}. Default `Cache::Default.new`.
-    # @!attribute [r] storage
-    #   @return [Storage::Interface] The storage backend.
-    #     Automatically wrapped in a {Storage::FaultTolerantProxy}.
-    #     Default `Storage::Memory.new`.
-    # @!attribute [r] listeners
-    #   @return [Array] listeners Faulty event listeners
-    # @!attribute [r] notifier
-    #   @return [Events::Notifier] A Faulty notifier. If given, listeners are
-    #     ignored.
-    Options = Struct.new(
-      :cache,
-      :storage,
-      :listeners,
-      :notifier
-    ) do
-      include ImmutableOptions
-
-      private
-
-      def finalize
-        self.notifier ||= Events::Notifier.new(listeners || [])
-
-        self.storage ||= Storage::Memory.new
-        unless storage.fault_tolerant?
-          self.storage = Storage::FaultTolerantProxy.new(storage, notifier: notifier)
-        end
-
-        self.cache ||= Cache::Default.new
-        unless cache.fault_tolerant?
-          self.cache = Cache::FaultTolerantProxy.new(cache, notifier: notifier)
-        end
-      end
-
-      def required
-        %i[cache storage notifier]
-      end
-
-      def defaults
-        {
-          listeners: [Events::LogListener.new]
-        }
-      end
-    end
-
-    # Create a new Faulty Scope
-    #
-    # Note, the process of creating a new scope is not thread safe,
-    # so make sure scopes are setup before spawning threads.
-    #
-    # @see Options
-    # @param options [Hash] Attributes for {Options}
-    # @yield [Options] For setting options in a block
-    def initialize(**options, &block)
-      @circuits = Concurrent::Map.new
-      @options = Options.new(options, &block)
-    end
-
-    # Create or retrieve a circuit
-    #
-    # Within a scope, circuit instances have unique names, so if the given circuit
-    # name already exists, then the existing circuit will be returned, otherwise
-    # a new circuit will be created. If an existing circuit is returned, then
-    # the {options} param and block are ignored.
-    #
-    # @param name [String] The name of the circuit
-    # @param options [Hash] Attributes for {Circuit::Options}
-    # @yield [Circuit::Options] For setting options in a block
-    # @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
-        Circuit.new(name, **options, &block)
-      end
-    end
-
-    # Get a list of all circuit names
-    #
-    # @return [Array<String>] The circuit names
-    def list_circuits
-      options.storage.list
-    end
-
-    private
-
-    # Get circuit options from the scope options
-    #
-    # @return [Hash] The circuit options
-    def circuit_options
-      options = @options.to_h
-      options.delete(:listeners)
-      options
-    end
-  end
-end