stoplight 5.8.3 → 6.0.0.rc2

data/lib/stoplight/admin/lights_repository/light.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module Stoplight
-  class Admin
-    class LightsRepository
-      class Light
-        COLORS = [
-          GREEN = Stoplight::Color::GREEN,
-          YELLOW = Stoplight::Color::YELLOW,
-          RED = Stoplight::Color::RED
-        ].freeze
-
-        # @!attribute id
-        #   @return [String]
-        attr_reader :id
-
-        # @!attribute name
-        #   @return [String]
-        attr_reader :name
-
-        # @!attribute color
-        #   @return [String]
-        attr_reader :color
-
-        # @!attribute state
-        #   @return [String]
-        attr_reader :state
-
-        # @!attribute failures
-        #   @return [<Stoplight::Failure>]
-        attr_reader :failures
-
-        # @!attribute failure_count
-        #   @return [Integer]
-        attr_reader :failure_count
-
-        # @param name [String]
-        # @param color [String]
-        # @param state [String]
-        # @param failures [<Stoplight::Failure>]
-        # @param failure_count [Integer, nil]
-        def initialize(name:, color:, state:, failures:, failure_count: nil)
-          @id = SecureRandom.uuid
-          @name = name
-          @color = color
-          @state = state
-          @failures = failures
-          @failure_count = failure_count
-        end
-
-        def latest_failure
-          failures.first
-        end
-
-        # @return [Boolean]
-        def locked?
-          !unlocked?
-        end
-
-        # @return [Boolean]
-        def unlocked?
-          state == Stoplight::State::UNLOCKED
-        end
-
-        # @return [Hash]
-        def as_json
-          {
-            name: name,
-            color: color,
-            failures: failures,
-            locked: locked?
-          }
-        end
-
-        # @return [Array]
-        def default_sort_key
-          [-COLORS.index(color), name]
-        end
-
-        def last_check = latest_failure&.time # TODO: take into account positive checks as well
-
-        # @return [String, nil]
-        def last_check_in_words
-          last_error_time = latest_failure&.time
-          return unless last_error_time
-
-          time_difference = Time.now.utc - last_error_time
-          if time_difference < 1
-            "just now"
-          elsif time_difference < 60
-            "#{time_difference.to_i}s ago"
-          elsif time_difference < 3600
-            "#{(time_difference / 60).to_i}m ago"
-          elsif time_difference < 86400
-            "#{(time_difference / 3600).to_i}h ago"
-          else
-            "#{(time_difference / 86400).to_i}d ago"
-          end
-        end
-
-        # @return [String]
-        def description_title
-          case color
-          when RED
-            if locked? && failures.empty?
-              "Locked Open"
-            else
-              "Last Error"
-            end
-          when Stoplight::Color::YELLOW
-            "Testing Recovery"
-          when GREEN
-            if locked?
-              "Forced Healthy"
-            else
-              "Healthy"
-            end
-          end
-        end
-
-        # @return [String]
-        def description_message
-          case color
-          when RED
-            if latest_failure
-              "#{latest_failure.error_class}: #{latest_failure.error_message}"
-            elsif locked?
-              "Circuit manually locked open"
-            else
-              "Not available"
-            end
-          when Stoplight::Color::YELLOW
-            if latest_failure
-              "#{latest_failure.error_class}: #{latest_failure.error_message}"
-            else
-              "Not available"
-            end
-          when GREEN
-            if locked?
-              "Circuit manually locked closed"
-            else
-              "No recent errors"
-            end
-          end
-        end
-
-        # @return [String]
-        def description_comment
-          case color
-          when RED
-            if locked?
-              "Override active - all requests blocked"
-            else
-              "Will attempt recovery after cooling period"
-            end
-          when YELLOW
-            "Allowing limited test traffic (0 of 1 requests)"
-          when GREEN
-            if locked?
-              "Override active - all requests processed"
-            else
-              "Operating normally"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stoplight/admin/lights_repository.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  class Admin
-    class LightsRepository
-      # @!attribute data_store
-      #   @return [Stoplight::Domain::_DataStore]
-      attr_reader :data_store
-      private :data_store
-
-      #  @param data_store [Stoplight::Domain::_DataStore]
-      def initialize(data_store:)
-        @data_store = data_store
-      end
-
-      # @return [<Stoplight::Admin::LightsRepository::Light>]
-      def all
-        data_store
-          .names
-          .map { |name| load_light(name) }
-          .sort_by(&:default_sort_key)
-      end
-
-      # @param colors <String>] colors name
-      # @return [<Stoplight::Admin::LightsRepository::Light>] lights with the requested colors
-      #
-      def with_color(*colors)
-        requested_colors = Array(colors)
-
-        all.select do |light|
-          requested_colors.include?(light.color)
-        end
-      end
-
-      # @param name [String] locks light by its name
-      # @param color [String, nil] locks to this color. When nil is given, locks to the current
-      #   color
-      # @return [void]
-      def lock(name, color = nil)
-        config = build_config(name)
-        color ||= data_store.get_state_snapshot(config).color
-
-        case color
-        when Stoplight::Color::GREEN
-          data_store.set_state(config, Stoplight::State::LOCKED_GREEN)
-        else
-          data_store.set_state(config, Stoplight::State::LOCKED_RED)
-        end
-      end
-
-      # @param name [String] unlocks light by its name
-      # @return [void]
-      def unlock(name)
-        config = build_config(name)
-        data_store.set_state(config, State::UNLOCKED)
-      end
-
-      # @param name [String] removes light metadata by its name
-      # @return [void]
-      def remove(name)
-        config = build_config(name)
-
-        data_store.delete_light(config)
-      end
-
-      private def load_light(name)
-        config = build_config(name)
-
-        # failures, state
-        state_snapshot = data_store.get_state_snapshot(config)
-        metrics = data_store.get_metrics(config)
-
-        Light.new(
-          name: name,
-          color: state_snapshot.color,
-          state: state_snapshot.locked_state,
-          failures: [metrics.last_error].compact,
-          failure_count: metrics.consecutive_errors
-        )
-      end
-
-      private def build_config(name)
-        Wiring::DefaultConfig.with(name:)
-      end
-    end
-  end
-end

