circuitbox 2.0.0.pre3 → 2.0.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 91bcf88d24630e489540fd2c149ce6b468ecdd7e
-  data.tar.gz: 8576e094971fb74bb390b2a1508fd6c330644915
+SHA256:
+  metadata.gz: 541c5e674d62681f13021254d4304c4903e2812915c59b74fcb419468f608c9d
+  data.tar.gz: 97fdbeedc5ac6aa8aa249ca92a1202175e8bbd3f777c4c5211583130aecf5b0d
 SHA512:
-  metadata.gz: 7e2246d5b01dddaa5fb1e3637f5f66a1bb1a9ffcbf20d8bec5d28d787328f748b7dc1818a72662ede92aab94eae32f1608eacc42697cd0fbe72f5ef16f7c42c9
-  data.tar.gz: 9b2022385d22e3e6fc31a1be8028fa047a49fb59f09779c77bdae53712ab8cda482513f6dd7909a1ee3b04ca4a6fdcb1d9a110cc57febb1b5e712b19f284b4a0
+  metadata.gz: 2466098850251fab23dd6be74a292150ba8eda1e27c3ef1fefcc79aab36dedc170daf4292ae3e9d20ea49468bb487855ce4d3bd77aa7ef1ec8b3ba18bd52d1c6
+  data.tar.gz: a62d7c7a283ce4adcec0c73b69db7de8ca982f493369a7ac6534bfc9641de2bc909b8294bb634913b64c1f454861488595e0f103672fa6cc448c7f6beaa8c170

data/README.md

@@ -1,6 +1,6 @@
 # Circuitbox
 
