shift-circuit-breaker 0.2.0

data/config/rubocop/.style_rubocop.yml

@@ -0,0 +1,154 @@
+Style/Alias:
+  Enabled: false
+
+Style/ArrayJoin:
+  Enabled: false
+
+Style/AsciiComments:
+  Enabled: false
+
+Style/Attr:
+  Enabled: false
+
+Style/BlockComments:
+  Enabled: false
+
+Style/CaseEquality:
+  Enabled: false
+
+Style/CharacterLiteral:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/CollectionMethods:
+  Enabled: true
+  PreferredMethods:
+    length: "size"
+
+Style/ColonMethodCall:
+  Enabled: false
+
+Style/CommentAnnotation:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/EachWithObject:
+  Enabled: false
+
+Style/EmptyLiteral:
+  Enabled: false
+
+Style/EvenOdd:
+  Enabled: false
+
+Style/FlipFlop:
+  Enabled: false
+
+Style/FormatString:
+  Enabled: false
+
+Style/GlobalVars:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/IfWithSemicolon:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false
+
+Style/LambdaCall:
+  Enabled: false
+
+Style/LineEndConcatenation:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/NegatedIf:
+  Enabled: false
+
+Style/NegatedWhile:
+  Enabled: false
+
+Style/Next:
+  Enabled: false
+
+Style/NilComparison:
+  Enabled: false
+
+Style/Not:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/OneLineConditional:
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/Proc:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/SelfAssignment:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Style/SingleLineMethods:
+  Enabled: false
+
+Style/SpecialGlobalVars:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+  
+Style/TrailingCommaInArguments:
+  Enabled: false
+
+Style/TrailingCommaInLiteral:
+  Enabled: false
+
+Style/TrivialAccessors:
+  Enabled: false
+
+Style/VariableInterpolation:
+  Enabled: false
+
+Style/WhenThen:
+  Enabled: false
+
+Style/WhileUntilModifier:
+  Enabled: false
+
+Style/WordArray:
+  Enabled: false

data/lib/shift/circuit_breaker.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/inflections"
+require "faraday"
+require "logger"
+require "net/protocol"
+require "sentry-raven"
+require "singleton"
+require "timeout"
+
+require "shift/circuit_breaker/adapters/base_adapter"
+require "shift/circuit_breaker/adapters/sentry_adapter"
+require "shift/circuit_breaker/adapters/newrelic_adapter"
+require "shift/circuit_breaker/config"
+require "shift/circuit_breaker/circuit_logger"
+require "shift/circuit_breaker/circuit_monitor"
+require "shift/circuit_breaker/circuit_handler"
+require "shift/circuit_breaker/version"
+
+module Shift
+  #
+  # ==== Example Usage:
+  #
+  # class MyClass
+  #   CIRCUIT_BREAKER = Shift::CircuitBreaker.new(:an_identifier_for_the_circuit,
+  #                                               error_threshold: 10,
+  #                                               skip_duration: 60,
+  #                                               additional_exception_classes: [Faraday::ClientError]
+  #                                             )
+  #
+  #   def do_something
+  #     # Note: operation and fallback should implement the public method #call or wrapped in a Proc/Lambda (as in the example below).
+  #     CIRCUIT_BREAKER.call(operation: -> { SomeService.new(name: 'test').perform_task }, fallback: -> { [1, 2, 3, 4, 5].sum })
+  #   end
+  # end
+  #
+  module CircuitBreaker
+    class << self
+      def new(*args)
+        Shift::CircuitBreaker::CircuitHandler.new(*args)
+      end
+
+      def config
+        @config ||= Shift::CircuitBreaker::Config.instance
+      end
+
+      def configure
+        @config = Shift::CircuitBreaker::Config.instance.tap do |config|
+          yield config if block_given?
+        end
+        @config.initialize_dependencies
+      end
+    end
+  end
+end

data/lib/shift/circuit_breaker/adapters/base_adapter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Shift
+  module CircuitBreaker
+    module Adapters
+      class BaseAdapter
+        def self.call(_message)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/shift/circuit_breaker/adapters/newrelic_adapter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Shift
+  module CircuitBreaker
+    module Adapters
+      class NewRelicAdapter < BaseAdapter
+        def self.call(message)
+          ::NewRelic::Agent.increment_metric(message) if defined?(NewRelic)
+        end
+      end
+    end
+  end
+end