data/lib/stoplight/domain/light/configuration_builder_interface.rb

@@ -1,236 +0,0 @@
-# frozen_string_literal: true
-
-require "forwardable"
-
-module Stoplight
-  module Domain
-    class Light
-      # Implements light configuration behavior
-      # steep:ignore:start
-      module ConfigurationBuilderInterface
-        # Configures data store to be used with this circuit breaker
-        #
-        # @example
-        #   Stoplight('example')
-        #     .with_data_store(Stoplight::DataStore::Memory.new)
-        #
-        # @param data_store [DataStore::Base]
-        # @return [Stoplight::Light]
-        # @deprecated
-        def with_data_store(data_store)
-          deprecate(<<~MSG)
-            Light#with_data_store is deprecated and will be removed in v6.0.0.
-
-            Circuit breakers should be configured once at creation, not cloned with
-            modifications.
-
-            Instead of:
-              light = Stoplight('api-call')
-              modified = light.with_data_store(data_stare)
-
-            Configure correctly from the start:
-              Stoplight('api-call', data_store:)
-          MSG
-          with_without_warning(data_store:)
-        end
-
-        # Configures cool off time. Stoplight automatically tries to recover
-        # from the red state after the cool off time.
-        #
-        # @example
-        #   Stoplight('example')
-        #     .cool_off_time(60)
-        #
-        # @param cool_off_time [Numeric] number of seconds
-        # @return [Stoplight::Light]
-        # @deprecated
-        def with_cool_off_time(cool_off_time)
-          deprecate(<<~MSG)
-            Light#with_cool_off_time is deprecated and will be removed in v6.0.0.
-
-            Circuit breakers should be configured once at creation, not cloned with
-            modifications.
-
-            Instead of:
-              light = Stoplight('api-call')
-              modified = light.with_cool_off_time(cool_off_time)
-
-            Configure correctly from the start:
-              Stoplight('api-call', cool_off_time:)
-          MSG
-          with_without_warning(cool_off_time:)
-        end
-
-        # Configures custom threshold. After this number of failures Stoplight
-        # switches to the red state:
-        #
-        # @example
-        #   Stoplight('example')
-        #     .with_threshold(5)
-        #
-        # @param threshold [Numeric]
-        # @return [Stoplight::Light]
-        # @deprecated
-        def with_threshold(threshold)
-          deprecate(<<~MSG)
-            Light#with_threshold is deprecated and will be removed in v6.0.0.
-
-            Circuit breakers should be configured once at creation, not cloned with
-            modifications.
-
-            Instead of:
-              light = Stoplight('api-call')
-              modified = light.with_threshold(threshold)
-
-            Configure correctly from the start:
-              Stoplight('api-call', threshold:)
-          MSG
-          with_without_warning(threshold:)
-        end
-
-        # Configures custom window size which Stoplight uses to count failures. For example,
-        #
-        # @example
-        #   Stoplight('example')
-        #     .with_threshold(5)
-        #     .with_window_size(60)
-        #
-        # The above example will turn to red light only when 5 errors happen
-        # within 60 seconds period.
-        #
-        # @param window_size [Numeric] number of seconds
-        # @return [Stoplight::Light]
-        # @deprecated
-        def with_window_size(window_size)
-          deprecate(<<~MSG)
-            Light#with_window_size is deprecated and will be removed in v6.0.0.
-
-            Circuit breakers should be configured once at creation, not cloned with
-            modifications.
-
-            Instead of:
-              light = Stoplight('api-call')
-              modified = light.with_window_size(window_size)
-
-            Configure correctly from the start:
-              Stoplight('api-call', window_size:)
-          MSG
-          with_without_warning(window_size:)
-        end
-
-        # Configures custom notifier
-        #
-        # @example
-        #   io = StringIO.new
-        #   notifier = Stoplight::Notifier::IO.new(io)
-        #   Stoplight('example')
-        #     .with_notifiers([notifier])
-        #
-        # @param notifiers [Array<Notifier::Base>]
-        # @return [Stoplight::Light]
-        # @deprecated
-        def with_notifiers(notifiers)
-          deprecate(<<~MSG)
-            Light#with_notifiers is deprecated and will be removed in v6.0.0.
-
-            Circuit breakers should be configured once at creation, not cloned with
-            modifications.
-
-            Instead of:
-              light = Stoplight('api-call')
-              modified = light.with_notifiers(notifiers)
-
-            Configure correctly from the start:
-              Stoplight('api-call', notifiers:)
-          MSG
-          with_without_warning(notifiers:)
-        end
-
-        # @param error_notifier [Proc]
-        # @return [Stoplight::Light]
-        # @api private
-        # @deprecated
-        def with_error_notifier(&error_notifier)
-          deprecate(<<~MSG)
-            Light#with_error_notifier is deprecated and will be removed in v6.0.0.
-
-            Circuit breakers should be configured once at creation, not cloned with
-            modifications.
-
-            Instead of:
-              light = Stoplight('api-call')
-              modified = light.with_error_notifier { |error| warn error }
-
-            Configure correctly from the start:
-              Stoplight('api-call', error_notifier: ->(error) { warn error })
-          MSG
-          with_without_warning(error_notifier: error_notifier)
-        end
-
-        # Configures a custom list of tracked errors that counts toward the threshold.
-        #
-        # @example
-        #   light = Stoplight('example')
-        #     .with_tracked_errors(TimeoutError, NetworkError)
-        #   light.run { call_external_service }
-        #
-        # In the example above, the +TimeoutError+ and +NetworkError+ exceptions
-        # will be counted towards the threshold for moving the circuit breaker into the red state.
-        # If not configured, the default tracked error is +StandardError+.
-        #
-        # @param tracked_errors [Array<StandardError>]
-        # @return [Stoplight::Light]
-        # @deprecated
-        def with_tracked_errors(*tracked_errors)
-          deprecate(<<~MSG)
-            Light#with_tracked_errors is deprecated and will be removed in v6.0.0.
-
-            Circuit breakers should be configured once at creation, not cloned with
-            modifications.
-
-            Instead of:
-              light = Stoplight('api-call')
-              modified = light.with_tracked_errors(TimeoutError, NetworkError)
-
-            Configure correctly from the start:
-              Stoplight('api-call', tracked_errors: [TimeoutError, NetworkError])
-          MSG
-          with_without_warning(tracked_errors:)
-        end
-
-        # Configures a custom list of skipped errors that do not count toward the threshold.
-        # Typically, such errors does not represent a real failure and handled somewhere else
-        # in the code.
-        #
-        # @example
-        #   light = Stoplight('example')
-        #    .with_skipped_errors(ActiveRecord::RecordNotFound)
-        #   light.run { User.find(123) }
-        #
-        # In the example above, the +ActiveRecord::RecordNotFound+ doesn't
-        # move the circuit breaker into the red state.
-        #
-        # @param skipped_errors [Array<Exception>]
-        # @return [Stoplight::Light]
-        # @deprecated
-        def with_skipped_errors(*skipped_errors)
-          deprecate(<<~MSG)
-            Light#with_skipped_errors is deprecated and will be removed in v6.0.0.
-
-            Circuit breakers should be configured once at creation, not cloned with
-            modifications.
-
-            Instead of:
-              light = Stoplight('api-call')
-              modified = light.with_skipped_errors(ActiveRecord::RecordNotFound)
-
-            Configure correctly from the start:
-              Stoplight('api-call', skipped_errors: [ActiveRecord::RecordNotFound])
-          MSG
-          with_without_warning(skipped_errors:)
-        end
-      end
-      # steep:ignore:end
-    end
-  end
-end

