stoplight 5.6.0 → 5.8.0

data/lib/stoplight/wiring/container.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    # This container implements an instance of +Stoplight::Infrastructure::DependencyInjection::Container+
-    # with Stoplight-specific wiring knowledge. It defines how to construct and connect
-    # all the components needed for a circuit breaker to function.
-    #
-    # ## Default Configuration
-    #
-    # The container is pre-configured with sensible defaults:
-    # - Data Store - in-memory storage
-    # - STDERR notifier
-    # - No-op error notifier
-    # - Consecutive failure detection
-    # - Consecutive success recovery
-    #
-    # @see Infrastructure::DependencyInjection::Container Generic DI container
-    # @see Stoplight::Wiring::LightFactory Factory that uses this container
-    # @api private
-    Container = Infrastructure::DependencyInjection::Container.define do
-      register(:config, Light::DefaultConfig)
-      register(:error_notifier, Default::ERROR_NOTIFIER)
-      register(:traffic_control, Default::TRAFFIC_CONTROL)
-      register(:traffic_recovery, Default::TRAFFIC_RECOVERY)
-
-      register(:data_store, Default::DATA_STORE) do |data_store|
-        FailSafeDataStore.wrap(
-          data_store:,
-          error_notifier: resolve(:error_notifier)
-        )
-      end
-
-      register(:notifiers, Default::NOTIFIERS) do |notifiers|
-        error_notifier = resolve(:error_notifier)
-        notifiers.map { |notifier| Wiring::FailSafeNotifier.wrap(notifier:, error_notifier:) }
-      end
-
-      factory(:green_run_strategy) do
-        Domain::Strategies::GreenRunStrategy.new(
-          config: resolve(:config),
-          request_tracker: resolve(:request_tracker)
-        )
-      end
-
-      factory(:yellow_run_strategy) do
-        Domain::Strategies::YellowRunStrategy.new(
-          config: resolve(:config),
-          data_store: resolve(:data_store),
-          notifiers: resolve(:notifiers),
-          request_tracker: resolve(:recovery_probe_tracker)
-        )
-      end
-
-      factory(:red_run_strategy) do
-        Domain::Strategies::RedRunStrategy.new(
-          config: resolve(:config)
-        )
-      end
-
-      factory(:request_tracker) do
-        Domain::Tracker::Request.new(
-          data_store: resolve(:data_store),
-          traffic_control: resolve(:traffic_control),
-          notifiers: resolve(:notifiers),
-          config: resolve(:config)
-        )
-      end
-
-      factory(:recovery_probe_tracker) do
-        Domain::Tracker::RecoveryProbe.new(
-          data_store: resolve(:data_store),
-          traffic_recovery: resolve(:traffic_recovery),
-          notifiers: resolve(:notifiers),
-          config: resolve(:config)
-        )
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/default_factory_builder.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    # Builds the default LightFactory from user-provided configuration which is
-    # used as the basis for all circuit breakers.
-    #
-    class DefaultFactoryBuilder
-      # @!attribute [r] configuration
-      #  @return [Stoplight::Wiring::DefaultConfiguration]
-      #
-      attr_reader :configuration
-
-      def initialize
-        @configuration = DefaultConfiguration.new
-      end
-
-      # @return [Stoplight::Wiring::LightFactory]
-      # @api private the method is used internally by Stoplight
-      def build
-        LightFactory.new(Wiring::Container).with(**configuration.to_h)
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/fail_safe_data_store.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module Stoplight
-  module Wiring
-    # 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
-    class FailSafeDataStore < Domain::DataStore
-      class << self
-        # Wraps a data store with fail-safe mechanisms.
-        #
-        # @param data_store [Stoplight::DataStore::Base] The data store to wrap.
-        # @param error_notifier [Proc] called when wrapped data store fails
-        # @return [Stoplight::DataStore::Base, FailSafe] The original data store if it is already
-        #   a +Memory+ or +FailSafe+ instance, otherwise a new +FailSafe+ instance.
-        def wrap(data_store:, error_notifier:)
-          case data_store
-          in Infrastructure::DataStore::Memory
-            data_store
-          in self if data_store.error_notifier == error_notifier
-            data_store
-          in self
-            new(data_store: data_store.data_store, error_notifier:)
-          else
-            new(data_store:, error_notifier:)
-          end
-        end
-      end
-
-      # @!attribute data_store
-      #  @return [Stoplight::DataStore::Base] The underlying primary data store being used
-      attr_reader :data_store
-
-      # @!attribute error_notifier
-      #   @return [Proc]
-      attr_reader :error_notifier
-
-      # @!attribute failover_data_store
-      #   @return [Stoplight::DataStore::Base] The fallback data store used when the primary fails.
-      private attr_reader :failover_data_store
-
-      # @!attribute circuit_breaker
-      #   @return [Stoplight::Light] The circuit breaker used to handle data store failures.
-      private attr_reader :circuit_breaker
-
-      # @param data_store [Stoplight::Domain::DataStore]
-      # @param error_notifier [Proc]
-      def initialize(data_store:, error_notifier:, failover_data_store: Wiring::Default::DATA_STORE)
-        @data_store = data_store
-        @error_notifier = error_notifier
-        @failover_data_store = failover_data_store
-        @circuit_breaker = Stoplight.system_light("data_store:fail_safe:#{data_store.class.name}")
-      end
-
-      def names
-        with_fallback(:names) do
-          data_store.names
-        end
-      end
-
-      def get_metrics(config, *args, **kwargs)
-        with_fallback(:get_metrics, config, *args, **kwargs) do
-          data_store.get_metrics(config, *args, **kwargs)
-        end
-      end
-
-      def get_recovery_metrics(config, *args, **kwargs)
-        with_fallback(:get_recovery_metrics, config, *args, **kwargs) do
-          data_store.get_recovery_metrics(config, *args, **kwargs)
-        end
-      end
-
-      def get_state_snapshot(config)
-        with_fallback(:get_state_snapshot, config) do
-          data_store.get_state_snapshot(config)
-        end
-      end
-
-      def clear_windowed_metrics(config)
-        with_fallback(:clear_windowed_metrics, config) do
-          data_store.clear_windowed_metrics(config)
-        end
-      end
-
-      def record_failure(config, *args, **kwargs)
-        with_fallback(:record_failure, config, *args, **kwargs) do
-          data_store.record_failure(config, *args, **kwargs)
-        end
-      end
-
-      def record_success(config, *args, **kwargs)
-        with_fallback(:record_success, config, *args, **kwargs) do
-          data_store.record_success(config, *args, **kwargs)
-        end
-      end
-
-      def record_recovery_probe_success(config, *args, **kwargs)
-        with_fallback(:record_recovery_probe_success, config, *args, **kwargs) do
-          data_store.record_recovery_probe_success(config, *args, **kwargs)
-        end
-      end
-
-      def record_recovery_probe_failure(config, *args, **kwargs)
-        with_fallback(:record_recovery_probe_failure, config, *args, **kwargs) do
-          data_store.record_recovery_probe_failure(config, *args, **kwargs)
-        end
-      end
-
-      def set_state(config, *args, **kwargs)
-        with_fallback(:set_state, config, *args, **kwargs) do
-          data_store.set_state(config, *args, **kwargs)
-        end
-      end
-
-      def transition_to_color(config, *args, **kwargs)
-        with_fallback(:transition_to_color, config, *args, **kwargs) do
-          data_store.transition_to_color(config, *args, **kwargs)
-        end
-      end
-
-      def delete_light(config, *args, **kwargs)
-        with_fallback(:delete_light, config, *args, **kwargs) do
-          data_store.delete_light(config, *args, **kwargs)
-        end
-      end
-
-      def ==(other)
-        other.is_a?(self.class) && other.data_store == data_store && other.error_notifier == error_notifier
-      end
-
-      # @param method_name [Symbol] protected method name
-      private def with_fallback(method_name, *args, **kwargs, &code)
-        fallback = proc do |error|
-          config = args.first
-          error_notifier.call(error) if config && error
-          @failover_data_store.public_send(method_name, *args, **kwargs)
-        end
-
-        circuit_breaker.run(fallback, &code)
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/fail_safe_notifier.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    # A wrapper around a notifier that provides fail-safe mechanisms using a
-    # circuit breaker. It ensures that a notification can gracefully
-    # handle failures.
-    #
-    # @api private
-    class FailSafeNotifier < Domain::StateTransitionNotifier
-      # @!attribute [r] notifier
-      #   @return [Stoplight::Domain::StateTransitionNotifier] The underlying notifier being wrapped.
-      attr_reader :notifier
-
-      # @!attribute [r] error_notifier
-      #   @return [Stoplight::Domain::StateTransitionNotifier] The underlying notifier being wrapped.
-      attr_reader :error_notifier
-
-      class << self
-        # Wraps a notifier with fail-safe mechanisms.
-        #
-        # @param notifier [Stoplight::Domain::StateTransitionNotifier] The notifier to wrap.
-        # @param error_notifier [Proc] called when wrapped data store fails
-        # @return [Stoplight::Notifier::FailSafe] The original notifier if it is already
-        #   a +FailSafe+ instance, otherwise a new +FailSafe+ instance.
-        def wrap(notifier:, error_notifier:)
-          case notifier
-          in self if notifier.error_notifier == error_notifier
-            notifier
-          in self
-            new(notifier: notifier.notifier, error_notifier:)
-          else
-            new(notifier:, error_notifier:)
-          end
-        end
-      end
-
-      # Initializes a new instance of the +FailSafe+ class.
-      #
-      # @param notifier [Stoplight::Domain::StateTransitionNotifier] The notifier to wrap.
-      # @param error_notifier [Proc] called when wrapped data store fails
-      def initialize(notifier:, error_notifier:)
-        @notifier = notifier
-        @error_notifier = error_notifier
-      end
-
-      # Sends a notification using the wrapped notifier with fail-safe mechanisms.
-      #
-      # @param config [Stoplight::Domain::Config] The light configuration.
-      # @param from_color [String] The initial color of the light.
-      # @param to_color [String] The target color of the light.
-      # @param error [Exception, nil] An optional error to include in the notification.
-      # @return [void]
-      def notify(config, from_color, to_color, error = nil)
-        fallback = proc do |exception|
-          error_notifier.call(exception) if exception
-          nil
-        end
-
-        circuit_breaker.run(fallback) do
-          notifier.notify(config, from_color, to_color, error)
-        end
-      end
-
-      # @return [Boolean]
-      def ==(other)
-        other.is_a?(self.class) && notifier == other.notifier
-      end
-
-      # @return [Stoplight::Light] The circuit breaker used to handle failures.
-      private def circuit_breaker
-        @circuit_breaker ||= Stoplight.system_light(
-          "stoplight:notifier:fail_safe:#{notifier.class.name}",
-          notifiers: []
-        )
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/light/default_config.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    module Light
-      # Provides default settings for the Stoplight library.
-      # @api private
-      DefaultConfig = Domain::Config.empty.with(
-        cool_off_time: Default::COOL_OFF_TIME,
-        threshold: Default::THRESHOLD,
-        recovery_threshold: Default::RECOVERY_THRESHOLD,
-        window_size: Default::WINDOW_SIZE,
-        tracked_errors: Default::TRACKED_ERRORS,
-        skipped_errors: Default::SKIPPED_ERRORS
-      )
-    end
-  end
-end

