stoplight 5.8.2 → 6.0.0.rc1

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/map"
-
-module Stoplight
-  module Infrastructure
-    module Memory
-      class DataStore
-        # Process-local recovery lock using Ruby's Thread::Mutex.
-        #
-        # This only serializes recovery within a single Ruby process.
-        # Multiple processes/servers will NOT coordinate - each process
-        # can send probes independently.
-        #
-        # Mutex Lifecycle:
-        # - One mutex created per unique light_name (lazily)
-        # - Mutexes persist for process lifetime (never GC'd)
-        #
-        class RecoveryLockStore
-          def initialize
-            @locks = Concurrent::Map.new
-          end
-
-          # @param light_name [String]
-          # @return [Stoplight::Infrastructure::Memory::DataStore::RecoveryLockToken, nil]
-          def acquire_lock(light_name)
-            lock = lock_for(light_name)
-            RecoveryLockToken.new(light_name:) if lock.try_lock
-          end
-
-          # @param recovery_lock_token [Stoplight::Infrastructure::Memory::DataStore::RecoveryLockToken]
-          # @return [void]
-          def release_lock(recovery_lock_token)
-            lock_for(recovery_lock_token.light_name).unlock
-          end
-
-          private
-
-          # Stores one mutex per unique light_name for the lifetime of the process.
-          # Mutexes are never garbage collected.
-          attr_reader :locks
-
-          private def lock_for(light_name)
-            locks.compute_if_absent(light_name) do
-              Thread::Mutex.new
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module Memory
-      class DataStore
-        class RecoveryLockToken
-          attr_reader :light_name
-
-          def initialize(light_name:)
-            @light_name = light_name
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module Memory
-      class DataStore
-        # Hash-based sliding window for O(1) amortized operations.
-        #
-        # Maintains a running sum and stores per-second counts in a Hash. Ruby's Hash
-        # preserves insertion order (FIFO), allowing efficient removal of expired
-        # buckets from the front via +Hash#shift+, with their counts subtracted from
-        # the running sum.
-        #
-        # Performance: O(1) amortized for both reads and writes
-        # Memory: Bounded to the number of buckets
-        #
-        # @note Not thread-safe; synchronization must be handled externally
-        # @api private
-        class SlidingWindow
-          def initialize(clock:)
-            @buckets = Hash.new { |buckets, bucket| buckets[bucket] = 0 }
-            @running_sum = 0
-            @clock = clock
-          end
-
-          # Increment the count at a given timestamp
-          def increment
-            buckets[current_bucket] += 1
-            self.running_sum += 1
-          end
-
-          def sum_in_window(window_start)
-            slide_window!(window_start)
-            self.running_sum
-          end
-
-          def inspect
-            "#<#{self.class.name} #{buckets}>"
-          end
-
-          private
-
-          # A hash mapping time buckets to their counts
-          attr_reader :buckets
-          # The running sum of all increments in the current window
-          attr_accessor :running_sum
-          attr_reader :clock
-
-          def slide_window!(window_start)
-            window_start_ts = window_start.to_i
-
-            loop do
-              timestamp, sum = buckets.first
-              if timestamp.nil? || timestamp >= window_start_ts
-                break
-              else
-                self.running_sum -= sum.to_i
-                buckets.shift
-              end
-            end
-          end
-
-          def current_bucket
-            bucket_for_time(clock.current_time)
-          end
-
-          def bucket_for_time(time)
-            time.to_i
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Infrastructure
-    module Memory
-      class DataStore
-        class State
-          attr_accessor :recovered_at
-          attr_accessor :locked_state
-          attr_accessor :recovery_scheduled_after
-          attr_accessor :recovery_started_at
-          attr_accessor :breached_at
-
-          def initialize
-            @locked_state = Stoplight::State::UNLOCKED
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,342 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-module Stoplight
-  module Infrastructure
-    module Memory
-      # steep:ignore:start
-      # @see +Domain::_DataStore+
-      class DataStore
-        include MonitorMixin
-
-        KEY_SEPARATOR = ":"
-
-        # @!attribute recovery_lock_store
-        #   @return [Stoplight::Infrastructure::Memory::DataStore::RecoveryLockStore]
-        #   @api private
-        private attr_reader :recovery_lock_store
-
-        # @!attribute clock
-        #   @return [Stoplight::Domain::_Clock]
-        private attr_reader :clock
-
-        # @param recovery_lock_store [Stoplight::Infrastructure::Memory::DataStore::RecoveryLockStore]
-        # @param clock [Stoplight::Domain::_Clock]
-        def initialize(recovery_lock_store:, clock:)
-          @clock = clock
-          @recovery_lock_store = recovery_lock_store
-          @errors = Hash.new { |errors, light_name| errors[light_name] = SlidingWindow.new(clock:) }
-          @successes = Hash.new { |successes, light_name| successes[light_name] = SlidingWindow.new(clock:) }
-          @metrics = Hash.new { |metrics, light_name| metrics[light_name] = Metrics.new }
-
-          @recovery_metrics = Hash.new { |metrics, light_name| metrics[light_name] = Metrics.new }
-
-          @states = Hash.new { |states, light_name| states[light_name] = State.new }
-
-          super() # MonitorMixin
-        end
-
-        # @return [Array<String>]
-        def names
-          synchronize { @metrics.keys | @states.keys | @recovery_metrics.keys }
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        # @return [Stoplight::Domain::MetricsSnapshot]
-        def get_metrics(config)
-          light_name = config.name
-
-          synchronize do
-            current_time = clock.current_time
-            window_start = if config.window_size
-              (current_time - config.window_size)
-            else
-              current_time
-            end
-
-            metrics = @metrics[light_name]
-
-            errors = @errors[light_name].sum_in_window(window_start) if config.window_size
-            successes = @successes[light_name].sum_in_window(window_start) if config.window_size
-            consecutive_errors = config.window_size ? [metrics.consecutive_errors, errors].min : metrics.consecutive_errors
-            consecutive_successes = config.window_size ? [metrics.consecutive_successes.to_i, successes].min : metrics.consecutive_successes.to_i
-
-            Domain::MetricsSnapshot.new(
-              errors:,
-              successes:,
-              consecutive_errors:,
-              consecutive_successes:,
-              last_error: metrics.last_error,
-              last_success_at: metrics.last_success_at
-            )
-          end
-        end
-
-        # @return [Stoplight::Domain::MetricsSnapshot]
-        def get_recovery_metrics(config)
-          light_name = config.name
-
-          synchronize do
-            metrics = @recovery_metrics[light_name]
-
-            Domain::MetricsSnapshot.new(
-              errors: nil, successes: nil,
-              consecutive_errors: metrics.consecutive_errors,
-              consecutive_successes: metrics.consecutive_successes,
-              last_error: metrics.last_error,
-              last_success_at: metrics.last_success_at
-            )
-          end
-        end
-
-        # @return [Stoplight::Domain::StateSnapshot]
-        def get_state_snapshot(config)
-          time, state = synchronize do
-            [clock.current_time, @states[config.name]]
-          end
-
-          Domain::StateSnapshot.new(
-            time:,
-            locked_state: state.locked_state,
-            recovery_scheduled_after: state.recovery_scheduled_after,
-            recovery_started_at: state.recovery_started_at,
-            breached_at: state.breached_at
-          )
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        # @param exception [Exception]
-        # @return [void]
-        def record_failure(config, exception)
-          current_time = clock.current_time
-          light_name = config.name
-          failure = Domain::Failure.from_error(exception, time: current_time)
-
-          synchronize do
-            @errors[light_name].increment if config.window_size
-
-            metrics = @metrics[light_name]
-
-            if metrics.last_error_at.nil? || failure.occurred_at > metrics.last_error_at
-              metrics.last_error = failure
-            end
-
-            metrics.consecutive_errors += 1
-            metrics.consecutive_successes = 0
-          end
-        end
-
-        def clear_metrics(config)
-          light_name = config.name
-          synchronize do
-            if config.window_size
-              @errors[light_name] = SlidingWindow.new(clock:)
-              @successes[light_name] = SlidingWindow.new(clock:)
-            end
-            @metrics[light_name] = Metrics.new
-          end
-        end
-
-        def clear_recovery_metrics(config)
-          synchronize do
-            @recovery_metrics[config.name] = Metrics.new
-          end
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        # @return [void]
-        def record_success(config)
-          light_name = config.name
-          current_time = clock.current_time
-
-          synchronize do
-            @successes[light_name].increment if config.window_size
-
-            metrics = @metrics[light_name]
-
-            if metrics.last_success_at.nil? || current_time > metrics.last_success_at
-              metrics.last_success_at = current_time
-            end
-
-            metrics.consecutive_errors = 0
-            metrics.consecutive_successes += 1
-          end
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        # @param exception [Exception]
-        # @return [void]
-        def record_recovery_probe_failure(config, exception)
-          light_name = config.name
-          current_time = clock.current_time
-          failure = Domain::Failure.from_error(exception, time: current_time)
-
-          synchronize do
-            metrics = @recovery_metrics[light_name]
-
-            if metrics.last_error_at.nil? || failure.occurred_at > metrics.last_error_at
-              metrics.last_error = failure
-            end
-
-            metrics.consecutive_errors += 1
-            metrics.consecutive_successes = 0
-          end
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        # @return [void]
-        def record_recovery_probe_success(config)
-          light_name = config.name
-          current_time = clock.current_time
-
-          synchronize do
-            metrics = @recovery_metrics[light_name]
-            if metrics.last_success_at.nil? || current_time > metrics.last_success_at
-              metrics.last_success_at = current_time
-            end
-
-            metrics.consecutive_errors = 0
-            metrics.consecutive_successes += 1
-          end
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        # @param state [String]
-        # @return [String]
-        def set_state(config, state)
-          light_name = config.name
-
-          synchronize do
-            @states[light_name].locked_state = state
-          end
-          state
-        end
-
-        # @return [String]
-        def inspect
-          "#<#{self.class.name}>"
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        # @return [void]
-        def delete_light(config)
-          light_name = config.name
-
-          synchronize do
-            @states.delete(light_name)
-            @recovery_metrics.delete(light_name)
-            @metrics.delete(light_name)
-            @errors.delete(light_name)
-            @successes.delete(light_name)
-          end
-        end
-
-        # Combined method that performs the state transition based on color
-        #
-        # @param config [Stoplight::Domain::Config] The light configuration
-        # @param color [String] The color to transition to ("GREEN", "YELLOW", or "RED")
-        # @return [Boolean] true if this is the first instance to detect this transition
-        def transition_to_color(config, color)
-          case color
-          when Color::GREEN
-            transition_to_green(config)
-          when Color::YELLOW
-            transition_to_yellow(config)
-          when Color::RED
-            transition_to_red(config)
-          else
-            raise ArgumentError, "Invalid color: #{color}"
-          end
-        end
-
-        # @param config [Stoplight::Domain::Config]
-        # @return [Stoplight::Infrastructure::Memory::DataStore::RecoveryLockToken, nil]
-        def acquire_recovery_lock(config)
-          recovery_lock_store.acquire_lock(config.name)
-        end
-
-        # @param lock [Stoplight::Infrastructure::Memory::DataStore::RecoveryLockToken]
-        # @return [void]
-        def release_recovery_lock(lock)
-          recovery_lock_store.release_lock(lock)
-        end
-
-        # Transitions to GREEN state and ensures only one notification
-        #
-        # @param config [Stoplight::Domain::Config] The light configuration
-        # @return [Boolean] true if this is the first instance to detect this transition
-        private def transition_to_green(config)
-          light_name = config.name
-          current_time = clock.current_time
-
-          synchronize do
-            state = @states[light_name]
-
-            if state.recovered_at
-              false
-            else
-              state.recovered_at = current_time
-              state.recovery_started_at = nil
-              state.breached_at = nil
-              state.recovery_scheduled_after = nil
-              true
-            end
-          end
-        end
-
-        # Transitions to YELLOW (recovery) state and ensures only one notification
-        #
-        # @param config [Stoplight::Domain::Config] The light configuration
-        # @return [Boolean] true if this is the first instance to detect this transition
-        private def transition_to_yellow(config)
-          light_name = config.name
-          current_time = clock.current_time
-
-          synchronize do
-            state = @states[light_name]
-            if state.recovery_started_at.nil?
-              state.recovery_started_at = current_time
-              state.recovery_scheduled_after = nil
-              state.recovered_at = nil
-              state.breached_at = nil
-              true
-            else
-              state.recovery_scheduled_after = nil
-              state.recovered_at = nil
-              state.breached_at = nil
-              false
-            end
-          end
-        end
-
-        # Transitions to RED state and ensures only one notification
-        #
-        # @param config [Stoplight::Domain::Config] The light configuration
-        # @return [Boolean] true if this is the first instance to detect this transition
-        private def transition_to_red(config)
-          light_name = config.name
-          current_time = clock.current_time
-          recovery_scheduled_after = current_time + config.cool_off_time
-
-          synchronize do
-            state = @states[light_name]
-            if state.breached_at
-              state.recovery_scheduled_after = recovery_scheduled_after
-              state.recovery_started_at = nil
-              state.recovered_at = nil
-              false
-            else
-              state.breached_at = current_time
-              state.recovery_scheduled_after = recovery_scheduled_after
-              state.recovery_started_at = nil
-              state.recovered_at = nil
-              true
-            end
-          end
-        end
-      end
-      # steep:ignore:end
-    end
-  end
-end

