circuitbox 2.0.0.pre4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb89d6ef46d73dfa35e7c43181112309aa524979ec1285688cc8cebf8d781bd4
-  data.tar.gz: 735c23115ea5127923c05b84d5b6cfe64193521bcd751639cc6ceab32c6b97ce
+  metadata.gz: 206d564d542dc903001281052403166a100732fc9b2b0f1f0999601e4543893b
+  data.tar.gz: '0095c6111ab38a311cb48ae8df82906185cef5b2b3ee8e761f08c9bacfb95782'
 SHA512:
-  metadata.gz: a29d10725e8a1a36eec12985681cd66b7c2b3303cb996bfe72226674230d7c8ef38b02bb5731665edd49c7922b2a9f0072434a2ab33da7f64713875415071420
-  data.tar.gz: 9a165096e2b0e5fe484c433284a3c0b6658f4b880552602cb57b22fcf3ea540302b3d3a0910b31b8f3e1938259ca6394faefd3bffffc6c40bf3104d8d02564ec
+  metadata.gz: 314fe848d0dfbcc1aab3b71f469349b950b3dd117df76fcc88d2e37da574ce03000a9f6b62f712d7e4d1b069d5428d12d75d29bb91410ed4c0a83d8a6bfd41ae
+  data.tar.gz: 613f95add06ef602442bcde07b62f12d2fdee60c5713fcb72b71d09ddcbe8085340ffdcbd9ad83161cf31b55536c2e9ec5cce0beaddfac3737fd7a39c62aec3f

data/README.md

