circuitbox 1.1.1 → 2.0.0.pre4

data/lib/circuitbox/circuit_breaker.rb

@@ -1,15 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'circuit_breaker/logger_messages'
+
 class Circuitbox
   class CircuitBreaker
-    attr_accessor :service, :circuit_options, :exceptions, :partition,
-                  :logger, :circuit_store, :notifier
+    include LoggerMessages
+
+    attr_reader :service, :circuit_options, :exceptions,
+                :logger, :circuit_store, :notifier, :time_class
 
     DEFAULTS = {
-      sleep_window:     300,
+      sleep_window: 90,
       volume_threshold: 5,
-      error_threshold:  50,
-      timeout_seconds:  1,
-      time_window:      60,
-    }
+      error_threshold: 50,
+      time_window: 60
+    }.freeze
 
     #
     # Configuration options
@@ -17,238 +22,213 @@ class Circuitbox
     # `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
-    # `timeout_seconds`   - seconds until it will timeout the request
-    # `exceptions`        - exceptions other than Timeout::Error that count as failures
+    # `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
     #
     def initialize(service, options = {})
-      @service = service
-      @circuit_options = options
-      @circuit_store   = options.fetch(:cache) { Circuitbox.circuit_store }
-      @notifier        = options.fetch(:notifier_class) { Notifier }
+      @service = service.to_s
+      @circuit_options = DEFAULTS.merge(options)
+      @circuit_store   = options.fetch(:cache) { Circuitbox.default_circuit_store }
+      @notifier = options.fetch(:notifier) { Circuitbox.default_notifier }
+
+      if @circuit_options[:timeout_seconds]
+        warn('timeout_seconds was removed in circuitbox 2.0. '\
+             'Check the upgrade guide at https://github.com/yammer/circuitbox')
+      end
 
-      @exceptions = options.fetch(:exceptions) { [] }
-      @exceptions = [Timeout::Error] if @exceptions.blank?
+      @exceptions = options.fetch(:exceptions)
+      raise ArgumentError.new('exceptions need to be an array') unless @exceptions.is_a?(Array)
 
-      @logger     = options.fetch(:logger) { defined?(Rails) ? Rails.logger : Logger.new(STDOUT) }
-      @time_class   = options.fetch(:time_class) { Time }
-      sanitize_options
+      @logger     = options.fetch(:logger) { Circuitbox.default_logger }
+      @time_class = options.fetch(:time_class) { Time }
+      @state_change_mutex = Mutex.new
+      check_sleep_window
     end
 
     def option_value(name)
-      value = circuit_options.fetch(name) { DEFAULTS.fetch(name) }
+      value = circuit_options[name]
       value.is_a?(Proc) ? value.call : value
     end
 
-    def run!(run_options = {})
-      @partition = run_options.delete(:partition) # sorry for this hack.
-
+    def run(circuitbox_exceptions: true, &block)
       if open?
-        logger.debug "[CIRCUIT] open: skipping #{service}"
-        open! unless open_flag?
         skipped!
-        raise Circuitbox::OpenCircuitError.new(service)
+        raise Circuitbox::OpenCircuitError.new(service) if circuitbox_exceptions
       else
-        close! if was_open?
-        logger.debug "[CIRCUIT] closed: querying #{service}"
+        logger.debug(circuit_running_message)
 
         begin
-          response = if exceptions.include? Timeout::Error
-            timeout_seconds = run_options.fetch(:timeout_seconds) { option_value(:timeout_seconds) }
-            timeout (timeout_seconds) { yield }
-          else
-            yield
-          end
-
-          logger.debug "[CIRCUIT] closed: #{service} querie success"
+          response = Timer.measure(service, notifier, 'runtime', &block)
+
           success!
-        rescue *exceptions => exception
-          logger.debug "[CIRCUIT] closed: detected #{service} failure"
+        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.
+          response = nil
           failure!
-          open! if half_open?
-          raise Circuitbox::ServiceFailureError.new(service, exception)
+          raise Circuitbox::ServiceFailureError.new(service, e) if circuitbox_exceptions
         end
       end
 
-      return response
-    end
-
-    def run(run_options = {})
-      begin
-        run!(run_options, &Proc.new)
-      rescue Circuitbox::Error
-        nil
-      end
+      response
     end
 
     def open?
-      if open_flag?
-        true
-      elsif passed_volume_threshold? && passed_rate_threshold?
-        true
-      else
-        false
-      end
+      circuit_store.key?(open_storage_key)
     end
 
     def error_rate(failures = failure_count, success = success_count)
       all_count = failures + success
-      return 0.0 unless all_count > 0
-      failure_count.to_f / all_count.to_f * 100
+      return 0.0 unless all_count.positive?
+
+      (failures / all_count.to_f) * 100
     end
 
     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
 
     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
 
     def try_close_next_time
