circuitbox 1.0.3 → 2.0.0.pre3

data/lib/circuitbox/circuit_breaker/logger_messages.rb

@@ -0,0 +1,31 @@
+# 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/configuration.rb

@@ -0,0 +1,55 @@
+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
+
+    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_timer
+      @default_timer ||= Timer::Simple.new
+    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,3 @@
 class Circuitbox
-  class Error < StandardError
-  end
+  class Error < StandardError; end
 end

data/lib/circuitbox/errors/open_circuit_error.rb

@@ -5,6 +5,5 @@ class Circuitbox
     def initialize(service)
       @service = service
     end
-
   end
 end

data/lib/circuitbox/errors/service_failure_error.rb

@@ -6,7 +6,8 @@ class Circuitbox
       @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

@@ -32,7 +32,7 @@ class Circuitbox
     end
 
     def error_call(datum)
-      circuit(datum).run!(run_options(datum)) do
+      circuit(datum).run do
         raise RequestFailed
       end
     rescue Circuitbox::Error => exception
@@ -40,13 +40,13 @@ class Circuitbox
     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)
@@ -55,7 +55,7 @@ class Circuitbox
     end
 
     def identifier
-      @identifier ||= opts.fetch(:identifier, ->(env) { env[:path] })
+      @identifier ||= opts.fetch(:identifier, ->(env) { env[:host] })
     end
 
     def exceptions
@@ -69,10 +69,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 +82,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
+          lambda { |response, exception| NullResponse.new(response, exception) }
+        end
+        default.respond_to?(:call) ? default : lambda { |*| default }
       end
-
-      @default_value = if default.respond_to?(:call)
-                         default
-                       else
-                         lambda { |*| default }
-                       end
     end
   end
 end

data/lib/circuitbox/faraday_middleware.rb

@@ -5,11 +5,6 @@ class Circuitbox
   class FaradayMiddleware < Faraday::Middleware
     class RequestFailed < StandardError; end
 
-    DEFAULT_EXCEPTIONS = [
-      Faraday::Error::TimeoutError,
-      RequestFailed,
-    ]
-
     class NullResponse < Faraday::Response
       attr_reader :original_response, :original_exception
       def initialize(response = nil, exception = nil)
@@ -19,26 +14,47 @@ class Circuitbox
       end
     end
 
-    attr_reader :opts
-
-    DEFAULT_CIRCUITBOX_OPTIONS = {
+    DEFAULT_OPTIONS = {
       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
-        response.status.nil? || (500 <= response.status && response.status <= 599)
-      end
-    }
+        response.status.nil? || (response.status >= 500 && response.status <= 599)
+      end,
+      default_value: ->(service_response, exception) { NullResponse.new(service_response, exception) },
+      # It's possible for the URL object to not have a host at the time the middleware
+      # is run. To not break circuitbox by creating a circuit with a nil service name
+      # we can get the string representation of the URL object and use that as the service name.
+      identifier: ->(env) { env[:url].host || env[:url].to_s },
+      # default circuit breaker options are merged in during initialization
+      circuit_breaker_options: {}
+    }.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,
+      RequestFailed
+    ].freeze
+
+    DEFAULT_CIRCUIT_BREAKER_OPTIONS = {
+      exceptions: DEFAULT_EXCEPTIONS
+    }.freeze
+
+    attr_reader :opts
 
     def initialize(app, opts = {})
       @app = app
-      @opts = DEFAULT_CIRCUITBOX_OPTIONS.merge(opts)
+      @opts = DEFAULT_OPTIONS.merge(opts)
+
+      @opts[:circuit_breaker_options] = DEFAULT_CIRCUIT_BREAKER_OPTIONS.merge(@opts[:circuit_breaker_options])
       super(app)
     end
 
     def call(request_env)
       service_response = nil
-      circuit(request_env).run!(run_options(request_env)) do
+      circuit(request_env).run do
         @app.call(request_env).on_complete do |env|
           service_response = Faraday::Response.new(env)
           raise RequestFailed if open_circuit?(service_response)
@@ -48,67 +64,28 @@ class Circuitbox
       circuit_open_value(request_env, service_response, ex)
     end
 