@@ -2,10 +2,16 @@
 
 ![Tests](https://github.com/yammer/circuitbox/workflows/Tests/badge.svg) [![Gem Version](https://badge.fury.io/rb/circuitbox.svg)](https://badge.fury.io/rb/circuitbox)
 
-Circuitbox is a Ruby circuit breaker gem. It protects your application from failures of its service dependencies. It wraps calls to external services and monitors for failures in one minute intervals. Once more than 10 requests have been made with a 50% failure rate, Circuitbox stops sending requests to that failing service for one minute. This helps your application gracefully degrade.
+Circuitbox is a Ruby circuit breaker gem.
+It protects your application from failures of its service dependencies.
+It wraps calls to external services and monitors for failures in one minute intervals.
+Using a circuit's defaults once more than 5 requests have been made with a 50% failure rate, Circuitbox stops sending requests to that failing service for 90 seconds.
+This helps your application gracefully degrade.
+
 Resources about the circuit breaker pattern:
 * [http://martinfowler.com/bliki/CircuitBreaker.html](http://martinfowler.com/bliki/CircuitBreaker.html)
-* [https://github.com/Netflix/Hystrix/wiki/How-it-Works#CircuitBreaker](https://github.com/Netflix/Hystrix/wiki/How-it-Works#CircuitBreaker)
+
+*Upgrading to 2.x? See [2.0 upgrade](docs/2.0-upgrade.md)*
 
 ## Usage
 
@@ -25,7 +31,7 @@ class ExampleServiceClient
   end
 
   def http_get
-    circuit.run(circuitbox_exceptions: false) do
+    circuit.run(exception: false) do
       Zephyr.new("http://example.com").get(200, 1000, "/api/messages")
     end
   end
@@ -43,19 +49,22 @@ Using the `run` method will throw an exception when the circuit is open or the u
 ```
 
 ## Global Configuration
-Circuitbox has defaults for circuit_store, notifier, and logger.
-This can be configured through ```Circuitbox.configure```.
-The circuit cache used by ```Circuitbox.circuit``` will be cleared after running ```Circuitbox.configure```.
-This means when accessing the circuit through ```Circuitbox.circuit``` any custom configuration options should always be given.
 
-Any circuit created manually through ```Circuitbox::CircuitBreaker``` before updating the configuration
-will need to be recreated to pick up the new defaults.
+Circuitbox defaults can be configured through ```Circuitbox.configure```.
+There are two defaults that can be configured:
+* `default_circuit_store` - Defaults to a `Circuitbox::MemoryStore`. This can be changed to a compatible Moneta store.
+* `default_notifier` - Defaults to `Circuitbox::Notifier::ActiveSupport` if `ActiveSupport::Notifications` is defined, otherwise defaults to `Circuitbox::Notifier::Null`
+
+After configuring circuitbox through `Circuitbox.configure`, the internal circuit cache of `Circuitbox.circuit` is cleared.
+
+Any circuit created manually through ```Circuitbox::CircuitBreaker``` before updating the configuration will need to be recreated to pick up the new defaults.
+
+The following is an example Circuitbox configuration:
 
 ```ruby
   Circuitbox.configure do |config|
     config.default_circuit_store = Circuitbox::MemoryStore.new
     config.default_notifier = Circuitbox::Notifier::Null.new
-    config.default_logger = Rails.logger
   end
 ```
 
@@ -81,17 +90,12 @@ class ExampleServiceClient
       # the store you want to use to save the circuit state so it can be
       # tracked, this needs to be Moneta compatible, and support increment
       # this overrides what is set in the global configuration
-      cache: Circuitbox::MemoryStore.new,
+      circuit_store: Circuitbox::MemoryStore.new,
 
       # exceeding this rate will open the circuit (checked on failures)
       error_threshold:  50,
 
-      # Logger to use
-      # This overrides what is set in the global configuration
-      logger: Logger.new(STDOUT),
-
       # Customized notifier
-      # overrides the default
       # this overrides what is set in the global configuration
       notifier: Notifier.new
     })
@@ -108,16 +112,17 @@ Circuitbox.circuit(:yammer, {
 })
 ```
 
-## Circuit Store (:cache)
+## Circuit Store
 
 Holds all the relevant data to trip the circuit if a given number of requests
 fail in a specified period of time. Circuitbox also supports
-[Moneta](https://github.com/minad/moneta). As moneta is not a dependency of circuitbox
+[Moneta](https://github.com/moneta-rb/moneta). As moneta is not a dependency of circuitbox
 it needs to be loaded prior to use. There are a lot of moneta stores to choose from but
 some pre-requisits need to be satisfied first:
 
 - Needs to support increment, this is true for most but not all available stores.
 - Needs to support expiry.
+- Needs to support bulk read.
 - Needs to support concurrent access if you share them. For example sharing a
   KyotoCabinet store across process fails because the store is single writer
   multiple readers, and all circuits sharing the store need to be able to write.
@@ -125,60 +130,14 @@ some pre-requisits need to be satisfied first:
 
 ## Notifications
 
-circuitbox use ActiveSupport Notifications.
-
-Usage example:
-
-**Log on circuit open/close:**
-
-```ruby
-class CircuitOpenException    < StandardError ; end
-
-ActiveSupport::Notifications.subscribe('circuit_open') do |name, start, finish, id, payload|
-  circuit_name = payload[:circuit]
-  Rails.logger.warn("Open circuit for: #{circuit_name}")
-end
-ActiveSupport::Notifications.subscribe('circuit_close') do |name, start, finish, id, payload|
-  circuit_name = payload[:circuit]
-  Rails.logger.info("Close circuit for: #{circuit_name}")
-end
-```
-
-**generate metrics:**
-
-```ruby
-$statsd = Statsd.new 'localhost', 9125
-
-ActiveSupport::Notifications.subscribe('circuit_gauge') do |name, start, finish, id, payload|
-  circuit_name = payload[:circuit]
-  gauge        = payload[:gauge]
-  value        = payload[:value]
-  metrics_key  = "circuitbox.circuit.#{circuit_name}.#{gauge}"
-
-  $statsd.gauge(metrics_key, value)
-end
-```
-
-`payload[:gauge]` can be:
-
-- `runtime` # runtime will only be notified when circuit is closed and block is successfully executed.
-
-**warnings:**
-in case of misconfiguration, circuitbox will fire a circuitbox_warning
-notification.
-
-```ruby
-ActiveSupport::Notifications.subscribe('circuit_warning') do |name, start, finish, id, payload|
-  circuit_name = payload[:circuit]
-  warning      = payload[:message]
-  Rails.logger.warning("#{circuit_name} - #{warning}")
-end
-
-```
+See [Circuit Notifications](docs/circuit_notifications.md)
 
 ## Faraday
 
-Circuitbox ships with [Faraday HTTP client](https://github.com/lostisland/faraday) middleware.
+Circuitbox ships with a [Faraday HTTP client](https://github.com/lostisland/faraday) middleware.
+The versions of faraday the middleware has been tested against is `>= 0.17` through `~> 2.0`.
+The middleware does not support parallel requests through a connections `in_parallel` method.
+
 
 ```ruby
 require 'faraday'

data/lib/circuitbox/circuit_breaker.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'circuit_breaker/logger_messages'
+require_relative 'time_helper/monotonic'
+require_relative 'time_helper/real'
 
 class Circuitbox
   class CircuitBreaker
-    include LoggerMessages
-
     attr_reader :service, :circuit_options, :exceptions,
-                :logger, :circuit_store, :notifier, :time_class
+                :circuit_store, :notifier, :time_class
 
     DEFAULTS = {
       sleep_window: 90,
@@ -16,20 +15,23 @@ class Circuitbox
       time_window: 60
     }.freeze
 
+    # Initialize a CircuitBreaker
     #
-    # Configuration options
-    #
-    # `sleep_window`      - seconds to sleep the circuit
-    # `volume_threshold`  - number of requests before error rate calculation occurs
-    # `error_threshold`   - percentage of failed requests needed to trip circuit
-    # `exceptions`        - exceptions that count as failures
-    # `time_window`       - interval of time used to calculate error_rate (in seconds) - default is 60s
-    # `logger`            - Logger to use - defaults to Rails.logger if defined, otherwise STDOUT
+    # @param service [String, Symbol] Name of the circuit for notifications and metrics store
+    # @param options [Hash] Options to create the circuit with
+    # @option options [Integer] :time_window (60) Interval of time, in seconds, used to calculate the error_rate
+    # @option options [Integer, Proc] :sleep_window (90) Seconds for the circuit to stay open when tripped
+    # @option options [Integer, Proc] :volume_threshold (5) Number of requests before error rate is first calculated
+    # @option options [Integer, Proc] :error_threshold (50) Percentage of failed requests needed to trip the circuit
+    # @option options [Array] :exceptions The exceptions that should be monitored and counted as failures
+    # @option options [Circuitbox::MemoryStore, Moneta] :circuit_store (Circuitbox.default_circuit_store) Class to store circuit open/close statistics
+    # @option options [Object] :notifier (Circuitbox.default_notifier) Class notifications are sent to
     #
+    # @raise [ArgumentError] If the exceptions option is not an Array
     def initialize(service, options = {})
       @service = service.to_s
       @circuit_options = DEFAULTS.merge(options)
-      @circuit_store   = options.fetch(:cache) { Circuitbox.default_circuit_store }
+      @circuit_store   = options.fetch(:circuit_store) { Circuitbox.default_circuit_store }
       @notifier = options.fetch(:notifier) { Circuitbox.default_notifier }
 
       if @circuit_options[:timeout_seconds]
@@ -37,47 +39,73 @@ class Circuitbox
              'Check the upgrade guide at https://github.com/yammer/circuitbox')
       end
 
+      if @circuit_options[:cache]
+        warn('cache was changed to circuit_store in circuitbox 2.0. '\
+             'Check the upgrade guide at https://github.com/yammer/circuitbox')
+      end
+
       @exceptions = options.fetch(:exceptions)
-      raise ArgumentError.new('exceptions need to be an array') unless @exceptions.is_a?(Array)
+      raise ArgumentError.new('exceptions must be an array') unless @exceptions.is_a?(Array)
+
+      @time_class = options.fetch(:time_class) { default_time_klass }
 
-      @logger     = options.fetch(:logger) { Circuitbox.default_logger }
-      @time_class = options.fetch(:time_class) { Time }
       @state_change_mutex = Mutex.new
+      @open_storage_key = "circuits:#{@service}:open"
+      @half_open_storage_key = "circuits:#{@service}:half_open"
       check_sleep_window
     end
 
     def option_value(name)
-      value = circuit_options[name]
+      value = @circuit_options[name]
       value.is_a?(Proc) ? value.call : value
     end
 
-    def run(circuitbox_exceptions: true, &block)
+    # Run the circuit with the given block.
+    # If the circuit is closed or half_open the block will run.
+    # If the circuit is open the block will not be run.
+    #
+    # @param exception [Boolean] If exceptions should be raised when the circuit is open
+    #   or when a watched exception is raised from the block
+    # @yield Block to run if circuit is not open
+    #
+    # @raise [Circuitbox::OpenCircuitError] If the circuit is open and exception is true
+    # @raise [Circuitbox::ServiceFailureError] If a tracked exception is raised from the block and exception is true
+    #
+    # @return [Object] The result from the block
+    # @return [Nil] If the circuit is open and exception is false
+    #   In cases where an exception that circuitbox is watching is raised from either a notifier
+    #   or from a custom circuit store nil can be returned even though the block ran successfully
+    def run(exception: true, &block)
       if open?
         skipped!
-        raise Circuitbox::OpenCircuitError.new(service) if circuitbox_exceptions
+        raise Circuitbox::OpenCircuitError.new(@service) if exception
       else
-        logger.debug(circuit_running_message)
-
         begin
-          response = Timer.measure(service, notifier, 'runtime', &block)
+          response = @notifier.notify_run(@service, &block)
 
           success!
-        rescue *exceptions => e
+        rescue *@exceptions => e
           # Other stores could raise an exception that circuitbox is asked to watch.
-          # setting to nil keeps the same behavior as the previous defination of run.
+          # setting to nil keeps the same behavior as the previous definition of run.
           response = nil
           failure!
-          raise Circuitbox::ServiceFailureError.new(service, e) if circuitbox_exceptions
+          raise Circuitbox::ServiceFailureError.new(@service, e) if exception
         end
       end
 
       response
     end
 
+    # Check if the circuit is open
+    #
+    # @return [Boolean] True if circuit is open, False if closed
     def open?
-      circuit_store.key?(open_storage_key)
+      @circuit_store.key?(@open_storage_key)
     end
 
+    # Calculates the current error rate of the circuit
+    #
+    # @return [Float] Error Rate
     def error_rate(failures = failure_count, success = success_count)
       all_count = failures + success
       return 0.0 unless all_count.positive?
@@ -85,34 +113,52 @@ class Circuitbox
       (failures / all_count.to_f) * 100
     end
 
+    # Number of Failures the circuit has encountered in the current time window
+    #
+    # @return [Integer] Number of failures
     def failure_count
-      circuit_store.load(stat_storage_key('failure'), raw: true).to_i
+      @circuit_store.load(stat_storage_key('failure'), raw: true).to_i
     end
 
+    # Number of successes the circuit has encountered in the current time window
+    #
+    # @return [Integer] Number of successes
     def success_count
-      circuit_store.load(stat_storage_key('success'), raw: true).to_i
+      @circuit_store.load(stat_storage_key('success'), raw: true).to_i
     end
 
+    # If the circuit is open the key indicating that the circuit is open
+    # On the next call to run the circuit would run as if it were in the half open state
+    #
+    # This does not reset any of the circuit success/failure state so future failures
+    # in the same time window may cause the circuit to open sooner
     def try_close_next_time
-      circuit_store.delete(open_storage_key)
+      @circuit_store.delete(@open_storage_key)
     end
 
     private
 
     def should_open?
-      failures = failure_count
-      successes = success_count
-      rate = error_rate(failures, successes)
-
-      passed_volume_threshold?(failures, successes) && passed_rate_threshold?(rate)
+      aligned_time = align_time_to_window
+
+      failures, successes = @circuit_store.values_at(stat_storage_key('failure', aligned_time),
+                                                     stat_storage_key('success', aligned_time),
+                                                     raw: true)
+      # Calling to_i is only needed for moneta stores which can return a string representation of an integer.
+      # While readability could increase by adding .map(&:to_i) to the end of the values_at call it's also slightly
+      # less performant when we only have two values to convert.
+      failures = failures.to_i
+      successes = successes.to_i
+
+      passed_volume_threshold?(failures, successes) && passed_rate_threshold?(failures, successes)
     end
 
     def passed_volume_threshold?(failures, successes)
       failures + successes >= option_value(:volume_threshold)
     end
 
-    def passed_rate_threshold?(rate)
-      rate >= option_value(:error_threshold)
+    def passed_rate_threshold?(failures, successes)
+      error_rate(failures, successes) >= option_value(:error_threshold)
     end
 
     def half_open_failure
@@ -122,7 +168,7 @@ class Circuitbox
         trip
       end
 
-      # Running event and logger outside of the synchronize block to allow other threads
+      # Running event outside of the synchronize block to allow other threads
       # that may be waiting to become unblocked
       notify_opened
     end
@@ -134,19 +180,18 @@ class Circuitbox
         trip
       end
 
-      # Running event and logger outside of the synchronize block to allow other threads
+      # Running event outside of the synchronize block to allow other threads
       # that may be waiting to become unblocked
       notify_opened
     end
 
     def notify_opened
       notify_event('open')
-      logger.debug(circuit_opened_message)
     end
 
     def trip
-      circuit_store.store(open_storage_key, true, expires: option_value(:sleep_window))
-      circuit_store.store(half_open_storage_key, true)
+      @circuit_store.store(@open_storage_key, true, expires: option_value(:sleep_window))
+      @circuit_store.store(@half_open_storage_key, true)
     end
 
     def close!
@@ -154,29 +199,26 @@ class Circuitbox
         # If the circuit is not open, the half_open key will be deleted from the store
         # if half_open exists the deleted value is returned and allows us to continue
         # if half_open doesn't exist nil is returned, causing us to return early
-        return unless !open? && circuit_store.delete(half_open_storage_key)
+        return unless !open? && @circuit_store.delete(@half_open_storage_key)
       end
 
       # Running event outside of the synchronize block to allow other threads
       # that may be waiting to become unblocked
       notify_event('close')
-      logger.debug(circuit_closed_message)
     end
 
     def half_open?
-      circuit_store.key?(half_open_storage_key)
+      @circuit_store.key?(@half_open_storage_key)
     end
 
     def success!
       increment_and_notify_event('success')
-      logger.debug(circuit_success_message)
 
       close! if half_open?
     end
 
     def failure!
       increment_and_notify_event('failure')
-      logger.debug(circuit_failure_message)
 
       if half_open?
         half_open_failure
@@ -187,20 +229,31 @@ class Circuitbox
 
     def skipped!
       notify_event('skipped')
-      logger.debug(circuit_skipped_message)
     end
 
     # Send event notification to notifier
     def notify_event(event)
-      notifier.notify(service, event)
+      @notifier.notify(@service, event)
     end
 
     # Increment stat store and send notification
     def increment_and_notify_event(event)
-      circuit_store.increment(stat_storage_key(event), 1, expires: (option_value(:time_window) * 2))
+      time_window = option_value(:time_window)
+      aligned_time = align_time_to_window(time_window)
+      @circuit_store.increment(stat_storage_key(event, aligned_time), 1, expires: time_window)
       notify_event(event)
     end
 
+    def stat_storage_key(event, aligned_time = align_time_to_window)
+      "circuits:#{@service}:stats:#{aligned_time}:#{event}"
+    end
+
+    # return time representation in seconds
+    def align_time_to_window(window = option_value(:time_window))
+      time = @time_class.current_second
+      time - (time % window) # remove rest of integer division
+    end
+
     def check_sleep_window
       sleep_window = option_value(:sleep_window)
       time_window  = option_value(:time_window)
@@ -208,27 +261,16 @@ class Circuitbox
 
       warning_message = "sleep_window: #{sleep_window} is shorter than time_window: #{time_window}, "\
                         "the error_rate would not be reset after a sleep."
-      notifier.notify_warning(service, warning_message)
-      warn("Circuit: #{service}, Warning: #{warning_message}")
-    end
-
-    def stat_storage_key(event)
-      "circuits:#{service}:stats:#{align_time_to_window}:#{event}"
+      @notifier.notify_warning(@service, warning_message)
+      warn("Circuit: #{@service}, Warning: #{warning_message}")
     end
 
-    # return time representation in seconds
-    def align_time_to_window
-      time = time_class.now.to_i
-      time_window = option_value(:time_window)
-      time - (time % time_window) # remove rest of integer division
-    end
-
-    def open_storage_key
-      @open_storage_key ||= "circuits:#{service}:open"
-    end
-
-    def half_open_storage_key
-      @half_open_storage_key ||= "circuits:#{service}:half_open"
+    def default_time_klass
+      if @circuit_store.is_a?(Circuitbox::MemoryStore)
+        Circuitbox::TimeHelper::Monotonic
+      else
+        Circuitbox::TimeHelper::Real
+      end
     end
   end
 end

data/lib/circuitbox/configuration.rb

@@ -1,27 +1,48 @@
 # frozen_string_literal: true
 
 require_relative 'memory_store'
-require_relative 'timer'
 require_relative 'notifier/active_support'
 require_relative 'notifier/null'
 
 class Circuitbox
   module Configuration
     attr_writer :default_circuit_store,
-                :default_notifier,
-                :default_timer,
-                :default_logger
+                :default_notifier
 
+    def self.extended(base)
+      base.instance_eval do
+        @cached_circuits_mutex = Mutex.new
+        @cached_circuits = {}
+
+        # preload circuit_store because it has no other dependencies
+        default_circuit_store
+      end
+    end
+
+    # Configure Circuitbox's defaults
+    # After configuring the cached circuits are cleared
+    #
+    # @yieldparam [Circuitbox::Configuration] Circuitbox configuration
+    #
     def configure
       yield self
       clear_cached_circuits!
       nil
     end
 
+    # Circuit store used by circuits that are not configured with a specific circuit store
+    # Defaults to Circuitbox::MemoryStore
+    #
+    # @return [Circuitbox::MemoryStore, Moneta] Circuit store
     def default_circuit_store
       @default_circuit_store ||= MemoryStore.new
     end
 
+    # Notifier used by circuits that are not configured with a specific notifier.
+    # If ActiveSupport::Notifications is defined it defaults to Circuitbox::Notifier::ActiveSupport
+    # Otherwise it defaults to Circuitbox::Notifier::Null
+    #
+    # @return [Circuitbox::Notifier::ActiveSupport, Circuitbox::Notifier::Null] Notifier
     def default_notifier
       @default_notifier ||= if defined?(ActiveSupport::Notifications)
                               Notifier::ActiveSupport.new
@@ -30,22 +51,16 @@ class Circuitbox
                             end
     end
 
-    def default_logger
-      @default_logger ||= if defined?(Rails)
-                            Rails.logger
-                          else
-                            Logger.new($stdout)
-                          end
-    end
-
     private
 
-    def cached_circuits
-      @cached_circuits ||= {}
+    def find_or_create_circuit_breaker(service_name, options)
+      @cached_circuits_mutex.synchronize do
+        @cached_circuits[service_name] ||= CircuitBreaker.new(service_name, options)
+      end
     end
 
     def clear_cached_circuits!
-      @cached_circuits = {}
+      @cached_circuits_mutex.synchronize { @cached_circuits = {} }
     end
   end
 end

data/lib/circuitbox/errors/open_circuit_error.rb

@@ -8,5 +8,9 @@ class Circuitbox
       super()
       @service = service
     end
+
+    def to_s
+      "#{self.class}: Service #{service.inspect} has an open circuit"
+    end
   end
 end

data/lib/circuitbox/errors/service_failure_error.rb

@@ -8,13 +8,13 @@ class Circuitbox
       super()
       @service = service
       @original = exception
-      # we copy over the original exceptions backtrace if there is one
+      # We copy over the original exceptions backtrace if there is one
       backtrace = exception.backtrace
       set_backtrace(backtrace) unless backtrace.empty?
     end
 
     def to_s
-      "#{self.class.name} wrapped: #{original}"
+      "#{self.class}: Service #{service.inspect} was unavailable (original: #{original})"
     end
   end
 end

data/lib/circuitbox/faraday_middleware.rb

@@ -21,7 +21,7 @@ class Circuitbox
       open_circuit: lambda do |response|
         # response.status:
         # nil -> connection could not be established, or failed very hard
-        # 5xx -> non recoverable server error, oposed to 4xx which are client errors
+        # 5xx -> non recoverable server error, opposed to 4xx which are client errors
         response.status.nil? || (response.status >= 500 && response.status <= 599)
       end,
       default_value: ->(service_response, exception) { NullResponse.new(service_response, exception) },
@@ -34,10 +34,7 @@ class Circuitbox
     }.freeze
 
     DEFAULT_EXCEPTIONS = [
-      # Faraday before 0.9.0 didn't have Faraday::TimeoutError so we default to Faraday::Error::TimeoutError
-      # Faraday >= 0.9.0 defines Faraday::TimeoutError and this can be used for all versions up to 1.0.0 that
-      # also define and raise Faraday::Error::TimeoutError as Faraday::TimeoutError is an ancestor
-      defined?(Faraday::TimeoutError) ? Faraday::TimeoutError : Faraday::Error::TimeoutError,
+      Faraday::TimeoutError,
       RequestFailed
     ].freeze
 
@@ -45,8 +42,6 @@ class Circuitbox
       exceptions: DEFAULT_EXCEPTIONS
     }.freeze
 
-    attr_reader :opts
-
     def initialize(app, opts = {})
       @app = app
       @opts = DEFAULT_OPTIONS.merge(opts)
@@ -70,12 +65,12 @@ class Circuitbox
     private
 
     def call_default_value(response, exception)
-      default_value = opts[:default_value]
+      default_value = @opts[:default_value]
       default_value.respond_to?(:call) ? default_value.call(response, exception) : default_value
     end
 
     def open_circuit?(response)
-      opts[:open_circuit].call(response)
+      @opts[:open_circuit].call(response)
     end
 
     def circuit_open_value(env, service_response, exception)
@@ -83,12 +78,12 @@ class Circuitbox
     end
 
     def circuit(env)
-      identifier = opts[:identifier]
+      identifier = @opts[:identifier]
       id = identifier.respond_to?(:call) ? identifier.call(env) : identifier
 
-      Circuitbox.circuit(id, opts[:circuit_breaker_options])
+      Circuitbox.circuit(id, @opts[:circuit_breaker_options])
     end
   end
 end
 
-Faraday::Middleware.register_middleware circuitbox: Circuitbox::FaradayMiddleware
+Faraday::Middleware.register_middleware(circuitbox: Circuitbox::FaradayMiddleware)

data/lib/circuitbox/memory_store/container.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'monotonic_time'
+require_relative '../time_helper/monotonic'
 
 class Circuitbox
   class MemoryStore
     class Container
-      include MonotonicTime
+      include TimeHelper::Monotonic
 
       attr_accessor :value
 

data/lib/circuitbox/memory_store.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'memory_store/monotonic_time'
+require_relative 'time_helper/monotonic'
 require_relative 'memory_store/container'
 
 class Circuitbox
   class MemoryStore
-    include MonotonicTime
+    include TimeHelper::Monotonic
 
     def initialize(compaction_frequency: 60)
       @store = {}
@@ -27,7 +27,7 @@ class Circuitbox
       @mutex.synchronize do
         existing_container = fetch_container(key)
 
-        # reusing the existing container is a small optmization
+        # reusing the existing container is a small optimization
         # to reduce the amount of objects created
         if existing_container
           existing_container.expires_after(seconds_to_expire)
@@ -40,7 +40,14 @@ class Circuitbox
     end
 
     def load(key, _opts = {})
-      @mutex.synchronize { fetch_value(key) }
+      @mutex.synchronize { fetch_container(key)&.value }
+    end
+
+    def values_at(*keys, **_opts)
+      @mutex.synchronize do
+        current_time = current_second
+        keys.map! { |key| fetch_container(key, current_time)&.value }
+      end
     end
 
     def key?(key)
@@ -53,9 +60,7 @@ class Circuitbox
 
     private
 
-    def fetch_container(key)
-      current_time = current_second
-
+    def fetch_container(key, current_time = current_second)
       compact(current_time) if @compact_after < current_time
 
       container = @store[key]
@@ -70,13 +75,6 @@ class Circuitbox
       end
     end
 
-    def fetch_value(key)
-      container = fetch_container(key)
-      return unless container
-
-      container.value
-    end
-
     def compact(current_time)
       @store.delete_if { |_, value| value.expired_at?(current_time) }
       @compact_after = current_time + @compaction_frequency

data/lib/circuitbox/notifier/active_support.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
 class Circuitbox
-  class Notifier
+  module Notifier
     class ActiveSupport
       def notify(circuit_name, event)
-        ::ActiveSupport::Notifications.instrument("circuit_#{event}", circuit: circuit_name)
+        ::ActiveSupport::Notifications.instrument("#{event}.circuitbox", circuit: circuit_name)
       end
 
       def notify_warning(circuit_name, message)
-        ::ActiveSupport::Notifications.instrument('circuit_warning', circuit: circuit_name, message: message)
+        ::ActiveSupport::Notifications.instrument('warning.circuitbox', circuit: circuit_name, message: message)
       end
 
-      def metric_gauge(circuit_name, gauge, value)
-        ::ActiveSupport::Notifications.instrument('circuit_gauge', circuit: circuit_name, gauge: gauge, value: value)
+      def notify_run(circuit_name, &block)
+        ::ActiveSupport::Notifications.instrument('run.circuitbox', circuit: circuit_name, &block)
       end
     end
   end

data/lib/circuitbox/notifier/null.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 class Circuitbox
-  class Notifier
+  module Notifier
     class Null
-      def notify(_, _); end
+      def notify(_circuit_name, _event); end
 
-      def notify_warning(_, _); end
+      def notify_warning(_circuit_name, _message); end
 
-      def metric_gauge(_, _, _); end
+      def notify_run(_circuit_name)
+        yield
+      end
     end
   end
 end

data/lib/circuitbox/{memory_store/monotonic_time.rb → time_helper/monotonic.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 class Circuitbox
-  class MemoryStore
-    module MonotonicTime
+  module TimeHelper
+    module Monotonic
       module_function
 
       def current_second

data/lib/circuitbox/time_helper/real.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Circuitbox
+  module TimeHelper
+    module Real
+      module_function
+
+      def current_second
+        ::Time.now.to_i
+      end
+    end
+  end
+end

data/lib/circuitbox/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Circuitbox
-  VERSION = '2.0.0.pre4'
+  VERSION = '2.0.0'
 end

data/lib/circuitbox.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'logger'
-
 require_relative 'circuitbox/version'
 require_relative 'circuitbox/circuit_breaker'
 require_relative 'circuitbox/errors/error'
@@ -10,15 +8,37 @@ require_relative 'circuitbox/errors/service_failure_error'
 require_relative 'circuitbox/configuration'
 
 class Circuitbox
-  class << self
-    include Configuration
+  extend Configuration
 
+  class << self
+    # @overload circuit(service_name, options = {})
+    #   Returns a Circuitbox::CircuitBreaker for the given service_name
+    #
+    #   @param service_name [String, Symbol] Name of the service
+    #     Mixing Symbols/Strings for the same service (:test/'test') will result in
+    #     multiple circuits being created that point to the same service.
+    #   @param options [Hash] Options for the circuit (See Circuitbox::CircuitBreaker#initialize options)
+    #     Any configuration options should always be passed when calling this method.
+    #   @return [Circuitbox::CircuitBreaker] CircuitBreaker for the given service_name
+    #
+    # @overload circuit(service_name, options = {}, &block)
+    #   Runs the circuit with the given block
+    #   The circuit's run method is called with `exception` set to false
+    #
+    #   @param service_name [String, Symbol] Name of the service
+    #     Mixing Symbols/Strings for the same service (:test/'test') will result in
+    #     multiple circuits being created that point to the same service.
+    #   @param options [Hash] Options for the circuit (See Circuitbox::CircuitBreaker#initialize options)
+    #     Any configuration options should always be passed when calling this method.
+    #
+    #   @return [Object] The result of the block
+    #   @return [nil] If the circuit is open
     def circuit(service_name, options, &block)
-      circuit = (cached_circuits[service_name] ||= CircuitBreaker.new(service_name, options))
+      circuit = find_or_create_circuit_breaker(service_name, options)
 
       return circuit unless block
 
-      circuit.run(circuitbox_exceptions: false, &block)
+      circuit.run(exception: false, &block)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: circuitbox
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre4
+  version: 2.0.0
 platform: ruby
 authors:
 - Fahim Ferdous
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-21 00:00:00.000000000 Z
+date: 2023-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: excon
   requirement: !ruby/object:Gem::Requirement
@@ -45,20 +45,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.17'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.17'
 - !ruby/object:Gem::Dependency
   name: gimme
   requirement: !ruby/object:Gem::Requirement
@@ -79,14 +73,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '5.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '5.14'
 - !ruby/object:Gem::Dependency
   name: minitest-excludes
   requirement: !ruby/object:Gem::Requirement
@@ -107,14 +101,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: moneta
   requirement: !ruby/object:Gem::Requirement
@@ -158,89 +152,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.8.1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 1.8.1
-- !ruby/object:Gem::Dependency
-  name: rubocop-minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.10.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.10.3
-- !ruby/object:Gem::Dependency
-  name: rubocop-performance
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.2
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.9.2
+        version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rake
+  name: typhoeus
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: timecop
+  name: webrick
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
-  name: typhoeus
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 0.9.26
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: 0.9.26
 description: 
 email:
 - fahimfmf@gmail.com
@@ -252,7 +218,6 @@ files:
 - README.md
 - lib/circuitbox.rb
 - lib/circuitbox/circuit_breaker.rb
-- lib/circuitbox/circuit_breaker/logger_messages.rb
 - lib/circuitbox/configuration.rb
 - lib/circuitbox/errors/error.rb
 - lib/circuitbox/errors/open_circuit_error.rb
@@ -261,10 +226,10 @@ files:
 - lib/circuitbox/faraday_middleware.rb
 - lib/circuitbox/memory_store.rb
 - lib/circuitbox/memory_store/container.rb
-- lib/circuitbox/memory_store/monotonic_time.rb
 - lib/circuitbox/notifier/active_support.rb
 - lib/circuitbox/notifier/null.rb
-- lib/circuitbox/timer.rb
+- lib/circuitbox/time_helper/monotonic.rb
+- lib/circuitbox/time_helper/real.rb
 - lib/circuitbox/version.rb
 homepage: https://github.com/yammer/circuitbox
 licenses:
@@ -273,6 +238,7 @@ metadata:
   bug_tracker_uri: https://github.com/yammer/circuitbox/issues
   changelog_uri: https://github.com/yammer/circuitbox/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/yammer/circuitbox
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -281,14 +247,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A robust circuit breaker that manages failing external services.

data/lib/circuitbox/circuit_breaker/logger_messages.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class Circuitbox
-  class CircuitBreaker
-    module LoggerMessages
-      def circuit_skipped_message
-        @circuit_skipped_message ||= "[CIRCUIT] #{service}: skipped"
-      end
-
-      def circuit_running_message
-        @circuit_running_message ||= "[CIRCUIT] #{service}: running"
-      end
-
-      def circuit_success_message
-        @circuit_success_message ||= "[CIRCUIT] #{service}: success"
-      end
-
-      def circuit_failure_message
-        @circuit_failure_message ||= "[CIRCUIT] #{service}: failure"
-      end
-
-      def circuit_opened_message
-        @circuit_opened_message ||= "[CIRCUIT] #{service}: opened"
-      end
-
-      def circuit_closed_message
-        @circuit_closed_message ||= "[CIRCUIT] #{service}: closed"
-      end
-    end
-  end
-end

data/lib/circuitbox/timer.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-class Circuitbox
-  class Timer
-    class Monotonic
-      class << self
-        def supported?
-          defined?(Process::CLOCK_MONOTONIC)
-        end
-
-        def now
-          Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        end
-      end
-    end
-
-    class Default
-      class << self
-        def supported?
-          true
-        end
-
-        def now
-          Time.now.to_f
-        end
-      end
-    end
-
-    class << self
-      def measure(service, notifier, metric_name)
-        before = now
-        result = yield
-        total_time = now - before
-        notifier.metric_gauge(service, metric_name, total_time)
-        result
-      end
-
-      private
-
-      if Monotonic.supported?
-        def now
-          Monotonic.now
-        end
-      else
-        def now
-          Default.now
-        end
-      end
-    end
-  end
-end