data/lib/stoplight/infrastructure/fail_safe/data_store.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module Stoplight
-  module Infrastructure
-    module FailSafe
-      # A wrapper around a data store that provides fail-safe mechanisms using a
-      # circuit breaker. It ensures that operations on the data store can gracefully
-      # handle failures by falling back to default values when necessary.
-      #
-      # @api private
-      # steep:ignore:start
-      class DataStore
-        # The underlying primary data store being used
-        attr_reader :data_store
-        attr_reader :error_notifier
-        # The fallback data store used when the primary fails.
-        attr_reader :failover_data_store
-        # The circuit breaker used to handle data store failures.
-        private attr_reader :circuit_breaker
-
-        def initialize(data_store:, error_notifier:, failover_data_store:, circuit_breaker:)
-          @data_store = data_store
-          @error_notifier = error_notifier
-          @failover_data_store = failover_data_store
-          @circuit_breaker = circuit_breaker
-        end
-
-        def names
-          with_fallback(:names) do
-            data_store.names
-          end
-        end
-
-        def get_metrics(config)
-          with_fallback(:get_metrics, config) do
-            data_store.get_metrics(config)
-          end
-        end
-
-        def get_recovery_metrics(config)
-          with_fallback(:get_recovery_metrics, config) do
-            data_store.get_recovery_metrics(config)
-          end
-        end
-
-        def get_state_snapshot(config)
-          with_fallback(:get_state_snapshot, config) do
-            data_store.get_state_snapshot(config)
-          end
-        end
-
-        def clear_metrics(config)
-          with_fallback(:clear_metrics, config) do
-            data_store.clear_metrics(config)
-          end
-        end
-
-        def clear_recovery_metrics(config)
-          with_fallback(:clear_recovery_metrics, config) do
-            data_store.clear_recovery_metrics(config)
-          end
-        end
-
-        def record_failure(config, exception)
-          with_fallback(:record_failure, config, exception) do
-            data_store.record_failure(config, exception)
-          end
-        end
-
-        def record_success(config)
-          with_fallback(:record_success, config) do
-            data_store.record_success(config)
-          end
-        end
-
-        def record_recovery_probe_success(config)
-          with_fallback(:record_recovery_probe_success, config) do
-            data_store.record_recovery_probe_success(config)
-          end
-        end
-
-        def record_recovery_probe_failure(config, exception)
-          with_fallback(:record_recovery_probe_failure, config, exception) do
-            data_store.record_recovery_probe_failure(config, exception)
-          end
-        end
-
-        def set_state(config, state)
-          with_fallback(:set_state, config, state) do
-            data_store.set_state(config, state)
-          end
-        end
-
-        def transition_to_color(config, color)
-          with_fallback(:transition_to_color, config, color) do
-            data_store.transition_to_color(config, color)
-          end
-        end
-
-        def delete_light(config)
-          with_fallback(:delete_light, config) do
-            data_store.delete_light(config)
-          end
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        def acquire_recovery_lock(config)
-          with_fallback(:acquire_recovery_lock, config) do
-            data_store.acquire_recovery_lock(config)
-          end
-        end
-
-        # Routes release to correct store based on token type.
-        # Redis tokens release via primary (with error notification on failure).
-        # Memory tokens release via failover directly.
-        #
-        def release_recovery_lock(recovery_lock_token)
-          case recovery_lock_token
-          in Redis::DataStore::RecoveryLockToken
-            fallback = proc do |error|
-              error_notifier.call(error) if error
-            end
-
-            circuit_breaker.run(fallback) do
-              data_store.release_recovery_lock(recovery_lock_token)
-            end
-          in Memory::DataStore::RecoveryLockToken
-            failover_data_store.release_recovery_lock(recovery_lock_token)
-          end
-        end
-
-        def ==(other)
-          other.is_a?(self.class) && other.data_store == data_store && other.error_notifier == error_notifier &&
-            other.failover_data_store == failover_data_store
-        end
-
-        private def with_fallback(method_name, *args, **kwargs, &code)
-          fallback = ->(error) {
-            config = args.first
-            error_notifier.call(error) if config && error
-            failover_data_store.public_send(method_name, *args, **kwargs)
-          }
-
-          circuit_breaker.run(fallback, &code)
-        end
-      end
-      # steep:ignore:end
-    end
-  end
-end

data/lib/stoplight/infrastructure/memory/data_store/metrics.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module Memory
-      class DataStore
-        class Metrics
-          attr_accessor :consecutive_errors
-          attr_accessor :consecutive_successes
-          attr_accessor :last_error
-          attr_accessor :last_success_at
-
-          def initialize(consecutive_errors: 0, consecutive_successes: 0, last_error: nil, last_success_at: nil)
-            @consecutive_errors = consecutive_errors
-            @consecutive_successes = consecutive_successes
-            @last_error = last_error
-            @last_success_at = last_success_at
-          end
-
-          def last_error_at
-            @last_error&.time
-          end
-        end
-      end
-    end
-  end
-end