-    def exceptions
-      circuit_breaker_options[:exceptions]
-    end
-
-    def identifier
-      @identifier ||= opts.fetch(:identifier, ->(env) { env[:url] })
-    end
-
     private
 
-    def run_options(env)
-      env[:circuit_breaker_run_options] || {}
-    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)
-      )
-    end
-
-    def default_value
-      return @default_value if @default_value
-
-      default = opts.fetch(:default_value) do
-        lambda { |service_response, exception| NullResponse.new(service_response, exception) }
-      end
-
-      @default_value = if default.respond_to?(:call)
-                         default
-                       else
-                         lambda { |*| default }
-                       end
+    def call_default_value(response, exception)
+      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)
     end
 
-    def circuitbox
-      @circuitbox ||= opts.fetch(:circuitbox, Circuitbox)
-    end
-
     def circuit_open_value(env, service_response, exception)
-      env[:circuit_breaker_default_value] || call_default_lambda(service_response, exception)
-    end
-
-    def call_default_lambda(service_response, exception)
-      if default_value.arity == 2
-        default_value.call(service_response, exception)
-      else
-        default_value.call(service_response)
-      end
+      env[:circuit_breaker_default_value] || call_default_value(service_response, exception)
     end
 
     def circuit(env)
+      identifier = opts[:identifier]
       id = identifier.respond_to?(:call) ? identifier.call(env) : identifier
-      circuitbox.circuit id, circuit_breaker_options
-    end
 
+      Circuitbox.circuit(id, opts[:circuit_breaker_options])
+    end
   end
 end
+
+Faraday::Middleware.register_middleware circuitbox: Circuitbox::FaradayMiddleware

data/lib/circuitbox/memory_store.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative 'memory_store/monotonic_time'
+require_relative 'memory_store/container'
+
+class Circuitbox
+  class MemoryStore
+    include MonotonicTime
+
+    def initialize(compaction_frequency: 60)
+      @store = {}
+      @mutex = Mutex.new
+      @compaction_frequency = compaction_frequency
+      @compact_after = current_second + compaction_frequency
+    end
+
+    def store(key, value, opts = {})
+      @mutex.synchronize do
+        @store[key] = Container.new(value: value, expiry: opts.fetch(:expires, 0))
+        value
+      end
+    end
+
+    def increment(key, amount = 1, opts = {})
+      seconds_to_expire = opts.fetch(:expires, 0)
+
+      @mutex.synchronize do
+        existing_container = fetch_container(key)
+
+        # reusing the existing container is a small optmization
+        # to reduce the amount of objects created
+        if existing_container
+          existing_container.expires_after(seconds_to_expire)
+          existing_container.value += amount
+        else
+          @store[key] = Container.new(value: amount, expiry: seconds_to_expire)
+          amount
+        end
+      end
+    end
+
+    def load(key, _opts = {})
+      @mutex.synchronize { fetch_value(key) }
+    end
+
+    def key?(key)
+      @mutex.synchronize { !fetch_container(key).nil? }
+    end
+
+    def delete(key)
+      @mutex.synchronize { @store.delete(key) }
+    end
+
+  private
+
+    def fetch_container(key)
+      current_time = current_second
+
+      compact(current_time) if @compact_after < current_time
+
+      container = @store[key]
+
+      return unless container
+
+      if container.expired_at?(current_time)
+        @store.delete(key)
+        nil
+      else
+        container
+      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
+    end
+  end
+end

data/lib/circuitbox/memory_store/container.rb

@@ -0,0 +1,28 @@
+require_relative 'monotonic_time'
+
+class Circuitbox
+  class MemoryStore
+    class Container
+      include MonotonicTime
+
+      attr_accessor :value
+
+      def initialize(value:, expiry: 0)
+        @value = value
+        expires_after(expiry)
+      end
+
+      def expired?
+        @expires_after > 0 && @expires_after < current_second
+      end
+
+      def expired_at?(clock_second)
+        @expires_after > 0 && @expires_after < clock_second
+      end
+
+      def expires_after(seconds = 0)
+        @expires_after = seconds.zero? ? seconds : current_second + seconds
+      end
+    end
+  end
+end