stoplight 5.8.3 → 6.0.0.rc2

data/lib/stoplight/infrastructure/redis/storage/key_space.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-
-module Stoplight
-  module Infrastructure
-    module Redis
-      module Storage
-        # Immutable key namespace for a light within a system.
-        #
-        # Produces keys following entity-first structure:
-        #   stoplight:v6:{system_id}:{light_id}:locks:recovery
-        #   stoplight:v6:{system_id}:{light_id}:metrics:successes
-        #   stoplight:v6:{system_id}:{light_id}:state
-        #
-        # Identifiers are derived from SHA-256 and truncated to 12 characters. Collisions are extremely
-        # unlikely at expected system scale.
-        #
-        # @example
-        #   key_space = KeySpace.build(system_name: "payments", light_name: "stripe-api")
-        #   key_space.key(:locks, :recovery)  #=> "stoplight:v6:df384ae97c77:cfe6861fa39e:locks:recovery"
-        #
-        KeySpace = Data.define(:system_id, :light_id)
-
-        class KeySpace
-          # @!attribute system_id
-          #   12-char hex identifier for the system
-          #
-          # @!attribute light_id
-          #   12-char hex identifier for the light
-
-          class << self
-            def build(system_name:, light_name:) = new(
-              system_id: hash_name(system_name),
-              light_id: hash_name(light_name)
-            )
-
-            # Generates a truncated SHA256 hash for use in Redis keys.
-            def hash_name(name) = Digest::SHA256.hexdigest(name.to_s)[0, 12] #: String
-          end
-
-          # Builds a Redis key within this namespace.
-          #
-          # @param pieces  Key segments to append
-          # @return  Full Redis key
-          def key(*pieces) = [:stoplight, :v5, system_id, "{#{light_id}}", *pieces].join(":")
-        end
-      end
-    end
-  end
-end

data/lib/stoplight/infrastructure/storage/compatibility_metrics.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module Storage
-      # Temporary adapter that bridges Domain::Storage::Metrics to existing DataStore.
-      #
-      # This compatibility layer allows the metrics abstraction to be introduced
-      # without breaking existing data store implementations. It delegates all
-      # operations to the data store's original methods.
-      #
-      # This class will be removed in a future versions once all data stores
-      # have native metrics implementations.
-      #
-      # @example Creating metrics for a circuit
-      #   metrics = CompatibilityMetrics.new(
-      #     data_store: redis_store,
-      #     config: config
-      #   )
-      #   metrics.record_success
-      #
-      class CompatibilityMetrics
-        attr_reader :data_store
-        attr_reader :config
-
-        def initialize(data_store:, config:)
-          @data_store = data_store
-          @config = config
-        end
-
-        def metrics_snapshot = data_store.get_metrics(config)
-
-        def record_success = data_store.record_success(config)
-
-        def record_failure(error) = data_store.record_failure(config, error)
-
-        def clear = data_store.clear_metrics(config)
-      end
-    end
-  end
-end

data/lib/stoplight/infrastructure/storage/compatibility_recovery_lock.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module Storage
-      # Temporary adapter that bridges +Domain::Storage::RecoveryLock+ to existing DataStore.
-      #
-      # This compatibility layer allows the recovery lock abstraction to be
-      # introduced without breaking existing data store implementations. It
-      # delegates all lock operations to the data store's original methods.
-      #
-      # This adapter will be removed in a future versions once all
-      # data stores have native recovery lock implementations.
-      #
-      # @see Stoplight::Domain::_RecoveryLockStore
-      class CompatibilityRecoveryLock
-        def initialize(data_store:, config:)
-          @data_store = data_store
-          @config = config
-        end
-
-        def acquire_lock = data_store.acquire_recovery_lock(config) #: Domain::Storage::RecoveryLockToken?
-
-        def release_lock(lock) = data_store.release_recovery_lock(lock)
-
-        private
-
-        attr_reader :data_store
-        attr_reader :config
-      end
-    end
-  end
-end

