stoplight 5.5.0 → 5.6.0

data/lib/stoplight/domain/traffic_recovery/base.rb

@@ -14,14 +14,14 @@ module Stoplight
       #       @min_samples = min_samples
       #     end
       #
-      #     def determine_color(config, metadata)
-      #       total_probes = metadata.recovery_probe_successes + metadata.recovery_probe_errors
+      #     def determine_color(config, metrics)
+      #       total_probes = metrics.recovery_probe_successes + metrics.recovery_probe_errors
       #
       #       if total_probes < @min_samples
       #         return Color::YELLOW # Keep recovering, not enough samples
       #       end
       #
-      #       success_rate = metadata.recovery_probe_successes.fdiv(total_probes)
+      #       success_rate = metrics.recovery_probe_successes.fdiv(total_probes)
       #       if success_rate >= @min_success_rate
       #         Color::GREEN # Recovery successful
       #       elsif success_rate <= 0.2
@@ -49,10 +49,11 @@ module Stoplight
         # current metrics and recovery progress.
         #
         # @param config [Stoplight::Domain::Config]
-        # @param metadata [Stoplight::Domain::Metadata]
+        # @param metrics [Stoplight::Domain::Metrics]
+        # @param state_snapshot [Stoplight::Domain::StateSnapshot]
         # @return [TrafficRecovery::Decision]
         # :nocov:
-        def determine_color(config, metadata)
+        def determine_color(config, metrics, state_snapshot)
           raise NotImplementedError
         end
         # :nocov:

data/lib/stoplight/domain/traffic_recovery/consecutive_successes.rb

@@ -49,16 +49,18 @@ module Stoplight
         # Determines if traffic should be resumed based on successes counts.
         #
         # @param config [Stoplight::Domain::Config]
-        # @param metadata [Stoplight::Domain::Metadata]
+        # @param recovery_metrics [Stoplight::Domain::Metrics]
+        # @param state_snapshot [Stoplight::Domain::StateSnapshot]
         # @return [TrafficRecovery::Decision]
-        def determine_color(config, metadata)
-          return TrafficRecovery::PASS if metadata.color != Color::YELLOW
+        def determine_color(config, recovery_metrics, state_snapshot)
+          return TrafficRecovery::PASS if state_snapshot.color != Color::YELLOW
 
-          recovery_started_at = metadata.recovery_started_at || metadata.recovery_scheduled_after
+          recovery_started_at = state_snapshot.recovery_started_at || state_snapshot.recovery_scheduled_after
 
-          if metadata.last_error_at && metadata.last_error_at >= recovery_started_at
+          # TODO: Need to add metrics cleanup and we can just use recovery_metrics.errors > 0
+          if recovery_metrics.last_error_at && recovery_metrics.last_error_at >= recovery_started_at
             TrafficRecovery::RED
-          elsif [metadata.consecutive_successes, metadata.recovery_probe_successes].min >= config.recovery_threshold
+          elsif recovery_metrics.consecutive_successes >= config.recovery_threshold
             TrafficRecovery::GREEN
           else
             TrafficRecovery::YELLOW

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Stoplight
+  module Infrastructure
+    module DataStore
+      class Memory
+        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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Stoplight
+  module Infrastructure
+    module DataStore
+      class Memory
+        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 = Domain::State::UNLOCKED
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,61 +18,90 @@ module Stoplight
           @recovery_probe_errors = Hash.new { |recovery_probe_errors, light_name| recovery_probe_errors[light_name] = SlidingWindow.new }
           @recovery_probe_successes = Hash.new { |recovery_probe_successes, light_name| recovery_probe_successes[light_name] = SlidingWindow.new }
 
-          @metadata = Hash.new do |metadata, light_name|
-            metadata[light_name] = Domain::Metadata.new(
-              current_time: Time.now,
-              successes: 0,
-              errors: 0,
-              recovery_probe_successes: 0,
-              recovery_probe_errors: 0,
-              last_error: nil,
-              last_error_at: nil,
-              last_success_at: nil,
-              consecutive_errors: 0,
-              consecutive_successes: 0,
-              breached_at: nil,
-              locked_state: Domain::State::UNLOCKED,
-              recovery_scheduled_after: nil,
-              recovery_started_at: nil,
-              recovered_at: nil
-            )
-          end
+          @states = Hash.new { |states, light_name| states[light_name] = State.new }
+          @metrics = Hash.new { |metrics, light_name| metrics[light_name] = Metrics.new }
+
           super # MonitorMixin
         end
 
         # @return [Array<String>]
         def names