data/lib/shift/circuit_breaker/adapters/sentry_adapter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Shift
+  module CircuitBreaker
+    module Adapters
+      class SentryAdapter < BaseAdapter
+        def self.call(message)
+          ::Raven.capture_exception(message) if defined?(Raven)
+        end
+      end
+    end
+  end
+end

data/lib/shift/circuit_breaker/circuit_handler.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Shift
+  module CircuitBreaker
+    #
+    # === Overview
+    #
+    # Implements a generic mechanism for detecting external service call timeouts and reduces the
+    # time spent waiting for further requests that will most-likely fail (e.g. timeout) and cause request queueing.
+    #
+    # Similar to a conventional circuit breaker, when a circuit is closed it allows operations
+    # to flow through. When the error_threshold is exceeded (tripped), the circuit is then opened for
+    # the defined skip_duration, ie. no operations are executed and the provided fallback is called.
+    #
+    class CircuitHandler
+      attr_accessor :name, :error_threshold, :skip_duration, :exception_classes, :error_count, :last_error_time, :state, :logger, :monitor
+
+      DEFAULT_EXCEPTION_CLASSES = [Net::OpenTimeout, Net::ReadTimeout, Faraday::TimeoutError, Timeout::Error].freeze
+
+      # Initializer creates an instance of the service
+      #
+      # @param [Symbol]  name              - the name used to identify the circuit breaker
+      # @param [Integer] error_threshold   - The minimum error threshold required for the circuit to be opened/tripped
+      # @param [Integer] skip_duration     - The duration in seconds the circuit should be open for before operations are allowed through/executed
+      # @param [Array]   additional_exception_classes - Any additional exception classes to rescue along the DEFAULT_EXCEPTION_CLASSES
+      # @param [Object]  logger            - service to handle error logging
+      # @param [Object]  monitor           - service to monitor metric
+      def initialize(name,
+                     error_threshold:,
+                     skip_duration:,
+                     additional_exception_classes: [],
+                     logger: Shift::CircuitBreaker::CircuitLogger.new,
+                     monitor: Shift::CircuitBreaker::CircuitMonitor.new)
+
+        self.name               = name
+        self.error_threshold    = error_threshold
+        self.skip_duration      = skip_duration
+        self.exception_classes  = (additional_exception_classes | DEFAULT_EXCEPTION_CLASSES)
+        self.logger             = logger
+        self.monitor            = monitor
+        self.error_count        = 0
+        self.last_error_time    = nil
+        self.state              = :closed
+      end
+
+      # Performs the given operation within the circuit
+      # @param [Proc] operation - the operation to be performed
+      # @param [Proc] fallback  - The result returned if the operation is not performed or raises an exception
+      def call(operation:, fallback:)
+        raise ArgumentError unless operation.respond_to?(:call) && fallback.respond_to?(:call)
+        set_state
+        if state == :open
+          monitor.record_metric(name, state)
+          return fallback.call
+        end
+        perform_operation(operation, fallback)
+      end
+
+      private
+
+      def set_state
+        # The curcuit is opened/tripped if the error_threshold is met or exceeded
+        # (error_count >= error_threshold) and the last_error_time is within
+        # the skip_duration (see comments in #skip_duration_expired?).
+        self.state = (error_count >= error_threshold) && !skip_duration_expired? ? :open : :closed
+      end
+
+      def skip_duration_expired?
+        return true unless last_error_time.present?
+        # IF the difference in time between now and the last_error_time
+        # is greater than the skip_duration, then it will have expired.
+        (Time.now - last_error_time) > skip_duration
+      end
+
+      def reset_state
+        # Reset the error attributes to default values.
+        self.error_count = 0
+        self.last_error_time = nil
+        self.state = :closed
+      end
+
+      def record_error
+        # Increment the error_count
+        self.error_count += 1
+        # Set the time the error occured.
+        self.last_error_time = Time.now
+      end
+
+      def perform_operation(operation, fallback)
+        response = operation.call
+        reset_state
+        monitor.record_metric(name, state)
+        response
+      rescue *exception_classes
+        handle_exception($!, fallback)
+      end
+
+      def handle_exception(exception, fallback)
+        record_error
+        set_state
+        monitor.record_metric(name, state)
+        logger.error(circuit_name: name, state: state, error_message: exception.message)
+        fallback.call
+      end
+    end
+  end
+end