data/lib/stoplight/infrastructure/redis/data_store/lua_scripts/get_metrics.lua

@@ -1,26 +0,0 @@
-local number_of_metric_buckets = tonumber(ARGV[1])
-local window_start_ts = tonumber(ARGV[2])
-local window_end_ts = tonumber(ARGV[3])
-local metrics_keys = {}
-for idx = 4, #ARGV do
-  table.insert(metrics_keys, ARGV[idx])
-end
-
-local metadata_key = KEYS[1]
-
-local function count_events(start_idx, bucket_count, start_ts)
-  local total = 0
-  for idx = start_idx, start_idx + bucket_count - 1 do
-    total = total + tonumber(redis.call('ZCOUNT', KEYS[idx], start_ts, window_end_ts))
-  end
-  return total
-end
-
-local offset = 2
-local successes = count_events(2, number_of_metric_buckets, window_start_ts)
-
-offset = offset + number_of_metric_buckets
-local errors = count_events(offset, number_of_metric_buckets, window_start_ts)
-
-local metrics = redis.call('HMGET',  metadata_key, unpack(metrics_keys))
-return {successes, errors, unpack(metrics)}

data/lib/stoplight/infrastructure/redis/data_store/lua_scripts/record_failure.lua

@@ -1,36 +0,0 @@
-local failure_ts = tonumber(ARGV[1])
-local failure_id = ARGV[2]
-local failure_json = ARGV[3]
-local bucket_ttl = tonumber(ARGV[4])
-local metadata_ttl = tonumber(ARGV[5])
-
-local metadata_key = KEYS[1]
-local errors_key = KEYS[2]
-
--- Record failure
-if errors_key ~= nil then
-  redis.call('ZADD', errors_key, failure_ts, failure_id)
-  redis.call('EXPIRE', errors_key, bucket_ttl) -- Not supported in Redis 6.2:, 'NX')
-end
-
--- Update metadata
-local meta = redis.call('HMGET', metadata_key, 'last_error_at', 'consecutive_errors')
-local prev_failure_ts = tonumber(meta[1])
-local prev_consecutive_errors = tonumber(meta[2])
-
-if not prev_failure_ts or failure_ts > prev_failure_ts then
-  redis.call(
-    'HSET', metadata_key,
-    'last_error_at', failure_ts,
-    'last_error_json', failure_json,
-    'consecutive_errors', (prev_consecutive_errors or 0) + 1,
-    'consecutive_successes', 0
-  )
-else
-  redis.call(
-    'HSET', metadata_key,
-    'consecutive_errors', (prev_consecutive_errors or 0) + 1,
-    'consecutive_successes', 0
-  )
-end
-redis.call('EXPIRE', metadata_key, metadata_ttl) -- Not supported in Redis 6.2:, 'GT')

