circuitbox 2.0.0.pre4 → 2.0.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb89d6ef46d73dfa35e7c43181112309aa524979ec1285688cc8cebf8d781bd4
-  data.tar.gz: 735c23115ea5127923c05b84d5b6cfe64193521bcd751639cc6ceab32c6b97ce
+  metadata.gz: 541c5e674d62681f13021254d4304c4903e2812915c59b74fcb419468f608c9d
+  data.tar.gz: 97fdbeedc5ac6aa8aa249ca92a1202175e8bbd3f777c4c5211583130aecf5b0d
 SHA512:
-  metadata.gz: a29d10725e8a1a36eec12985681cd66b7c2b3303cb996bfe72226674230d7c8ef38b02bb5731665edd49c7922b2a9f0072434a2ab33da7f64713875415071420
-  data.tar.gz: 9a165096e2b0e5fe484c433284a3c0b6658f4b880552602cb57b22fcf3ea540302b3d3a0910b31b8f3e1938259ca6394faefd3bffffc6c40bf3104d8d02564ec
+  metadata.gz: 2466098850251fab23dd6be74a292150ba8eda1e27c3ef1fefcc79aab36dedc170daf4292ae3e9d20ea49468bb487855ce4d3bd77aa7ef1ec8b3ba18bd52d1c6
+  data.tar.gz: a62d7c7a283ce4adcec0c73b69db7de8ca982f493369a7ac6534bfc9641de2bc909b8294bb634913b64c1f454861488595e0f103672fa6cc448c7f6beaa8c170

data/README.md

@@ -25,7 +25,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,7 +43,7 @@ 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.
+Circuitbox has defaults for circuit_store and notifier.
 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.
@@ -55,7 +55,6 @@ will need to be recreated to pick up the new defaults.
   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,15 +80,11 @@ 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
@@ -108,7 +103,7 @@ 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
@@ -125,60 +120,59 @@ some pre-requisits need to be satisfied first:
 
 ## Notifications
 
-circuitbox use ActiveSupport Notifications.
+Circuitbox has two built in notifiers, null and active support.
+The active support notifier is used if `ActiveSupport::Notifications` is defined when circuitbox is loaded.
+If `ActiveSupport::Notifications` is not defined the null notifier is used.
+The null notifier does not send notifications anywhere.
+
+The default notifier can be changed to use a specific built in notifier or a custom notifier when [configuring circuitbox](#global-configuration).
 
+### ActiveSupport
 Usage example:
 
-**Log on circuit open/close:**
+**Circuit open/close:**
 
 ```ruby
-class CircuitOpenException    < StandardError ; end
-
-ActiveSupport::Notifications.subscribe('circuit_open') do |name, start, finish, id, payload|
+ActiveSupport::Notifications.subscribe('open.circuitbox') 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|
+ActiveSupport::Notifications.subscribe('close.circuitbox') do |_name, _start, _finish, _id, payload|
   circuit_name = payload[:circuit]
   Rails.logger.info("Close circuit for: #{circuit_name}")
 end
 ```
 
-**generate metrics:**
+**Circuit run:**
 
 ```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)
+ActiveSupport::Notifications.subscribe('run.circuitbox') do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  circuit_name = event.payload[:circuit_name]
+  
+  Rails.logger.info("Circuit: #{circuit_name} Runtime: #{event.duration}")
 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
+**Circuit Warnings:**
+In case of misconfiguration, circuitbox will fire a `warning.circuitbox`
 notification.
 
 ```ruby
-ActiveSupport::Notifications.subscribe('circuit_warning') do |name, start, finish, id, payload|
+ActiveSupport::Notifications.subscribe('warning.circuitbox') do |_name, _start, _finish, _id, payload|
   circuit_name = payload[:circuit]
   warning      = payload[:message]
-  Rails.logger.warning("#{circuit_name} - #{warning}")
+  Rails.logger.warning("Circuit warning for: #{circuit_name} Message: #{warning}")
 end
 
 ```
 
 ## 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,16 +1,23 @@
 # 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
 
     def configure
       yield self
@@ -30,22 +37,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.pre5'
 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,15 @@ require_relative 'circuitbox/errors/service_failure_error'
 require_relative 'circuitbox/configuration'
 
 class Circuitbox
-  class << self
-    include Configuration
+  extend Configuration
 
+  class << self
     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.pre5
 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-04-06 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
 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