-      circuit_store.delete(storage_key(:asleep))
+      circuit_store.delete(open_storage_key)
     end
 
-  private
-    def open!
-      log_event :open
-      logger.debug "[CIRCUIT] opening #{service} circuit"
-      circuit_store.store(storage_key(:asleep), true, expires: option_value(:sleep_window))
-      half_open!
-      was_open!
-    end
+    private
 
-    ### BEGIN - all this is just here to produce a close notification
-    def close!
-      log_event :close
-      circuit_store.delete(storage_key(:was_open))
+    def should_open?
+      failures = failure_count
+      successes = success_count
+      rate = error_rate(failures, successes)
+
+      passed_volume_threshold?(failures, successes) && passed_rate_threshold?(rate)
     end
 
-    def was_open!
-      circuit_store.store(storage_key(:was_open), true)
+    def passed_volume_threshold?(failures, successes)
+      failures + successes >= option_value(:volume_threshold)
     end
 
-    def was_open?
-      circuit_store[storage_key(:was_open)].present?
+    def passed_rate_threshold?(rate)
+      rate >= option_value(:error_threshold)
     end
-    ### END
 
-    def half_open!
-      circuit_store.store(storage_key(:half_open), true)
+    def half_open_failure
+      @state_change_mutex.synchronize do
+        return if open? || !half_open?
+
+        trip
+      end
+
+      # Running event and logger outside of the synchronize block to allow other threads
+      # that may be waiting to become unblocked
+      notify_opened
     end
 
-    def open_flag?
-      circuit_store[storage_key(:asleep)].present?
+    def open!
+      @state_change_mutex.synchronize do
+        return if open?
+
+        trip
+      end
+
+      # Running event and logger outside of the synchronize block to allow other threads
+      # that may be waiting to become unblocked
+      notify_opened
     end
 
-    def half_open?
-      circuit_store[storage_key(:half_open)].present?
+    def notify_opened
+      notify_event('open')
+      logger.debug(circuit_opened_message)
     end
 
-    def passed_volume_threshold?
-      success_count + failure_count > option_value(:volume_threshold)
+    def trip
+      circuit_store.store(open_storage_key, true, expires: option_value(:sleep_window))
+      circuit_store.store(half_open_storage_key, true)
     end
 
-    def passed_rate_threshold?
-      read_and_log_error_rate >= option_value(:error_threshold)
+    def close!
+      @state_change_mutex.synchronize do
+        # 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)
+      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 read_and_log_error_rate
-      failures = failure_count
-      success  = success_count
-      rate = error_rate(failures, success)
-      log_metrics(rate, failures, success)
-      rate
+    def half_open?
+      circuit_store.key?(half_open_storage_key)
     end
 
     def success!
-      log_event :success
-      circuit_store.delete(storage_key(:half_open))
+      increment_and_notify_event('success')
+      logger.debug(circuit_success_message)
+
+      close! if half_open?
     end
 
     def failure!
-      log_event :failure
+      increment_and_notify_event('failure')
+      logger.debug(circuit_failure_message)
+
+      if half_open?
+        half_open_failure
+      elsif should_open?
+        open!
+      end
     end
 
     def skipped!
-      log_event :skipped
+      notify_event('skipped')
+      logger.debug(circuit_skipped_message)
     end
 
-    # Store success/failure/open/close data in memcache
-    def log_event(event)
-      notifier.new(service,partition).notify(event)
-      log_event_to_process(event)
+    # Send event notification to notifier
+    def notify_event(event)
+      notifier.notify(service, event)
     end
 
-    def log_metrics(error_rate, failures, successes)
-      n = notifier.new(service,partition)
-      n.metric_gauge(:error_rate, error_rate)
-      n.metric_gauge(:failure_count, failures)
-      n.metric_gauge(:success_count, successes)
+    # 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))
+      notify_event(event)
     end
 
-    def sanitize_options
+    def check_sleep_window
       sleep_window = option_value(:sleep_window)
       time_window  = option_value(:time_window)
-      if sleep_window < time_window
-        notifier.new(service,partition).notify_warning("sleep_window:#{sleep_window} is shorter than time_window:#{time_window}, the error_rate could not be reset properly after a sleep. sleep_window as been set to equal time_window.")
-        @circuit_options[:sleep_window] = option_value(:time_window)
-      end
-    end
-
-    # When there is a successful response within a count interval, clear the failures.
-    def clear_failures!
-      circuit_store.store(stat_storage_key(:failure), 0, raw: true)
-    end
+      return unless sleep_window < time_window
 
