circuitbox 1.1.0 → 2.0.0.pre4

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

data/lib/circuitbox/faraday_middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'faraday'
 require 'circuitbox'
 
@@ -5,13 +7,9 @@ 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)
         @original_response  = response
         @original_exception = exception
@@ -19,96 +17,78 @@ 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)
         end
       end
-    rescue Circuitbox::Error => ex
-      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] })
+    rescue Circuitbox::Error => e
+      circuit_open_value(request_env, service_response, e)
     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,85 @@
+# 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,30 @@
+# frozen_string_literal: true
+
+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.positive? && @expires_after < current_second
+      end
+
+      def expired_at?(clock_second)
+        @expires_after.positive? && @expires_after < clock_second
+      end
+
+      def expires_after(seconds = 0)
+        @expires_after = seconds.zero? ? seconds : current_second + seconds
+      end
+    end
+  end
+end

data/lib/circuitbox/memory_store/monotonic_time.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Circuitbox
+  class MemoryStore
+    module MonotonicTime
+      module_function
+
+      def current_second
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, :second)
+      end
+    end
+  end
+end

data/lib/circuitbox/notifier/active_support.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Circuitbox
+  class Notifier
+    class ActiveSupport
+      def notify(circuit_name, event)
+        ::ActiveSupport::Notifications.instrument("circuit_#{event}", circuit: circuit_name)
+      end
+
+      def notify_warning(circuit_name, message)
+        ::ActiveSupport::Notifications.instrument('circuit_warning', 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)
+      end
+    end
+  end
+end