stoplight 5.8.3 → 6.0.0.rc2

data/lib/stoplight/wiring/{configuration_dsl.rb → system_configuration_dsl.rb}

@@ -2,9 +2,9 @@
 
 module Stoplight
   module Wiring
-    class ConfigurationDsl
+    class SystemConfigurationDsl
       def initialize(
-        name: T.undefined,
+        name,
         cool_off_time: T.undefined,
         threshold: T.undefined,
         recovery_threshold: T.undefined,
@@ -17,15 +17,16 @@ module Stoplight
         traffic_control: T.undefined,
         traffic_recovery: T.undefined
       )
-        @name = name
+        @name = name.to_s
+        @id = Domain::Id.for(@name)
         @cool_off_time = cool_off_time
         @threshold = threshold
         @recovery_threshold = recovery_threshold
         @window_size = window_size
-        @tracked_errors = tracked_errors
-        @skipped_errors = skipped_errors
-        @traffic_control = traffic_control
-        @traffic_recovery = traffic_recovery
+        @tracked_errors = (tracked_errors.is_a?(Undefined) || tracked_errors.is_a?(Array)) ? tracked_errors : [tracked_errors]
+        @skipped_errors = (skipped_errors.is_a?(Undefined) || skipped_errors.is_a?(Array)) ? skipped_errors : [skipped_errors]
+        @traffic_control = traffic_control.is_a?(Undefined) ? traffic_control : LightConfigurationDsl::TrafficControlDsl.call(traffic_control)
+        @traffic_recovery = traffic_recovery.is_a?(Undefined) ? traffic_recovery : LightConfigurationDsl::TrafficRecoveryDsl.call(traffic_recovery)
         @error_notifier = error_notifier
         @data_store = data_store
         @notifiers = notifiers