data/lib/shift/circuit_breaker/circuit_logger.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Shift
+  module CircuitBreaker
+    class CircuitLogger
+      attr_accessor :logger, :remote_logger
+
+      delegate :debug, :fatal, :info, :warn, :add, :log, to: :logger
+
+      ERROR_MESSAGE = <<~EOF
+        ====================================================================================
+        CIRCUIT BREAKER REQUEST FAILURE: %<circuit_name>s
+
+        STATE: %<state>s
+        MESSAGE: %<error_message>s
+        ====================================================================================
+        EOF
+
+      # Initializer creates an instance of the service
+      #
+      # @param [Object]  logger  - service to handle internal logging
+      # @param [Object]  remote_logger - external error logging service eg. Sentry
+      def initialize(logger: ::Logger.new(STDOUT), remote_logger: Shift::CircuitBreaker::Adapters::SentryAdapter)
+        self.logger = logger
+        self.remote_logger = remote_logger
+      end
+
+      # @param [Object] context - contains :circuit_name, :state, :error_message
+      def error(context)
+        message = (ERROR_MESSAGE % context)
+        logger.error(message)
+        remote_logger.call(message) if remote_logger.respond_to?(:call)
+      end
+    end
+  end
+end

data/lib/shift/circuit_breaker/circuit_monitor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Shift
+  module CircuitBreaker
+    class CircuitMonitor
+      attr_accessor :monitor, :logger
+
+      # Initializer creates an instance of the service
+      #
+      # @param [Object] monitor - service to handle monitoring
+      # @param [Object] logger  - service to handle logging
+      def initialize(monitor: Shift::CircuitBreaker::Adapters::NewRelicAdapter, logger: Shift::CircuitBreaker::CircuitLogger.new)
+        self.monitor = monitor
+        self.logger = logger
+      end
+
+      # @param [String] name - The circuit name
+      # @param [Symbol] state - The circuit state
+      def record_metric(name, state)
+        metric = formatted_metric(name, state)
+        monitor.call(metric) if monitor.respond_to?(:call)
+        logger.info("* #{metric} *")
+      end
+
+      private
+
+      def formatted_metric(name, state)
+        "Custom/#{name.to_s.classify}CircuitBreaker/#{state.to_s.classify}"
+      end
+    end
+  end
+end

data/lib/shift/circuit_breaker/config.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Shift
+  module CircuitBreaker
+    #
+    # Global Configuration Object
+    #
+    # ==== Example Usage:
+    #
+    # Add an initializer in your application (eg. shift_circuit_breaker.rb)
+    # with the following configs:
+    #
+    # Shift::CircuitBreaker.configure do |config|
+    #   config.new_relic_license_key  = ENV["NEW_RELIC_LICENSE_KEY"]
+    #   config.new_relic_app_name     = ENV["NEW_RELIC_APP_NAME"]
+    #   config.sentry_dsn             = ENV["SENTRY_DSN"]
+    #   config.sentry_environments    = %w[ production ]
+    # end
+    #
+    class Config
+      include Singleton
+
+      attr_accessor :new_relic_license_key, :new_relic_app_name, :sentry_dsn, :sentry_environments
+
+      def initialize_dependencies
+        initialize_sentry
+        initialize_newrelic
+      end
+
+      private
+
+      def initialize_sentry
+        if sentry_dsn
+          Raven.configure do |config|
+            config.dsn = sentry_dsn
+            config.environments = sentry_environments if sentry_environments.present?
+          end
+        end
+      end
+
+      def initialize_newrelic
+        if new_relic_app_name.present? && new_relic_license_key.present?
+          require "newrelic_rpm"
+        end
+      end
+    end
+  end
+end