stoplight 5.5.0 → 5.6.0

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

@@ -92,12 +92,13 @@ module Stoplight
           end
         end
 
-        def get_metadata(config)
-          detect_clock_skew
+        # @param config [Stoplight::Domain::Config]
+        # @return [Stoplight::Domain::Metrics]
+        def get_metrics(config)
+          config.name
 
           window_end_ts = current_time.to_f
-          window_start_ts = window_end_ts - [config.window_size, METRICS_RETENTION_TIME].compact.min.to_f
-          recovery_window_start_ts = window_end_ts - config.cool_off_time.to_i
+          window_start_ts = window_end_ts - config.window_size.to_i
 
           if config.window_size
             failure_keys = failure_bucket_keys(config, window_end: window_end_ts)
@@ -106,54 +107,121 @@ module Stoplight
             failure_keys = []
             success_keys = []
           end
+
+          successes, errors, last_success_at, last_error_json, consecutive_errors, consecutive_successes = @redis.with do |client|
+            client.evalsha(
+              get_metrics_sha,
+              argv: [
+                failure_keys.count,
+                window_start_ts,
+                window_end_ts,
+                "last_success_at", "last_error_json", "consecutive_errors", "consecutive_successes"
+              ],
+              keys: [
+                metadata_key(config),
+                *success_keys,
+                *failure_keys
+              ]
+            )
+          end
+
+          Domain::Metrics.new(
+            successes: (successes if config.window_size),
+            errors: (errors if config.window_size),
+            total_consecutive_errors: consecutive_errors.to_i,
+            total_consecutive_successes: consecutive_successes.to_i,
+            last_error: deserialize_failure(last_error_json),
+            last_success_at: (Time.at(last_success_at.to_f) if last_success_at)
+          )
+        end
+
+        # @param config [Stoplight::Domain::Config]
+        # @return [Stoplight::Domain::Metrics]
+        def get_recovery_metrics(config)
+          config.name
+
+          window_end_ts = current_time.to_f
+          window_start_ts = window_end_ts - config.cool_off_time
+
           recovery_probe_failure_keys = recovery_probe_failure_bucket_keys(config, window_end: window_end_ts)
           recovery_probe_success_keys = recovery_probe_success_bucket_keys(config, window_end: window_end_ts)
 
-          successes, errors, recovery_probe_successes, recovery_probe_errors, meta = @redis.with do |client|
+          successes, errors, last_success_at, last_error_json, consecutive_errors, consecutive_successes = @redis.with do |client|
             client.evalsha(
-              get_metadata_sha,
+              get_metrics_sha,
               argv: [
-                failure_keys.count,
                 recovery_probe_failure_keys.count,
                 window_start_ts,
                 window_end_ts,
-                recovery_window_start_ts
+                "last_success_at", "last_error_json", "consecutive_errors", "consecutive_successes"
               ],
               keys: [
                 metadata_key(config),
-                *success_keys,
-                *failure_keys,
                 *recovery_probe_success_keys,
                 *recovery_probe_failure_keys
               ]
             )
           end
-          meta_hash = meta.each_slice(2).to_h.transform_keys(&:to_sym)
-          last_error_json = meta_hash.delete(:last_error_json)
-          last_error = deserialize_failure(last_error_json) if last_error_json
 