-    # Logs to process memory.
-    def log_event_to_process(event)
-      key = stat_storage_key(event)
-      if circuit_store.load(key, raw: true)
-        circuit_store.increment(key)
-      else
-        # yes we want a string here, as the underlying stores impement this as a native type.
-        circuit_store.store(key, "1", raw: true)
-      end
-    end
-
-    # For returning stale responses when the circuit is open
-    def response_key(args)
-      Digest::SHA1.hexdigest(storage_key(:cache, args.inspect.to_s))
+      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, options = {})
-      storage_key(:stats, align_time_on_minute, event, options)
+    def stat_storage_key(event)
+      "circuits:#{service}:stats:#{align_time_to_window}:#{event}"
     end
 
-
     # return time representation in seconds
-    def align_time_on_minute(time=nil)
-      time      ||= @time_class.now.to_i
+    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 storage_key(*args)
-      options = args.extract_options!
-
-      key = if options[:without_partition]
-        "circuits:#{service}:#{args.join(":")}"
-      else
-        "circuits:#{service}:#{partition}:#{args.join(":")}"
-      end
-
-      return key
+      time - (time % time_window) # remove rest of integer division
     end
 
-    def timeout(timeout_seconds, &block)
-      Timeout::timeout(timeout_seconds) { block.call }
+    def open_storage_key
+      @open_storage_key ||= "circuits:#{service}:open"
     end
 
-    def self.reset
-      Circuitbox.reset
+    def half_open_storage_key
+      @half_open_storage_key ||= "circuits:#{service}:half_open"
     end
-
   end
 end

data/lib/circuitbox/configuration.rb

@@ -0,0 +1,51 @@
+# 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
+
+    def configure
+      yield self
+      clear_cached_circuits!
+      nil
+    end
+
+    def default_circuit_store
+      @default_circuit_store ||= MemoryStore.new
+    end
+
+    def default_notifier
+      @default_notifier ||= if defined?(ActiveSupport::Notifications)
+                              Notifier::ActiveSupport.new
+                            else
+                              Notifier::Null.new
+                            end
+    end
+
+    def default_logger
+      @default_logger ||= if defined?(Rails)
+                            Rails.logger
+                          else
+                            Logger.new($stdout)
+                          end
+    end
+
+    private
+
+    def cached_circuits
+      @cached_circuits ||= {}
+    end
+
+    def clear_cached_circuits!
+      @cached_circuits = {}
+    end
+  end
+end

data/lib/circuitbox/errors/error.rb

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

data/lib/circuitbox/errors/open_circuit_error.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 class Circuitbox
   class OpenCircuitError < Circuitbox::Error
     attr_reader :service
 
     def initialize(service)
+      super()
       @service = service
     end
-
   end
 end

data/lib/circuitbox/errors/service_failure_error.rb

@@ -1,12 +1,16 @@
+# 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
-      set_backtrace(exception.backtrace) unless exception.backtrace.empty?
+      backtrace = exception.backtrace
+      set_backtrace(backtrace) unless backtrace.empty?
     end
 
     def to_s

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,36 +28,36 @@ 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
 
     def error_call(datum)
-      circuit(datum).run!(run_options(datum)) do
+      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)
-      circuit(datum).run!(run_options(datum)) do
+      circuit(datum).run do
         @stack.request_call(datum)
       end
     end
 
     def response_call(datum)
-      circuit(datum).run!(run_options(datum)) do
+      circuit(datum).run do
         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
-      @identifier ||= opts.fetch(:identifier, ->(env) { env[:path] })
+      @identifier ||= opts.fetch(:identifier, ->(env) { env[:host] })
     end
 
     def exceptions
@@ -69,10 +71,6 @@ class Circuitbox
       circuitbox.circuit id, circuit_breaker_options
     end
 
-    def run_options(datum)
-      opts.merge(datum)[:circuit_breaker_run_options] || {}
-    end
-
     def open_circuit?(response)
       opts[:open_circuit].call(response)
     end
@@ -86,26 +84,21 @@ class Circuitbox
     end
 
     def circuit_breaker_options
-      return @circuit_breaker_options if @circuit_breaker_options
-
-      @circuit_breaker_options = opts.fetch(:circuit_breaker_options, {})
-      @circuit_breaker_options.merge!(
-        exceptions: opts.fetch(:exceptions, DEFAULT_EXCEPTIONS)
-      )
+      @circuit_breaker_options ||= begin
+        options = opts.fetch(:circuit_breaker_options, {})
+        options.merge!(
+          exceptions: opts.fetch(:exceptions, DEFAULT_EXCEPTIONS)
+        )
+      end
     end
 
     def default_value
-      return @default_value if @default_value
-
-      default = opts.fetch(:default_value) do
-        lambda { |response, exception| NullResponse.new(response, exception) }
+      @default_value ||= begin
+        default = opts.fetch(:default_value) do
+          ->(response, exception) { NullResponse.new(response, exception) }
+        end
+        default.respond_to?(:call) ? default : ->(*) { default }
       end
-
-      @default_value = if default.respond_to?(:call)
-                         default
-                       else
-                         lambda { |*| default }
-                       end
     end
   end
 end