-[![Build Status](https://travis-ci.org/yammer/circuitbox.svg?branch=master)](https://travis-ci.org/yammer/circuitbox) [![Gem Version](https://badge.fury.io/rb/circuitbox.svg)](https://badge.fury.io/rb/circuitbox)
+![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.
 Resources about the circuit breaker pattern:
@@ -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, timer, 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,8 +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_timer = Circuitbox::Timer::Simple.new
-    config.default_logger = Rails.logger
   end
 ```
 
@@ -82,21 +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 Timer object
-      # Use NullTimer if you don't want to time circuit execution
-      # Use MonotonicTimer to avoid bad time metrics on system time resync
-      # This overrides what is set in the global configuration
-      execution_timer: SimpleTimer,
-
       # Customized notifier
       # overrides the default
       # this overrides what is set in the global configuration
@@ -115,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
@@ -132,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:
-
-- `execution_time` # execution time 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'
@@ -241,71 +228,6 @@ c.use Circuitbox::FaradayMiddleware, circuit_breaker_options: {}
 c.use Circuitbox::FaradayMiddleware, open_circuit: lambda { |response| response.status >= 500 }
 ```
 
-## CHANGELOG
-### v1.1.0
-- ruby 2.2 support [#58](https://github.com/yammer/circuitbox/pull/58)
-- configurable logger [#58](https://github.com/yammer/circuitbox/pull/58)
-
-### v1.0.3
-- fix timeout issue for default configuration, as default `:Memory` adapter does
-  not natively support expires, we need to actually load it on demand.
-- fix memoization of `circuit_breaker_options` not actually doing memoization in
-  `excon` and `faraday` middleware.
-
-### v1.0.2
-- Fix timeout issue [#51](https://github.com/yammer/circuitbox/issues/51)
-  [sebastian-juliu](https://github.com/sebastian-julius)
-
-### v1.0.1
-- Fix Rails integration, as version 1.0.0 removed the rails tasks integration, but missed
-  removing the related railtie.
-
-### v1.0.0
-- support for cross process circuitbreakers by swapping the circuitbreaker store for a
-  `Moneta` supported key value store.
-- Change `FaradayMiddleware` default behaviour to not open on `4xx` errors but just on `5xx`
-  server errors and connection errors
-- Remove stat store, which was largely unused
-
-### v0.11.0
-- fix URI require missing (https://github.com/yammer/circuitbox/pull/42 @gottfrois)
-- configurable circuitbox store backend via Moneta supporting multi process circuits
-
-### v0.10.4
-- Issue #39, keep the original backtrace for the wrapped exception around when
-  re-raising a Circuitbox::Error
-
-### v0.10.3
-- Circuitbox::ServiceFailureError wraps the original exception that was raised.
-  The behaviour for to_s wasn't exposing this information and was returning the
-  name of class "Circuitbox::ServiceFailureError". Change the behaviour for to_s
-  to indicate this exception is a wrapper around the original exception.
-  [sherrry](https://github.com/sherrry)
-
-### v0.10.2
-- Faraday middleware passes two arguments to the `default_value` callback, not
-  just one.  First argument is still the error response from Faraday if there is
-  one.  Second argument is the exception that caused the call to fail if it
-  failed before Faraday returned a response.  Old behaviour is preserved if you
-  pass a lambda that takes just one argument, but this is deprecated and will be
-  removed in the next version of Circuitbox.
-  [dwaller](https://github.com/dwaller)
-
-### v0.10.1
-- [Documentation fix](https://github.com/yammer/circuitbox/pull/29) [chiefcll](https://github.com/chiefcll)
-- [Faraday middleware fix](https://github.com/yammer/circuitbox/pull/30) [chiefcll](https://github.com/chiefcll)
-
-### v0.10
-- configuration option for faraday middleware for what should be considered to open the circuit [enrico-scalavio](https://github.com/enrico-scalavino)
-- fix for issue 16, support of in_parallel requests in faraday middleware which were opening the circuit.
-- deprecate the __run_option__ `:storage_key`
-
-### v0.9
-- add `run!` method to raise exception on circuit open and service
-
-### v0.8
-- Everything prior to keeping the change log
-
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/circuitbox/circuit_breaker.rb

@@ -1,36 +1,37 @@
 # 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, :execution_timer
+                :circuit_store, :notifier, :time_class
 
     DEFAULTS = {
-      sleep_window:     90,
+      sleep_window: 90,
       volume_threshold: 5,
-      error_threshold:  50,
-      time_window:      60
+      error_threshold: 50,
+      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 }
-      @execution_timer = options.fetch(:execution_timer) { Circuitbox.default_timer }
+      @circuit_store   = options.fetch(:circuit_store) { Circuitbox.default_circuit_store }
       @notifier = options.fetch(:notifier) { Circuitbox.default_notifier }
 
       if @circuit_options[:timeout_seconds]
@@ -38,83 +39,126 @@ 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, '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)
+    # 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 = execution_timer.time(service, notifier, 'execution_time') do
-            yield
-          end
+          response = @notifier.notify_run(@service, &block)
 
           success!
-        rescue *exceptions => exception
+        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, exception) 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 > 0
+      return 0.0 unless all_count.positive?
+
       (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
+    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
@@ -124,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
@@ -136,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!
@@ -156,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
@@ -189,48 +229,48 @@ 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 check_sleep_window
-      sleep_window = option_value(:sleep_window)
-      time_window  = option_value(:time_window)
-      if sleep_window < time_window
-        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
-    end
-
-    def stat_storage_key(event)
-      "circuits:#{service}:stats:#{align_time_to_window}:#{event}"
+    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
-      time = time_class.now.to_i
-      time_window = option_value(:time_window)
-      time - (time % time_window) # remove rest of integer division
+    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 open_storage_key
-      @open_storage_key ||= "circuits:#{service}:open"
+    def check_sleep_window
+      sleep_window = option_value(:sleep_window)
+      time_window  = option_value(:time_window)
+      return unless sleep_window < time_window
+
+      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 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/monotonic'
-require_relative 'timer/null'
-require_relative 'timer/simple'
 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,26 +37,16 @@ class Circuitbox
                             end
     end
 
-    def default_timer
-      @default_timer ||= Timer::Simple.new
-    end
-
-    def default_logger
-      @default_logger ||= if defined?(Rails)
-                            Rails.logger
-                          else
-                            Logger.new(STDOUT)
-                          end
-    end
-
-  private
+    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/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Circuitbox
   class Error < StandardError; end
 end

data/lib/circuitbox/errors/open_circuit_error.rb

@@ -1,9 +1,16 @@
+# frozen_string_literal: true
+
 class Circuitbox
   class OpenCircuitError < Circuitbox::Error
     attr_reader :service
 
     def initialize(service)
+      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

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 class Circuitbox
   class ServiceFailureError < Circuitbox::Error
     attr_reader :service, :original
 
     def initialize(service, exception)
+      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/excon_middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'excon'
 require 'circuitbox'
 
@@ -8,7 +10,7 @@ class Circuitbox
     DEFAULT_EXCEPTIONS = [
       Excon::Errors::Timeout,
       RequestFailed
-    ]
+    ].freeze
 
     class NullResponse < Excon::Response
       def initialize(response, exception)
@@ -26,7 +28,7 @@ class Circuitbox
 
     def initialize(stack, opts = {})
       @stack = stack
-      default_options = { open_circuit: lambda { |response| response[:status] >= 400 } }
+      default_options = { open_circuit: ->(response) { response[:status] >= 400 } }
       @opts = default_options.merge(opts)
       super(stack)
     end
@@ -35,8 +37,8 @@ class Circuitbox
       circuit(datum).run do
         raise RequestFailed
       end
-    rescue Circuitbox::Error => exception
-      circuit_open_value(datum, datum[:response], exception)
+    rescue Circuitbox::Error => e
+      circuit_open_value(datum, datum[:response], e)
     end
 
     def request_call(datum)
@@ -50,8 +52,8 @@ class Circuitbox
         raise RequestFailed if open_circuit?(datum[:response])
       end
       @stack.response_call(datum)
-    rescue Circuitbox::Error => exception
-      circuit_open_value(datum, datum[:response], exception)
+    rescue Circuitbox::Error => e
+      circuit_open_value(datum, datum[:response], e)
     end
 
     def identifier
@@ -93,9 +95,9 @@ class Circuitbox
     def default_value
       @default_value ||= begin
         default = opts.fetch(:default_value) do
-          lambda { |response, exception| NullResponse.new(response, exception) }
+          ->(response, exception) { NullResponse.new(response, exception) }
         end
-        default.respond_to?(:call) ? default : lambda { |*| default }
+        default.respond_to?(:call) ? default : ->(*) { default }
       end
     end
   end

data/lib/circuitbox/faraday_middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'circuitbox'
 
@@ -7,6 +9,7 @@ class Circuitbox
 
     class NullResponse < Faraday::Response
       attr_reader :original_response, :original_exception
+
       def initialize(response = nil, exception = nil)
         @original_response  = response
         @original_exception = exception
@@ -18,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) },
@@ -31,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
 
@@ -42,8 +42,6 @@ class Circuitbox
       exceptions: DEFAULT_EXCEPTIONS
     }.freeze
 
-    attr_reader :opts
-
     def initialize(app, opts = {})
       @app = app
       @opts = DEFAULT_OPTIONS.merge(opts)
@@ -60,19 +58,19 @@ class Circuitbox
           raise RequestFailed if open_circuit?(service_response)
         end
       end
-    rescue Circuitbox::Error => ex
-      circuit_open_value(request_env, service_response, ex)
+    rescue Circuitbox::Error => e
+      circuit_open_value(request_env, service_response, e)
     end
 
     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)
@@ -80,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,9 +1,11 @@
-require_relative 'monotonic_time'
+# frozen_string_literal: true
+
+require_relative '../time_helper/monotonic'
 
 class Circuitbox
   class MemoryStore
     class Container
-      include MonotonicTime
+      include TimeHelper::Monotonic
 
       attr_accessor :value
 
@@ -13,11 +15,11 @@ class Circuitbox
       end
 
       def expired?
-        @expires_after > 0 && @expires_after < current_second
+        @expires_after.positive? && @expires_after < current_second
       end
 
       def expired_at?(clock_second)
-        @expires_after > 0 && @expires_after < clock_second
+        @expires_after.positive? && @expires_after < clock_second
       end
 
       def expires_after(seconds = 0)

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)
@@ -51,11 +58,9 @@ class Circuitbox
       @mutex.synchronize { @store.delete(key) }
     end
 
-  private
-
-    def fetch_container(key)
-      current_time = current_second
+    private
 
+    def fetch_container(key, current_time = current_second)
       compact(current_time) if @compact_after < current_time
 
       container = @store[key]
@@ -70,12 +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,11 +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,6 +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,3 +1,5 @@
+# frozen_string_literal: true
+
 class Circuitbox
-  VERSION = '2.0.0.pre3'.freeze
+  VERSION = '2.0.0.pre5'
 end

data/lib/circuitbox.rb

@@ -1,5 +1,4 @@
-require 'uri'
-require 'logger'
+# frozen_string_literal: true
 
 require_relative 'circuitbox/version'
 require_relative 'circuitbox/circuit_breaker'
@@ -9,15 +8,15 @@ require_relative 'circuitbox/errors/service_failure_error'
 require_relative 'circuitbox/configuration'
 
 class Circuitbox
-  class << self
-    include Configuration
+  extend Configuration
 
-    def circuit(service_name, options)
-      circuit = (cached_circuits[service_name] ||= CircuitBreaker.new(service_name, options))
+  class << self
+    def circuit(service_name, options, &block)
+      circuit = find_or_create_circuit_breaker(service_name, options)
 
-      return circuit unless block_given?
+      return circuit unless block
 
-      circuit.run(circuitbox_exceptions: false) { yield }
+      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.pre3
+  version: 2.0.0.pre5
 platform: ruby
 authors:
 - Fahim Ferdous
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-28 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.15'
-    - - "<"
-      - !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.15'
-    - - "<"
-      - !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,28 @@ 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
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -163,28 +171,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
-  name: moneta
+  name: webrick
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.26
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.26
 description: 
 email:
 - fahimfmf@gmail.com
@@ -196,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
@@ -205,17 +226,19 @@ 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/monotonic.rb
-- lib/circuitbox/timer/null.rb
-- lib/circuitbox/timer/simple.rb
+- lib/circuitbox/time_helper/monotonic.rb
+- lib/circuitbox/time_helper/real.rb
 - lib/circuitbox/version.rb
 homepage: https://github.com/yammer/circuitbox
 licenses:
 - Apache-2.0
-metadata: {}
+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:
@@ -224,15 +247,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+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/monotonic.rb

@@ -1,17 +0,0 @@
-class Circuitbox
-  class Timer
-    class Monotonic
-      def initialize(time_unit = :millisecond)
-        @time_unit = time_unit
-      end
-
-      def time(service, notifier, metric_name)
-        before = Process.clock_gettime(Process::CLOCK_MONOTONIC, @time_unit)
-        result = yield
-        total_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, @time_unit) - before
-        notifier.metric_gauge(service, metric_name, total_time)
-        result
-      end
-    end
-  end
-end

data/lib/circuitbox/timer/null.rb

@@ -1,9 +0,0 @@
-class Circuitbox
-  class Timer
-    class Null
-      def time(_service, _notifier, _metric_name)
-        yield
-      end
-    end
-  end
-end

data/lib/circuitbox/timer/simple.rb

@@ -1,13 +0,0 @@
-class Circuitbox
-  class Timer
-    class Simple
-      def time(service, notifier, metric_name)
-        before = Time.now.to_f
-        result = yield
-        total_time = Time.now.to_f - before
-        notifier.metric_gauge(service, metric_name, total_time)
-        result
-      end
-    end
-  end
-end