-          Domain::Metadata.new(
-            current_time:,
+          Domain::Metrics.new(
             successes:,
             errors:,
-            recovery_probe_successes:,
-            recovery_probe_errors:,
-            last_error:,
-            last_error_at: (Time.at(meta_hash[:last_error_at].to_f) if meta_hash[:last_error_at]),
-            last_success_at: (Time.at(meta_hash[:last_success_at].to_f) if meta_hash[:last_success_at]),
-            consecutive_errors: meta_hash[:consecutive_errors].to_i,
-            consecutive_successes: meta_hash[:consecutive_successes].to_i,
-            breached_at: (Time.at(meta_hash[:breached_at].to_f) if meta_hash[:breached_at]),
-            locked_state: meta_hash[:locked_state] || Domain::State::UNLOCKED,
-            recovery_scheduled_after: (Time.at(meta_hash[:recovery_scheduled_after].to_f) if meta_hash[:recovery_scheduled_after]),
-            recovery_started_at: (Time.at(meta_hash[:recovery_started_at].to_f) if meta_hash[:recovery_started_at]),
-            recovered_at: (Time.at(meta_hash[:recovered_at].to_f) if meta_hash[:recovered_at])
+            total_consecutive_errors: consecutive_errors.to_i,
+            total_consecutive_successes: consecutive_successes.to_i,
+            last_error: deserialize_failure(last_error_json),
+            last_success_at: (Time.at(last_success_at.to_f) if last_success_at)
+          )
+        end
+
+        # @return [Stoplight::Domain::StateSnapshot]
+        def get_state_snapshot(config)
+          detect_clock_skew
+
+          breached_at_raw, locked_state, recovery_scheduled_after_raw, recovery_started_at_raw = @redis.with do |client|
+            client.hmget(metadata_key(config), :breached_at, :locked_state, :recovery_scheduled_after, :recovery_started_at)
+          end
+          breached_at = breached_at_raw&.to_f
+          recovery_scheduled_after = recovery_scheduled_after_raw&.to_f
+          recovery_started_at = recovery_started_at_raw&.to_f
+
+          Domain::StateSnapshot.new(
+            breached_at: (Time.at(breached_at) if breached_at),
+            locked_state: locked_state || Domain::State::UNLOCKED,
+            recovery_scheduled_after: (Time.at(recovery_scheduled_after) if recovery_scheduled_after),
+            recovery_started_at: (Time.at(recovery_started_at) if recovery_started_at),
+            time: current_time
+          )
+        end
+
+        def clear_windowed_metrics(config)
+          if config.window_size
+            window_end_ts = current_time.to_i
+            @redis.with do |client|
+              client.unlink(
+                *failure_bucket_keys(config, window_end: window_end_ts),
+                *success_bucket_keys(config, window_end: window_end_ts)
+              )
+            end
+          end
+        end
+
+        private def state_snapshot_from_hash(data, time: current_time)
+          breached_at = data[:breached_at]&.to_f
+          recovery_scheduled_after = data[:recovery_scheduled_after]&.to_f
+          recovery_started_at = data[:recovery_started_at]&.to_f
+
+          Domain::StateSnapshot.new(
+            breached_at: (Time.at(breached_at) if breached_at),
+            locked_state: data[:locked_state] || Domain::State::UNLOCKED,
+            recovery_scheduled_after: (Time.at(recovery_scheduled_after) if recovery_scheduled_after),
+            recovery_started_at: (Time.at(recovery_started_at) if recovery_started_at),
+            time:
           )
         end
 
         # @param config [Stoplight::Domain::Config] The light configuration.
         # @param exception [Exception]
-        # @return [Stoplight::Domain::Metadata] The updated metadata after recording the failure.
+        # @return [void]
         def record_failure(config, exception)
           current_time = self.current_time
           current_ts = current_time.to_f
@@ -169,7 +237,6 @@ module Stoplight
               ].compact
             )
           end
-          get_metadata(config)
         end
 
         def record_success(config, request_id: SecureRandom.hex(12))
@@ -191,7 +258,7 @@ module Stoplight
         #
         # @param config [Stoplight::Domain::Config] The light configuration.
         # @param exception [Exception]
-        # @return [Stoplight::Domain::Metadata] The updated metadata after recording the failure.
+        # @return [void]
         def record_recovery_probe_failure(config, exception)
           current_time = self.current_time
           current_ts = current_time.to_f
@@ -207,14 +274,13 @@ module Stoplight
               ].compact
             )
           end
-          get_metadata(config)
         end
 
         # Records a successful recovery probe for a specific light configuration.
         #
         # @param config [Stoplight::Domain::Config] The light configuration.
         # @param request_id [String] The unique identifier for the request
-        # @return [Stoplight::Domain::Metadata] The updated metadata after recording the success.
+        # @return [void]
         def record_recovery_probe_success(config, request_id: SecureRandom.hex(12))
           current_ts = current_time.to_f
 
@@ -228,7 +294,6 @@ module Stoplight
               ].compact
             )
           end
-          get_metadata(config)
         end
 
         def set_state(config, state)
@@ -283,7 +348,7 @@ module Stoplight
         # @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)
-          current_ts = current_time.to_i
+          current_ts = current_time.to_f
           meta_key = metadata_key(config)
 
           became_yellow = @redis.then do |client|
@@ -301,7 +366,7 @@ module Stoplight
         # @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)
-          current_ts = current_time.to_i
+          current_ts = current_time.to_f
           meta_key = metadata_key(config)
           recovery_scheduled_after_ts = current_ts + config.cool_off_time
 
@@ -316,9 +381,19 @@ module Stoplight
           became_red == 1
         end
 
-        # @param failure_json [String]
-        # @return [Domain::Failure]
+        # Removes all traces of a light from Redis metadata (metrics will expire by TTL).
+        #
+        # @param config [Stoplight::Domain::Config] The light configuration.
+        # @return [Integer] number of keys removed
+        def delete_light(config)
+          @redis.then { |client| client.del(metadata_key(config)) }
+        end
+
+        # @param failure_json [String, nil]
+        # @return [Domain::Failure, nil]
         private def deserialize_failure(failure_json)