@@ -34,6 +35,7 @@ module Stoplight
       def configure!(default_config)
         ConfigCompatibilityValidator.call(
           config: default_config.with(
+            id: @id,
             name:,
             cool_off_time:,
             threshold:,
@@ -60,42 +62,10 @@ module Stoplight
       attr_reader :error_notifier
       attr_reader :data_store
       attr_reader :notifiers
-
-      def tracked_errors
-        value = @tracked_errors
-        if value.is_a?(Undefined)
-          value
-        else
-          Array(value)
-        end
-      end
-
-      def skipped_errors
-        value = @skipped_errors
-        if value.is_a?(Undefined)
-          value
-        else
-          Array(value)
-        end
-      end
-
-      def traffic_control
-        value = @traffic_control
-        if value.is_a?(Undefined)
-          value
-        else
-          LightFactory::TrafficControlDsl.call(value)
-        end
-      end
-
-      def traffic_recovery
-        value = @traffic_recovery
-        if value.is_a?(Undefined)
-          value
-        else
-          LightFactory::TrafficRecoveryDsl.call(value)
-        end
-      end
+      attr_reader :tracked_errors
+      attr_reader :skipped_errors
+      attr_reader :traffic_control
+      attr_reader :traffic_recovery
     end
   end
 end

data/lib/stoplight.rb

@@ -21,13 +21,11 @@ module Stoplight # rubocop:disable Style/Documentation
 
   CONFIG_MUTEX = Mutex.new
   private_constant :CONFIG_MUTEX
-  @systems = Concurrent::Map.new
 
   class << self
     # Configures the Stoplight library.
     #
     # This method allows you to set up the library's configuration using a block.
-    # It raises an error if called more than once.
     # @param trust_me_im_an_engineer [Boolean]
     # @yield [config] Provides a configuration object to the block.
     # @yieldparam config [Stoplight::Wiring::DefaultConfiguration] The configuration object.
@@ -48,8 +46,7 @@ module Stoplight # rubocop:disable Style/Documentation
     #   it will not be possible to change the configuration of existing circuit breakers. If you do so, the method
     #   produces a warning:
     #
-    #     "Stoplight reconfigured. Existing circuit breakers will not see the new configuration. New
-    #       configuration: ...f
+    #     "Stoplight reconfigured. Existing circuit breakers will not see new configuration"
     #
     #   If you really know what you are doing, you can pass the +trust_me_im_an_engineer+ parameter as +true+ to
     #   suppress this warning, which could be useful in test environments.
@@ -59,86 +56,42 @@ module Stoplight # rubocop:disable Style/Documentation
         configuration = Wiring::DefaultConfiguration.new
         yield configuration if block_given?
 
-        default_config = configuration.to_config!
-        @default_config = default_config
-        @default_light_factory = Wiring::LightFactory.new(config: default_config)
+        @state = Wiring::GlobalState.new(default_config: configuration.to_config!)
       end
     end
 
-    # @api private
-    def system_light(
-      name,
-      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
-    )
-      Wiring::LightFactory.new(config: Wiring::DefaultConfig).build_with(
-        name: "__stoplight__#{name}",
-        cool_off_time:,
-        threshold:,
-        recovery_threshold:,
-        window_size:,
-        tracked_errors:,
-        skipped_errors:,
-        data_store:,
-        error_notifier:,
-        notifiers:,
-        traffic_control:,
-        traffic_recovery:
-      )
-    end
+    # Registers a Light with the given configuration.
+    #
+    # If a light with this name is already registered, returns it. If the given settings
+    # differ from the existing registration, raises +Stoplight::Error::ConfigurationError+.
+    # #
+    # @example
+    #   Stoplight.register("stripe", threshold: 5, cool_off_time: 60)
+    #
+    def register(...) = state.default_system.register(...)
 
-    # Create a Light with the user default configuration.
+    # Returns a Light previously registered.
     #
-    # @return [Stoplight::Light]
-    # @api private
-    def light(
-      name,
-      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
-    )
-      __stoplight__default_light_factory.build_with(
-        name:,
-        cool_off_time:,
-        threshold:,
-        recovery_threshold:,
-        window_size:,
-        tracked_errors:,
-        skipped_errors:,
-        data_store:,
-        error_notifier:,
-        notifiers:,
-        traffic_control:,
-        traffic_recovery:
-      )
-    end
+    # @raise [Stoplight::Error::UnregisteredLightError] if no light was registered under +name+
+    #
+    # @example
+    #   Stoplight.register("stripe", threshold: 5)
+    #   Stoplight.light("stripe")
+    #
+    def light(...) = state.default_system.light(...)
+
+    # Returns the consumer side of the default system's telemetry bus.
+    #
+    # @example
+    #   Stoplight.telemetry.subscribe(Stoplight::Telemetry::RunCompleted) { |envelope| track(envelope) }
+    #
+    def telemetry = state.default_system.telemetry
 
     # Creates a new named system with the given configuration.
     #
     # Systems are composition roots that own infrastructure (data store, notifiers)
     # and enforce configuration consistency for all lights created within them.
     #
-    # @param name [String] Unique identifier for the system
-    # @param settings [Hash] Configuration options that override global defaults.
-    #   @see Stoplight() documentation
-    #
     # @return [Stoplight::Wiring::System] A new system instance.
     #
     # @raise [ArgumentError] If a system with the given name already exists.
@@ -147,55 +100,14 @@ module Stoplight # rubocop:disable Style/Documentation
     #   for repeated access. Calling this method twice with the same name raises an error.
     #
     # @example Creating a system for payment services
-    #   Payments = Stoplight.__stoplight__system(:payments, threshold: 3, cool_off_time: 30)
+    #   Payments = Stoplight.register_system("Payments", threshold: 3, cool_off_time: 30)
+    #   Payments.register("stripe")
     #   Payments.light("stripe").run { process_payment }
     #
     # @example Isolated system with dedicated data store
-    #   Analytics = Stoplight.__stoplight__system(:analytics, data_store: analytics_redis)
+    #   Analytics = Stoplight.register_system("Analytics", data_store: analytics_redis)
     #
-    # @api private
-    def __stoplight__system(
-      name,
-      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
-    )
-      ensure_configured
-
-      systems.compute(name.to_s) do |existing_system|
-        if existing_system
-          raise ArgumentError, "system `#{name}` is already in use"
-        else
-          Wiring::System.new(
-            config: Wiring::ConfigurationDsl.new(
-              name: name.to_s,
-              cool_off_time:,
-              threshold:,
-              recovery_threshold:,
-              window_size:,
-              tracked_errors:,
-              skipped_errors:,
-              traffic_control:,
-              traffic_recovery:,
-              data_store:,
-              error_notifier:,
-              notifiers:
-            ).configure!(default_config)
-          )
-        end
-      end
-    end
-
-    private attr_reader :systems
-    private def default_config = T.must(@default_config)
+    def register_system(...) = state.register_system(...)
 
     # Resets Stoplight to an unconfigured state.
     #
@@ -221,28 +133,16 @@ module Stoplight # rubocop:disable Style/Documentation
     #
     # @api private
     def __stoplight__reset!
-      @systems = Concurrent::Map.new
-      @default_config = nil
-      @default_light_factory = nil
-      @configured = nil
-    end
-
-    # Retrieves the current default dependencies.
-    #
-    # @return [Stoplight::Domain::LightFactory]
-    # @api private
-    def __stoplight__default_light_factory
-      ensure_configured
-      T.must(@default_light_factory)
+      @state = nil
     end
 
-    def __stoplight__default_configuration
-      ensure_configured
-      T.must(@default_config)
-    end
+    def __stoplight__default_configuration = state.default_config
+    def __stoplight__default_system = state.default_system
 
     # @api private
     private def ensure_configured
+      return if configured?
+
       CONFIG_MUTEX.synchronize do
         configure unless configured?
       end
@@ -253,38 +153,36 @@ module Stoplight # rubocop:disable Style/Documentation
         warn "Stoplight reconfigured. Existing circuit breakers will not see new configuration"
       end
       yield
-      @configured = true
     end
 
     private def configured?
-      @configured == true
+      @state != nil
+    end
+
+    private def state
+      ensure_configured
+      T.must(@state)
     end
   end
 end
 
-# Creates a new Stoplight circuit brNeaker with the given name and settings.
+# Creates a new Stoplight circuit breaker with the given name and settings.
 #
 # @param name [String] The name of the circuit breaker.
-# @param settings [Hash] Optional settings to configure the circuit breaker.
-#   @option settings [Numeric] :cool_off_time The time to wait before resetting the circuit breaker.
-#   @option settings [Stoplight::DataStore::Base] :data_store The data store to use for storing state.
-#   @option settings [Array<Stoplight::Notifier::Base>] :notifiers A list of notifiers to use.
-#   @option settings [Numeric] :threshold The failure threshold to trip the circuit breaker.
-#   @option settings [Numeric] :window_size The size of the rolling window for failure tracking.
-#   @option settings [Array<StandardError>] :tracked_errors A list of errors to track.
-#   @option settings [Array<Exception>] :skipped_errors A list of errors to skip.
-#   @option settings [Symbol, {Symbol, Hash{Symbol, any}}] :traffic_control The
-#     traffic control strategy to use.
+# @param cool_off_time The time to wait before resetting the circuit breaker, in whole seconds, at least 1.
+# @param threshold The failure threshold to trip the circuit breaker.
+# @param window_size The size of the rolling window for failure tracking, in whole seconds, at least 1.
+# @param tracked_errors A list of errors to track.
+# @param skipped_errors A list of errors to skip.
+# @param traffic_control The traffic control strategy to use.
 #
 # @return [Stoplight::Light] A new circuit breaker instance.
 # @raise [ArgumentError] If an unknown option is provided in the settings.
+# @raise [Stoplight::Error::ConfigurationError] If a setting is invalid or conflicts with an earlier registration.
 #
 # @example configure circuit breaker behavior
 #   light = Stoplight("Payment API", window_size: 300, threshold: 5, cool_off_time: 60)
 #
-# @example configure data store
-#   light = Stoplight("Payment API", data_store: Stoplight::DataStore::Redis.new(redis_client))
-#
 # In the example below, 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+.
@@ -306,46 +204,4 @@ end
 #   # When 66.6% error rate reached withing a sliding 5 minute window, the circuit breaker will trip.
 #   light = Stoplight("Payment API", traffic_control: :error_rate, threshold: 0.666, window_size: 300)
 #
-def Stoplight(
-  name,
-  cool_off_time: Stoplight::T.undefined,
-  threshold: Stoplight::T.undefined,
-  recovery_threshold: Stoplight::T.undefined,
-  window_size: Stoplight::T.undefined,
-  tracked_errors: Stoplight::T.undefined,
-  skipped_errors: Stoplight::T.undefined,
-  data_store: Stoplight::T.undefined,
-  error_notifier: Stoplight::T.undefined,
-  notifiers: Stoplight::T.undefined,
-  traffic_control: Stoplight::T.undefined,
-  traffic_recovery: Stoplight::T.undefined
-) # rubocop:disable Naming/MethodName
-  Stoplight::Common::Deprecations.deprecate(<<~MSG) if error_notifier != Stoplight::T.undefined
-    Passing "error_notifier" to Stoplight('#{name}') is deprecated and will be removed in v6.0.0.
-
-    IMPORTANT: The `error_notifier` is NOT called for exceptions in your protected code.
-    It only reports internal Stoplight failures (e.g., Redis connection errors).
-
-    To fix: Move `error_notifier` to global configuration:
-
-      Stoplight.configure do |config|
-        config.error_notifier = ->(error) { Logger.warn(error) }
-      end
-
-    See: https://github.com/bolshakov/stoplight#error-notifiers
-  MSG
-  Stoplight.light(
-    name,
-    cool_off_time:,
-    threshold:,
-    recovery_threshold:,
-    window_size:,
-    tracked_errors:,
-    skipped_errors:,
-    data_store:,
-    error_notifier:,
-    notifiers:,
-    traffic_control:,
-    traffic_recovery:
-  )
-end
+def Stoplight(...) = Stoplight.register(...) # rubocop:disable Naming/MethodName

data/sig/sinatra/base.rbs

@@ -0,0 +1,6 @@
+module Sinatra
+  class Base
+    # TODO: temporarily fix https://github.com/ruby/gem_rbs_collection/pull/1057
+    def erb: (untyped template, ?::Hash[untyped, untyped] options, ?::Hash[untyped, untyped] locals) ?{ () -> untyped } -> untyped
+  end
+end

data/sig/stdlib/securerandom.rbs

@@ -0,0 +1,4 @@
+module SecureRandom
+  def self.uuid: () -> String
+  def self.hex: (Integer) -> String
+end

data/sig/stoplight/admin/actions/action.rbs

@@ -0,0 +1,10 @@
+
+module Stoplight
+  class Admin
+    module Actions
+      class Action
+        def halt: (Integer status) -> void
+      end
+    end
+  end
+end

data/sig/stoplight/admin/actions/lock.rbs

@@ -0,0 +1,17 @@
+module Stoplight
+  class Admin
+    module Actions
+      class Lock < Action
+        @config_registry: ConfigRegistry
+        @storage: Wiring::System::Storage
+
+        def initialize: (
+            config_registry: ConfigRegistry,
+            storage: Wiring::System::Storage
+          ) -> void
+
+        def call: (light_id: String, color: Domain::color) -> void
+      end
+    end
+  end
+end

data/sig/stoplight/admin/actions/lock_all.rbs

@@ -0,0 +1,17 @@
+module Stoplight
+  class Admin
+    module Actions
+      class LockAll < Action
+        @config_registry: ConfigRegistry
+        @storage: Wiring::System::Storage
+
+        def initialize: (
+            config_registry: ConfigRegistry,
+            storage: Wiring::System::Storage
+          ) -> void
+
+        def call: (color: Domain::color)-> void
+      end
+    end
+  end
+end

data/sig/stoplight/admin/actions/remove.rbs

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Stoplight
+  class Admin
+    module Actions
+      # This action removes a light's metadata from Redis
+      class Remove < Action
+        @config_registry: ConfigRegistry
+        @storage: Wiring::System::Storage
+        @registry: Domain::_Registry
+
+        def initialize: (
+            config_registry: ConfigRegistry,
+            storage: Wiring::System::Storage,
+            registry: Domain::_Registry
+          ) -> void
+
+        def call: (light_id: String) -> void
+      end
+    end
+  end
+end

data/sig/stoplight/admin/actions/stats.rbs

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Stoplight
+  class Admin
+    module Actions
+      class Stats < Action
+        @lights_stats: singleton(Stoplight::Admin::LightsStats)
+        @config_registry: ConfigRegistry
+        @storage: Wiring::System::Storage
+
+        # @param lights_stats [Class<Stoplight::Admin::LightsStats>]
+        def initialize: (
+            lights_stats: singleton(Stoplight::Admin::LightsStats),
+            config_registry: ConfigRegistry,
+            storage: Wiring::System::Storage,
+          ) -> void
+
+        # @return [(Stoplight::Admin::LightView)]
+        def call: -> [
+          Array[LightView],
+          Hash[Symbol, Integer],
+        ]
+
+        private def build_light: (Domain::Config) -> LightView
+      end
+    end
+  end
+end

data/sig/stoplight/admin/actions/unlock.rbs

@@ -0,0 +1,17 @@
+module Stoplight
+  class Admin
+    module Actions
+      class Unlock < Action
+        @config_registry: ConfigRegistry
+        @storage: Wiring::System::Storage
+
+        def initialize: (
+            config_registry: ConfigRegistry,
+            storage: Wiring::System::Storage
+          ) -> void
+
+        def call: (light_id: String) -> void
+      end
+    end
+  end
+end

data/sig/stoplight/admin/config_registry.rbs

@@ -0,0 +1,20 @@
+module Stoplight
+  class Admin
+    class ConfigRegistry
+      @registry: Domain::_Registry
+      @system_config: Domain::Config
+
+      def initialize: (
+          registry: Domain::_Registry,
+          system_config: Domain::Config
+        ) -> void
+
+      def all: -> Array[Domain::Config]
+      def find_by_id: (String) -> Domain::Config?
+
+      private
+
+      def deserialize_config: (Hash[String, untyped]) -> Domain::Config
+    end
+  end
+end

data/sig/stoplight/admin/dependencies.rbs

@@ -0,0 +1,16 @@
+module Stoplight
+  class Admin
+    class Dependencies
+      @system: Wiring::System
+      @storage: Wiring::System::Storage
+
+      def initialize: (system: Wiring::System) -> void
+      def config_registry: -> ConfigRegistry
+      def stats_action: -> Actions::Stats
+      def unlock_action: -> Actions::Unlock
+      def lock_action: -> Actions::Lock
+      def lock_all_action: -> Actions::LockAll
+      def remove_action: -> Actions::Remove
+    end
+  end
+end

data/sig/stoplight/admin/helpers.rbs

@@ -0,0 +1,17 @@
+module Stoplight
+  class Admin
+    module Helpers : Sinatra::Base
+      COLORS: Array[Domain::color]
+
+      def dependencies: -> Dependencies
+      def system_url: (String system_id, String path) -> String
+      def asset_path: (String) -> String
+      def time_ago_in_words: (Time) -> String
+      def control_attributes: (String href, ?confirm: String?, ?verb: String?) -> String
+      def find_system: (String) -> Wiring::System
+      def current_system_id: -> String
+      def current_system: -> Wiring::System
+      def show_system_switcher?: -> bool
+    end
+  end
+end

data/sig/stoplight/admin/light_view.rbs

@@ -0,0 +1,39 @@
+module Stoplight
+  class Admin
+    class LightView
+      COLORS: Array[Domain::color]
+
+      attr_reader failures: Array[Domain::Failure]
+
+      @state_snapshot: Domain::StateSnapshot
+      @metrics_snapshot: Domain::MetricsSnapshot
+      @recovery_metrics_snapshot: Domain::MetricsSnapshot
+      @config: Domain::Config
+      @failures: Array[Domain::Failure]
+
+      def initialize: (
+          config: Domain::Config,
+          state_snapshot: Domain::StateSnapshot,
+          recovery_metrics_snapshot: Domain::MetricsSnapshot,
+          metrics_snapshot: Domain::MetricsSnapshot,
+        ) -> void
+
+      def id: -> String
+      def color: -> Domain::color
+      def name: -> String
+      def state: -> Domain::state
+      def traffic_metric_label: -> String
+      def traffic_metric_value: -> String
+      def locked?: -> bool
+      def unlocked?: -> bool
+      def as_json: -> Hash[Symbol, _ToS]
+      def default_sort_key: -> Array[Comparable]
+      def last_check: -> Time?
+      private def duration_in_words: (Integer) -> String
+      def description_title: -> String
+      def description_message: -> String
+      def description_comment: -> String
+      def latest_failure: -> Domain::Failure?
+    end
+  end
+end

data/sig/stoplight/admin/lights_stats.rbs

@@ -0,0 +1,30 @@
+module Stoplight
+  class Admin
+    class LightsStats
+      EMPTY_STATS: Hash[Symbol, Integer]
+
+      attr_reader lights: Array[LightView]
+      @lights: Array[LightView]
+
+      def self.call: (Array[LightView]) -> Hash[Symbol, Integer]
+
+      def initialize: (Array[LightView]) -> void
+
+      def call: -> Hash[Symbol, Integer]
+
+      private
+
+      def size: -> Integer
+
+      def count_lights: (Domain::color)-> Integer
+      def count_red: -> Integer
+      def count_green: -> Integer
+      def count_yellow: -> Integer
+
+      def percent_lights: (Domain::color)-> Integer
+      def percent_green: -> Integer
+      def percent_red: -> Integer
+      def percent_yellow: -> Integer
+    end
+  end
+end