data/lib/stoplight/infrastructure/redis/data_store/lua_scripts/record_recovery_probe_failure.lua

@@ -1,27 +0,0 @@
-local failure_ts = tonumber(ARGV[1])
-local failure_json = ARGV[2]
-
-local metadata_key = KEYS[1]
-
-
--- Update metadata
-local meta = redis.call('HMGET', metadata_key, 'last_error_at', 'consecutive_errors')
-local prev_failure_ts = tonumber(meta[1])
-local prev_consecutive_errors = tonumber(meta[2])
-
-if not prev_failure_ts or failure_ts > prev_failure_ts then
-  redis.call(
-    'HSET', metadata_key,
-    'last_error_at', failure_ts,
-    'last_error_json', failure_json,
-    'consecutive_errors', (prev_consecutive_errors or 0) + 1,
-    'consecutive_successes', 0
-  )
-else
-  redis.call(
-    'HSET', metadata_key,
-    'consecutive_errors', (prev_consecutive_errors or 0) + 1,
-    'consecutive_successes', 0
-  )
-end
-

data/lib/stoplight/infrastructure/redis/data_store/lua_scripts/record_recovery_probe_success.lua

@@ -1,23 +0,0 @@
-local request_ts = tonumber(ARGV[1])
-
-local metadata_key = KEYS[1]
-
--- Update metadata
-local meta = redis.call('HMGET', metadata_key, 'last_success_at', 'consecutive_successes')
-local prev_success_ts = tonumber(meta[1])
-local prev_consecutive_successes = tonumber(meta[2])
-
-if not prev_success_ts or request_ts > prev_success_ts then
-  redis.call(
-    'HSET', metadata_key,
-    'last_success_at', request_ts,
-    'consecutive_errors', 0,
-    'consecutive_successes', (prev_consecutive_successes or 0) + 1
-  )
-else
-  redis.call(
-    'HSET', metadata_key,
-    'consecutive_errors', 0,
-    'consecutive_successes', (prev_consecutive_successes or 0) + 1
-  )
-end