data/lib/stoplight/wiring/light/system_config.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    module Light
-      SystemConfig = DefaultConfig.with(
-        recovery_threshold: 3
-      )
-    end
-  end
-end

data/lib/stoplight/wiring/public_api.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    # Public API facade for backward compatibility and convenience
-    # @api public
-    module PublicApi
-      # Aliases for domain concepts
-      Color = Domain::Color
-      Error = Domain::Error
-      State = Domain::State
-
-      # Namespace aliases for data stores
-      module DataStore
-        Redis = Infrastructure::DataStore::Redis
-        Memory = Infrastructure::DataStore::Memory
-      end
-
-      # Namespace aliases for notifiers
-      module Notifier
-        Base = Domain::StateTransitionNotifier
-        Generic = Infrastructure::Notifier::Generic
-        IO = Infrastructure::Notifier::IO
-        Logger = Infrastructure::Notifier::Logger
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/system_container.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    SystemContainer = Container.with(
-      traffic_recovery: Domain::TrafficRecovery::ConsecutiveSuccesses.new
-    )
-  end
-end

data/lib/stoplight/wiring/system_light_factory.rb

@@ -1,17 +0,0 @@
-# frozon_string_literal: true
-
-module Stoplight
-  module Wiring
-    # Factory for internal system lights used by the Stoplight itself.
-    #
-    # System lights are isolated from user configuration to prevent
-    # user settings from breaking the library's own circuit breakers.
-    # For example, the FailSafe data store wrapper uses a system light
-    # to protect against data store failures.
-    #
-    # @api private
-    SystemLightFactory = Wiring::LightFactory.new(
-      Wiring::SystemContainer.with(config: Light::SystemConfig)
-    )
-  end
-end