data/lib/stoplight/infrastructure/storage/compatibility_recovery_metrics.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module Storage
-      # When a circuit is RED (open), Stoplight periodically sends "recovery probes"
-      # to test whether the protected service has recovered. These test requests have
-      # different semantics than normal requests and their metrics are tracked separately.
-      #
-      # Like +CompatibilityMetrics+, this adapter will be replaced with purpose-built
-      # recovery metrics implementations (e.g., +ConsecutiveSuccessMetrics+) once the
-      # metrics extraction is complete.
-      #
-      # @example Recovery probe flow
-      #   # Circuit is RED, start probing
-      #   recovery_metrics = CompatibilityRecoveryMetrics.new(
-      #     data_store: redis_store,
-      #     config: circuit_config
-      #   )
-      #
-      #   recovery_metrics.record_success
-      #   recovery_metrics.metrics_snapshot # => 1 success, 0 failures
-      #
-      class CompatibilityRecoveryMetrics
-        def initialize(data_store:, config:)
-          @data_store = data_store
-          @config = config
-        end
-
-        def metrics_snapshot = data_store.get_recovery_metrics(config)
-
-        # Tracks successful circuit breaker execution
-        def record_success = data_store.record_recovery_probe_success(config)
-
-        # Tracks failed circuit breaker execution
-        def record_failure(error) = data_store.record_recovery_probe_failure(config, error)
-
-        def clear = data_store.clear_recovery_metrics(config)
-
-        private
-
-        attr_reader :data_store
-        attr_reader :config
-      end
-    end
-  end
-end