data/lib/stoplight/infrastructure/redis/data_store/lua_scripts/record_success.lua

@@ -1,35 +0,0 @@
-local request_ts = tonumber(ARGV[1])
-local request_id = ARGV[2]
-local bucket_ttl = tonumber(ARGV[3])
-local metadata_ttl = tonumber(ARGV[4])
-
-local metadata_key = KEYS[1]
-local successes_key = KEYS[2]
-
--- Record success
-if successes_key ~= nil then
-  redis.call('ZADD', successes_key, request_ts, request_id)
-  redis.call('EXPIRE', successes_key, bucket_ttl) -- Not supported in Redis 6.2:, 'NX')
-end
-
--- Update metadata
-local meta = redis.call('HMGET', metadata_key, 'last_success_at', 'consecutive_successes')
-local prev_success_ts = tonumber(meta[1])
-local prev_consecutive_successes = tonumber(meta[2])
-
-if not prev_success_ts or request_ts > prev_success_ts then
-  redis.call(
-    'HSET', metadata_key,
-    'last_success_at', request_ts,
-    'consecutive_errors', 0,
-    'consecutive_successes', (prev_consecutive_successes or 0) + 1
-  )
-else
-  redis.call(
-    'HSET', metadata_key,
-    'consecutive_errors', 0,
-    'consecutive_successes', (prev_consecutive_successes or 0) + 1
-  )
-end
-
-redis.call('EXPIRE', metadata_key, metadata_ttl) -- Not supported in Redis 6.2:, 'GT')