+          return if failure_json.nil?
+
           object = JSON.parse(failure_json)
           error_object = object["error"]
 
@@ -439,9 +514,9 @@ module Stoplight
           end
         end
 
-        private def get_metadata_sha
-          @get_metadata_sha ||= @redis.then do |client|
-            client.script("load", Lua::GET_METADATA)
+        private def get_metrics_sha
+          @get_metrics_sha ||= @redis.then do |client|
+            client.script("load", Lua::GET_METRICS)
           end
         end
 

data/lib/stoplight/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Stoplight
-  VERSION = Gem::Version.new("5.5.0")
+  VERSION = Gem::Version.new("5.6.0")
 end

data/lib/stoplight/wiring/fail_safe_data_store.rb

@@ -62,9 +62,27 @@ module Stoplight
         end
       end
 
-      def get_metadata(config, *args, **kwargs)
-        with_fallback(:get_metadata, config, *args, **kwargs) do
-          data_store.get_metadata(config, *args, **kwargs)
+      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
 
@@ -104,6 +122,12 @@ module Stoplight
         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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stoplight
 version: !ruby/object:Gem::Version
-  version: 5.5.0
+  version: 5.6.0
 platform: ruby
 authors:
 - Cameron Desautels
@@ -47,6 +47,7 @@ files:
 - lib/stoplight/admin/actions/lock_all_green.rb
 - lib/stoplight/admin/actions/lock_green.rb
 - lib/stoplight/admin/actions/lock_red.rb
+- lib/stoplight/admin/actions/remove.rb
 - lib/stoplight/admin/actions/stats.rb
 - lib/stoplight/admin/actions/unlock.rb
 - lib/stoplight/admin/dependencies.rb
@@ -66,8 +67,9 @@ files:
 - lib/stoplight/domain/light.rb
 - lib/stoplight/domain/light/configuration_builder_interface.rb
 - lib/stoplight/domain/light_factory.rb
-- lib/stoplight/domain/metadata.rb
+- lib/stoplight/domain/metrics.rb
 - lib/stoplight/domain/state.rb
+- lib/stoplight/domain/state_snapshot.rb
 - lib/stoplight/domain/state_transition_notifier.rb
 - lib/stoplight/domain/strategies/green_run_strategy.rb
 - lib/stoplight/domain/strategies/red_run_strategy.rb
@@ -83,9 +85,11 @@ files:
 - lib/stoplight/domain/traffic_recovery/base.rb
 - lib/stoplight/domain/traffic_recovery/consecutive_successes.rb
 - lib/stoplight/infrastructure/data_store/memory.rb
+- lib/stoplight/infrastructure/data_store/memory/metrics.rb
 - lib/stoplight/infrastructure/data_store/memory/sliding_window.rb
+- lib/stoplight/infrastructure/data_store/memory/state.rb
 - lib/stoplight/infrastructure/data_store/redis.rb
-- lib/stoplight/infrastructure/data_store/redis/get_metadata.lua
+- lib/stoplight/infrastructure/data_store/redis/get_metrics.lua
 - lib/stoplight/infrastructure/data_store/redis/lua.rb
 - lib/stoplight/infrastructure/data_store/redis/record_failure.lua
 - lib/stoplight/infrastructure/data_store/redis/record_success.lua

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

@@ -1,38 +0,0 @@
-local number_of_metric_buckets = tonumber(ARGV[1])
-local number_of_recovery_buckets = tonumber(ARGV[2])
-local window_start_ts = tonumber(ARGV[3])
-local window_end_ts = tonumber(ARGV[4])
-local recovery_window_start_ts = tonumber(ARGV[5])
-
-local metadata_key = KEYS[1]
-
--- It possible that after a successful recovery, Stoplight still see metrics
--- that are older than the recovery window. To prevent this from happening,
--- we need to limit the start time of the window to the time of the last recovery.
-local recovered_at = redis.call('HGET', metadata_key, "recovered_at")
-if recovered_at then
-  window_start_ts = math.max(window_start_ts, tonumber(recovered_at))
-end
-
-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)
-
-offset = offset + number_of_metric_buckets
-local recovery_probe_successes = count_events(offset, number_of_recovery_buckets, recovery_window_start_ts)
-
-offset = offset + number_of_recovery_buckets
-local recovery_probe_errors = count_events(offset, number_of_recovery_buckets, recovery_window_start_ts)
-
-local metadata = redis.call('HGETALL',  metadata_key)
-return {successes, errors, recovery_probe_successes, recovery_probe_errors, metadata}