circuitbox 1.1.1 → 2.0.0.pre4

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/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/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/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

data/lib/circuitbox/notifier/null.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Circuitbox
+  class Notifier
+    class Null
+      def notify(_, _); end
+
+      def notify_warning(_, _); end
+
+      def metric_gauge(_, _, _); end
+    end
+  end
+end

data/lib/circuitbox/timer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Circuitbox
+  class Timer
+    class Monotonic
+      class << self
+        def supported?
+          defined?(Process::CLOCK_MONOTONIC)
+        end
+
+        def now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+
+    class Default
+      class << self
+        def supported?
+          true
+        end
+
+        def now
+          Time.now.to_f
+        end
+      end
+    end
+
+    class << self
+      def measure(service, notifier, metric_name)
+        before = now
+        result = yield
+        total_time = now - before
+        notifier.metric_gauge(service, metric_name, total_time)
+        result
+      end
+
+      private
+
+      if Monotonic.supported?
+        def now
+          Monotonic.now
+        end
+      else
+        def now
+          Default.now
+        end
+      end
+    end
+  end
+end

data/lib/circuitbox/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Circuitbox
-VERSION='1.1.1'
+  VERSION = '2.0.0.pre4'
 end

data/lib/circuitbox.rb

@@ -1,64 +1,24 @@
-require 'uri'
+# frozen_string_literal: true
+
 require 'logger'
-require 'timeout'
-require 'moneta'
-require 'active_support/all'
 
-require 'circuitbox/version'
-require 'circuitbox/circuit_breaker'
-require 'circuitbox/notifier'
-require 'circuitbox/errors/error'
-require 'circuitbox/errors/open_circuit_error'
-require 'circuitbox/errors/service_failure_error'
+require_relative 'circuitbox/version'
+require_relative 'circuitbox/circuit_breaker'
+require_relative 'circuitbox/errors/error'
+require_relative 'circuitbox/errors/open_circuit_error'
+require_relative 'circuitbox/errors/service_failure_error'
+require_relative 'circuitbox/configuration'
 
 class Circuitbox
-  attr_accessor :circuits, :circuit_store
-  cattr_accessor :configure
+  class << self
+    include Configuration
 
-  def self.instance
-    @@instance ||= new
-  end
+    def circuit(service_name, options, &block)
+      circuit = (cached_circuits[service_name] ||= CircuitBreaker.new(service_name, options))
 
-  def initialize
-    self.instance_eval(&@@configure) if @@configure
-  end
-
-  def self.configure(&block)
-    @@configure = block if block
-  end
-
-  def self.reset
-    @@instance = nil
-    @@configure = nil
-  end
-
-  def self.circuit_store
-    self.instance.circuit_store ||= Moneta.new(:Memory, expires: true)
-  end
+      return circuit unless block
 
-  def self.circuit_store=(store)
-    self.instance.circuit_store = store
-  end
-
-  def self.[](service_identifier, options = {})
-    self.circuit(service_identifier, options)
-  end
-
-  def self.circuit(service_identifier, options = {})
-    service_name = self.parameter_to_service_name(service_identifier)
-
-    self.instance.circuits ||= Hash.new
-    self.instance.circuits[service_name] ||= CircuitBreaker.new(service_name, options)
-
-    if block_given?
-      self.instance.circuits[service_name].run { yield }
-    else
-      self.instance.circuits[service_name]
+      circuit.run(circuitbox_exceptions: false, &block)
     end
   end
-
-  def self.parameter_to_service_name(param)
-    uri = URI(param.to_s)
-    uri.host.present? ? uri.host : param.to_s
-  end
 end