data/lib/stoplight/infrastructure/storage/compatibility_state.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module Storage
-      # Temporary adapter that bridges Domain::Storage::State to existing DataStore.
-      #
-      # This compatibility layer allows the state abstraction to be introduced
-      # without breaking existing data store implementations. It delegates all
-      # state operations to the data store's original methods.
-      #
-      # This adapter will be removed in a future versions once all
-      # data stores have native state storage implementations.
-      #
-      # @example Creating state storage for a circuit
-      #   state = CompatibilityState.new(
-      #     data_store: redis_store,
-      #     config: circuit_config
-      #   )
-      #   state.set_state(State::LOCKED_RED)
-      #   snapshot = state.state_snapshot
-      #
-      class CompatibilityState
-        def initialize(data_store:, config:)
-          @data_store = data_store
-          @config = config
-        end
-
-        def state_snapshot = data_store.get_state_snapshot(config)
-
-        def set_state(state) = data_store.set_state(config, state)
-
-        def transition_to_color(color) = data_store.transition_to_color(config, color)
-
-        def clear = data_store.delete_light(config)
-
-        private
-
-        attr_reader :data_store
-        attr_reader :config
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/light_builder.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-
-module Stoplight
-  module Wiring
-    # Constructs a fully-wired Light instance from validated configuration.
-    #
-    # LightBuilder is the final assembly step in the Light creation pipeline.
-    # It receives validated config and dependencies from ConfigurationPipeline
-    # and wires together all infrastructure components (data stores, trackers,
-    # strategies) needed for a functioning circuit breaker.
-    #
-    # LightBuilder maintains a global registry (MEMORY_REGISTRY) that ensures
-    # the same Memory data store config object always produces the same
-    # data store instance:
-    #
-    #   data_store = Stoplight::DataStore::Memory.new
-    #   light1 = Stoplight("foo", data_store: data_store)
-    #   light2 = Stoplight("bar", data_store: data_store)
-    #   # light1 and light2 share the same underlying memory store
-    #
-    #   light3 = Stoplight("baz", data_store: Stoplight::DataStore::Memory.new)
-    #   # light3 has its own independent store
-    #
-    # This singleton behavior is keyed by config object identity (object_id),
-    # not by value equality.
-    #
-    # @api private
-    class LightBuilder
-      FAILOVER_DATA_STORE_CONFIG = Stoplight::DataStore::Memory.new
-      private_constant :FAILOVER_DATA_STORE_CONFIG
-
-      MEMORY_REGISTRY = Concurrent::Map.new
-      private_constant :MEMORY_REGISTRY
-
-      def initialize(config:, factory:)
-        @clock = Infrastructure::SystemClock.new
-        @config = config
-        @name = T.must(config.name)
-        @cool_off_time = config.cool_off_time
-
-        @data_store_config = config.data_store
-        @error_notifier = config.error_notifier
-        @factory = factory
-        @notifiers = config.notifiers
-        @traffic_recovery = config.traffic_recovery
-        @traffic_control = config.traffic_control
-
-        @error_tracking_policy = Domain::ErrorTrackingPolicy.new(
-          tracked: config.tracked_errors,
-          skipped: config.skipped_errors
-        )
-      end
-
-      def build
-        Stoplight::Domain::Light.new(
-          @name,
-          state_store:,
-          green_run_strategy:,
-          yellow_run_strategy:,
-          red_run_strategy:,
-          factory:
-        )
-      end
-
-      private
-
-      attr_reader :data_store_config
-      attr_reader :error_notifier
-      attr_reader :factory
-      attr_reader :clock
-      attr_reader :traffic_control
-      attr_reader :traffic_recovery
-      attr_reader :config
-
-      def state_store = Stoplight::Infrastructure::Storage::CompatibilityState.new(config:, data_store:)
-
-      # @return [<Stoplight::Notifier::Base>]
-      def notifiers
-        Array(@notifiers).map do |notifier|
-          Infrastructure::Notifier::FailSafe.new(notifier:, error_notifier:)
-        end
-      end
-
-      def redis_recovery_lock_store
-        Infrastructure::Redis::DataStore::RecoveryLockStore.new(
-          redis:,
-          lock_timeout: config.cool_off_time_in_milliseconds,
-          scripting:
-        )
-      end
-
-      def scripting = Infrastructure::Redis::DataStore::Scripting.new(redis:)
-
-      def memory_recovery_lock_store
-        Infrastructure::Memory::DataStore::RecoveryLockStore.new
-      end
-
-      def failover_data_store
-        create_data_store(FAILOVER_DATA_STORE_CONFIG)
-      end
-
-      def data_store
-        create_data_store(data_store_config)
-      end
-
-      def metrics_store
-        Stoplight::Infrastructure::Storage::CompatibilityMetrics.new(config:, data_store:)
-      end
-
-      def recovery_lock_store
-        Stoplight::Infrastructure::Storage::CompatibilityRecoveryLock.new(config:, data_store:)
-      end
-
-      def request_tracker
-        Domain::Tracker::Request.new(traffic_control:, notifiers:, config:, metrics_store:, state_store:)
-      end
-
-      def recovery_probe_tracker
-        Domain::Tracker::RecoveryProbe.new(
-          traffic_recovery:,
-          notifiers:,
-          config:,
-          metrics_store: recovery_metrics_store,
-          state_store:
-        )
-      end
-
-      def recovery_metrics_store
-        Stoplight::Infrastructure::Storage::CompatibilityRecoveryMetrics.new(config:, data_store:)
-      end
-
-      def green_run_strategy
-        Domain::Strategies::GreenRunStrategy.new(
-          error_tracking_policy: @error_tracking_policy,
-          request_tracker:
-        )
-      end
-
-      def yellow_run_strategy
-        Domain::Strategies::YellowRunStrategy.new(
-          name: @name,
-          error_tracking_policy: @error_tracking_policy,
-          notifiers:,
-          request_tracker: recovery_probe_tracker,
-          red_run_strategy:,
-          state_store:,
-          metrics_store:,
-          recovery_lock_store:,
-          config: @config
-        )
-      end
-
-      def red_run_strategy
-        Domain::Strategies::RedRunStrategy.new(name: @name, cool_off_time: @cool_off_time)
-      end
-
-      def create_data_store(data_store_config)
-        case data_store_config
-        when Stoplight::DataStore::Memory
-          memory_registry.compute_if_absent(data_store_config.object_id) do
-            Infrastructure::Memory::DataStore.new(
-              recovery_lock_store: memory_recovery_lock_store,
-              clock:
-            )
-          end
-        when Stoplight::DataStore::Redis
-          Infrastructure::FailSafe::DataStore.new(
-            data_store: Stoplight::Infrastructure::Redis::DataStore.new(
-              clock:,
-              redis: data_store_config.redis,
-              warn_on_clock_skew: data_store_config.warn_on_clock_skew,
-              recovery_lock_store: redis_recovery_lock_store,
-              scripting:
-            ),
-            error_notifier:,
-            failover_data_store:,
-            circuit_breaker: Stoplight.system_light("data_store:fail_safe:redis")
-          )
-        else
-          raise NoMatchingPatternError, data_store_config
-        end
-      end
-
-      def redis
-        case data_store_config
-        when DataStore::Redis
-          data_store_config.redis
-        else
-          raise TypeError, "Expected Stoplight::DataStore::Redis, got #{data_store_config.class}"
-        end
-      end
-
-      def memory_registry = MEMORY_REGISTRY
-    end
-  end
-end