-          synchronize { @metadata.keys }
+          synchronize { @metrics.keys | @states.keys }
         end
 
         # @param config [Stoplight::Domain::Config]
-        # @return [Stoplight::Domain::Metadata]
-        def get_metadata(config)
+        # @return [Stoplight::Domain::Metrics]
+        def get_metrics(config)
           light_name = config.name
 
           synchronize do
             current_time = self.current_time
-            recovery_window_start = (current_time - config.cool_off_time)
-            recovered_at = @metadata[light_name].recovered_at
             window_start = if config.window_size
-              [recovered_at, (current_time - config.window_size)].compact.max
+              (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
+
+            Domain::Metrics.new(
+              errors:,
+              successes:,
+              total_consecutive_errors: metrics.consecutive_errors,
+              total_consecutive_successes: metrics.consecutive_successes,
+              last_error: metrics.last_error,
+              last_success_at: metrics.last_success_at
+            )
+          end
+        end
+
+        # @return [Stoplight::Domain::Metrics]
+        def get_recovery_metrics(config)
+          light_name = config.name
+
+          synchronize do
+            current_time = self.current_time
+            recovery_window_start = (current_time - config.cool_off_time)
+            if config.window_size
+              (current_time - config.window_size)
             else
               current_time
             end
 
-            @metadata[light_name].with(
-              current_time:,
-              errors: @errors[config.name].sum_in_window(window_start),
-              successes: @successes[config.name].sum_in_window(window_start),
-              recovery_probe_errors: @recovery_probe_errors[config.name].sum_in_window(recovery_window_start),
-              recovery_probe_successes: @recovery_probe_successes[config.name].sum_in_window(recovery_window_start)
+            metrics = @metrics[light_name]
+
+            Domain::Metrics.new(
+              errors: @recovery_probe_errors[light_name].sum_in_window(recovery_window_start),
+              successes: @recovery_probe_successes[light_name].sum_in_window(recovery_window_start),
+              total_consecutive_errors: metrics.consecutive_errors,
+              total_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
+            [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 [Stoplight::Domain::Metadata]
+        # @return [void]
         def record_failure(config, exception)
           current_time = self.current_time
           light_name = config.name
@@ -81,21 +110,23 @@ module Stoplight
           synchronize do
             @errors[light_name].increment if config.window_size
 
-            metadata = @metadata[light_name]
-            @metadata[light_name] = if metadata.last_error_at.nil? || current_time > metadata.last_error_at
-              metadata.with(
-                last_error_at: current_time,
-                last_error: failure,
-                consecutive_errors: metadata.consecutive_errors.succ,
-                consecutive_successes: 0
-              )
-            else
-              metadata.with(
-                consecutive_errors: metadata.consecutive_errors.succ,
-                consecutive_successes: 0
-              )
+            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_windowed_metrics(config)
+          if config.window_size
+            synchronize do
+              @errors[config.name] = SlidingWindow.new
+              @successes[config.name] = SlidingWindow.new
             end
-            get_metadata(config)
           end
         end
 
@@ -108,25 +139,20 @@ module Stoplight
           synchronize do
             @successes[light_name].increment if config.window_size
 
-            metadata = @metadata[light_name]
-            @metadata[light_name] = if metadata.last_success_at.nil? || current_time > metadata.last_success_at
-              metadata.with(
-                last_success_at: current_time,
-                consecutive_errors: 0,
-                consecutive_successes: metadata.consecutive_successes.succ
-              )
-            else
-              metadata.with(
-                consecutive_errors: 0,
-                consecutive_successes: metadata.consecutive_successes.succ
-              )
+            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 [Stoplight::Domain::Metadata]
+        # @return [void]
         def record_recovery_probe_failure(config, exception)
           light_name = config.name
           current_time = self.current_time
@@ -135,26 +161,19 @@ module Stoplight
           synchronize do
             @recovery_probe_errors[light_name].increment
 
-            metadata = @metadata[light_name]
-            @metadata[light_name] = if metadata.last_error_at.nil? || current_time > metadata.last_error_at
-              metadata.with(
-                last_error_at: current_time,
-                last_error: failure,
-                consecutive_errors: metadata.consecutive_errors.succ,
-                consecutive_successes: 0
-              )
-            else
-              metadata.with(
-                consecutive_errors: metadata.consecutive_errors.succ,
-                consecutive_successes: 0
-              )
+            metrics = @metrics[light_name]
+
+            if metrics.last_error_at.nil? || failure.occurred_at > metrics.last_error_at
+              metrics.last_error = failure
             end
-            get_metadata(config)
+
+            metrics.consecutive_errors += 1
+            metrics.consecutive_successes = 0
           end
         end
 
         # @param config [Stoplight::Domain::Config]
-        # @return [Stoplight::Domain::Metadata]
+        # @return [void]
         def record_recovery_probe_success(config)
           light_name = config.name
           current_time = self.current_time
@@ -162,20 +181,13 @@ module Stoplight
           synchronize do
             @recovery_probe_successes[light_name].increment
 
-            metadata = @metadata[light_name]
-            @metadata[light_name] = if metadata.last_success_at.nil? || current_time > metadata.last_success_at
-              metadata.with(
-                last_success_at: current_time,
-                consecutive_errors: 0,
-                consecutive_successes: metadata.consecutive_successes.succ
-              )
-            else
-              metadata.with(
-                consecutive_errors: 0,
-                consecutive_successes: metadata.consecutive_successes.succ
-              )
+            metrics = @metrics[light_name]
+            if metrics.last_success_at.nil? || current_time > metrics.last_success_at
+              metrics.last_success_at = current_time
             end
-            get_metadata(config)
+
+            metrics.consecutive_errors = 0
+            metrics.consecutive_successes += 1
           end
         end
 
@@ -186,8 +198,7 @@ module Stoplight
           light_name = config.name
 
           synchronize do
-            metadata = @metadata[light_name]
-            @metadata[light_name] = metadata.with(locked_state: state)
+            @states[light_name].locked_state = state
           end
           state
         end
@@ -224,16 +235,15 @@ module Stoplight
           current_time = self.current_time
 
           synchronize do
-            metadata = @metadata[light_name]
-            if metadata.recovered_at
+            state = @states[light_name]
+
+            if state.recovered_at
               false
             else
-              @metadata[light_name] = metadata.with(
-                recovered_at: current_time,
-                recovery_started_at: nil,
-                breached_at: nil,
-                recovery_scheduled_after: nil
-              )
+              state.recovered_at = current_time
+              state.recovery_started_at = nil
+              state.breached_at = nil
+              state.recovery_scheduled_after = nil
               true
             end
           end
@@ -248,21 +258,17 @@ module Stoplight
           current_time = self.current_time
 
           synchronize do
-            metadata = @metadata[light_name]
-            if metadata.recovery_started_at.nil?
-              @metadata[light_name] = metadata.with(
-                recovery_started_at: current_time,
-                recovery_scheduled_after: nil,
-                recovered_at: nil,
-                breached_at: nil
-              )
+            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
-              @metadata[light_name] = metadata.with(
-                recovery_scheduled_after: nil,
-                recovered_at: nil,
-                breached_at: nil
-              )
+              state.recovery_scheduled_after = nil
+              state.recovered_at = nil
+              state.breached_at = nil
               false
             end
           end
@@ -278,21 +284,17 @@ module Stoplight
           recovery_scheduled_after = current_time + config.cool_off_time
 
           synchronize do
-            metadata = @metadata[light_name]
-            if metadata.breached_at
-              @metadata[light_name] = metadata.with(
-                recovery_scheduled_after: recovery_scheduled_after,
-                recovery_started_at: nil,
-                recovered_at: nil
-              )
+            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
-              @metadata[light_name] = metadata.with(
-                breached_at: current_time,
-                recovery_scheduled_after: recovery_scheduled_after,
-                recovery_started_at: nil,
-                recovered_at: nil
-              )
+              state.breached_at = current_time
+              state.recovery_scheduled_after = recovery_scheduled_after
+              state.recovery_started_at = nil
+              state.recovered_at = nil
               true
             end
           end

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

@@ -0,0 +1,26 @@
+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/data_store/redis/lua.rb

@@ -14,7 +14,7 @@ module Stoplight
 
           RECORD_FAILURE = read_lua_file("record_failure")
           RECORD_SUCCESS = read_lua_file("record_success")
-          GET_METADATA = read_lua_file("get_metadata")
+          GET_METRICS = read_lua_file("get_metrics")
           TRANSITION_TO_YELLOW = read_lua_file("transition_to_yellow")
           TRANSITION_TO_RED = read_lua_file("transition_to_red")
           TRANSITION_TO_GREEN = read_lua_file("transition_to_green")