data/lib/stoplight/infrastructure/redis/data_store/lua_scripts/release_lock.lua

@@ -1,6 +0,0 @@
-local token = ARGV[1]
-local lock_key = KEYS[1]
-
-if redis.call("get", lock_key) == token then
-  return redis.call("del", lock_key)
-end

data/lib/stoplight/infrastructure/redis/data_store/lua_scripts/transition_to_green.lua

@@ -1,10 +0,0 @@
-local meta_key = KEYS[1]
-local current_ts = tonumber(ARGV[1])
-
---  1 if the field is a new field in the hash and the value was set
-local became_green = redis.call('HSETNX', meta_key, 'recovered_at', current_ts)
-
-if became_green == 1 then
-  redis.call("HDEL", meta_key, 'recovery_started_at', 'recovery_scheduled_after', 'breached_at')
-end
-return became_green

data/lib/stoplight/infrastructure/redis/data_store/lua_scripts/transition_to_red.lua

@@ -1,10 +0,0 @@
-local meta_key = KEYS[1]
-local current_ts = tonumber(ARGV[1])
-local recovery_scheduled_after_ts = tonumber(ARGV[2])
-
---  1 if the field is a new field in the hash and the value was set
-local became_red = redis.call('HSETNX', meta_key, 'breached_at', current_ts)
-
-redis.call('HSET', meta_key, 'recovery_scheduled_after', recovery_scheduled_after_ts)
-redis.call("HDEL", meta_key, "recovery_started_at", "recovered_at")
-return became_red