data/lib/stoplight/wiring/notifier_factory.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    class NotifierFactory
-      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 create(notifier:, error_notifier:)
-          case notifier
-          in Infrastructure::Notifier::FailSafe if notifier.error_notifier == error_notifier
-            notifier
-          in Infrastructure::Notifier::FailSafe
-            Infrastructure::Notifier::FailSafe.new(notifier: notifier.notifier, error_notifier:)
-          else
-            Infrastructure::Notifier::FailSafe.new(notifier:, error_notifier:)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/system/light_builder.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    class System
-      class LightBuilder < Wiring::LightBuilder
-        def initialize(system:, config:, factory:)
-          @system = system
-
-          super(config:, factory:)
-        end
-
-        def key_space = @key_space ||= Infrastructure::Redis::Storage::KeySpace.build(
-          system_name: system.name,
-          light_name: config.name
-        )
-
-        def storage_set
-          @storage_set ||= StorageSetBuilder.new(backend: build_backend, windowed: !config.window_size.nil?).build
-        end
-
-        private
-
-        attr_reader :system
-
-        def state_store = storage_set.state_store
-        def recovery_lock_store = storage_set.recovery_lock_store
-        def recovery_metrics_store = storage_set.recovery_metrics_store
-        def metrics_store = storage_set.metrics_store
-        def storage_scripting = Infrastructure::Redis::Storage::Scripting.new(redis:)
-        def failover_system = @failover_system ||= Stoplight.__stoplight__system("failover-#{system.name}")
-
-        def build_backend
-          case data_store_config
-          in DataStore::Memory
-            Memory::Backend.new(clock:, config:)
-          in DataStore::Redis
-            Redis::Backend.new(
-              redis:, scripting: storage_scripting, key_space:, clock:, config:, error_notifier:,
-              failover_light: failover_system.light("redis")
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stoplight/wiring/system/light_factory.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Wiring
-    class System
-      class LightFactory < Wiring::LightFactory
-        attr_reader :system
-
-        def initialize(system:, config:)
-          @system = system
-
-          super(config:)
-        end
-
-        def with(
-          name: T.undefined,
-          cool_off_time: T.undefined,
-          threshold: T.undefined,
-          recovery_threshold: T.undefined,
-          window_size: T.undefined,
-          tracked_errors: T.undefined,
-          skipped_errors: T.undefined,
-          data_store: T.undefined,
-          error_notifier: T.undefined,
-          notifiers: T.undefined,
-          traffic_control: T.undefined,
-          traffic_recovery: T.undefined
-        )
-          self.class.new(
-            system:,
-            config: ConfigurationDsl.new(
-              cool_off_time:,
-              threshold:,
-              recovery_threshold:,
-              window_size:,
-              tracked_errors:,
-              skipped_errors:,
-              traffic_control:,
-              traffic_recovery:,
-              error_notifier:,
-              data_store:,
-              notifiers:
-            ).configure!(config)
-          )
-        end
-
-        class InternalLightFactory < Wiring::LightFactory
-          def initialize
-          end
-
-          def with(**untyped) # steep:ignore
-            raise NotImplementedError, "You're not allowed to extend system lights"
-          end
-        end
-
-        private def light_builder(config:)
-          System::LightBuilder.new(system:, factory: light_factory, config:)
-        end
-
-        private def light_factory = InternalLightFactory.new
-      end
-    end
-  end
-end

data/sig/_private/stoplight/domain/light.rbs

@@ -1,25 +0,0 @@
-module Stoplight
-  module Domain
-    class Light
-      include _Light
-      attr_reader green_run_strategy: Strategies::GreenRunStrategy
-      attr_reader yellow_run_strategy: Strategies::YellowRunStrategy
-      attr_reader red_run_strategy: Strategies::RedRunStrategy
-      attr_reader state_store: Domain::_StateStore
-      attr_reader factory: _LightFactory
-      @name: String
-
-      def initialize: (
-        String name,
-        green_run_strategy: Strategies::GreenRunStrategy,
-        yellow_run_strategy: Strategies::YellowRunStrategy,
-        red_run_strategy: Strategies::RedRunStrategy,
-        factory: _LightFactory,
-        state_store: Domain::_StateStore
-      ) -> void
-
-      private def state_strategy_factory: (color) -> _RunStrategy
-      private def state_snapshot: -> StateSnapshot
-    end
-  end
-end

data/sig/_private/stoplight/domain/ports/data_store.rbs

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Domain
-    interface _DataStore
-      # Retrieves the names of all lights stored in the data store.
-      #
-      # @return An array of light names.
-      def names: -> Array[String]
-
-      # Retrieves metrics for a specific light configuration.
-      def get_metrics: (Config) -> Domain::MetricsSnapshot
-
-      # Retrieves recovery metrics for a specific light configuration.
-      def get_recovery_metrics: (Config) -> Domain::MetricsSnapshot
-
-      # Retrieves State Snapshot for a specific light configuration.
-      def get_state_snapshot: (Config) -> StateSnapshot
-
-      # Clears windowed metrics (successes/errors) to prevent
-      # stale failures from before recovery from affecting post-recovery decisions.
-      # Consecutive counts are intentionally preserved as they track current streaks.
-      def clear_metrics: (Config) -> void
-
-      def clear_recovery_metrics: (Config) -> void
-
-      # Records a failure for a specific light configuration.
-      def record_failure: (Config, StandardError exception) -> void
-
-      # Records a success for a specific light configuration.
-      def record_success: (Config) -> void
-
-      # Records a failed recovery probe for a specific light configuration.
-      def record_recovery_probe_failure: (Config, StandardError exception) -> void
-
-      # Records a successful recovery probe for a specific light configuration.
-      def record_recovery_probe_success: (Config) -> void
-
-      # Sets the state of a specific light configuration.
-      def set_state: (Config, state state) -> state
-
-      # Acquires recovery lock for serializing probe execution.
-      def acquire_recovery_lock: (Config) -> _RecoveryLockToken?
-
-      # Releases previously acquired lock.
-      def release_recovery_lock: (_RecoveryLockToken lock) -> void
-
-      # Transitions the Stoplight to the specified color.
-      #
-      # This method performs a color transition operation that works across distributed instances
-      # of the light. It ensures that in a multi-instance environment, only one instance
-      # is considered the "first" to perform the transition (and therefore responsible for
-      # triggering notifications).
-      #
-      # @param config
-      # @param color The target color/state to transition to.
-      #   Should be one of Stoplight::Color::GREEN, Stoplight::Color::YELLOW, or Stoplight::Color::RED.
-      #
-      # @return [Boolean] Returns +true+ if this instance was the first to perform this specific transition
-      #   (and should therefore trigger notifications). Returns +false+ if another instance already
-      #   initiated this transition.
-      #
-      # @note In distributed environments with multiple instances, race conditions can occur when instances
-      #   attempt conflicting transitions simultaneously (e.g., one instance tries to transition from
-      #   YELLOW to GREEN while another tries YELLOW to RED). The implementation handles this, but
-      #   be aware that the last operation may determine the final color of the light.
-      #
-      def transition_to_color: (Config, color color) -> bool
-
-      # Deletes metadata (and related persistent state) for the given light.
-      #
-      # Implementations may choose to only remove metadata; metrics may expire via TTL.
-      def delete_light: (Config) -> void
-    end
-  end
-end