stoplight 5.3.5 → 5.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c930c989a3184cfc4fb254c720a854caf34fb56bbb550df150d65125969240b2
-  data.tar.gz: 3ca98448ca2a378d6101e4b10e4567adb24bc65c2747d77bccf4b9386aeba64c
+  metadata.gz: e14702003b76fde01b28e5266b392f5d55b2924c83365a0ab122f11aebf2e4a7
+  data.tar.gz: e9c1b348b2637aa66408de62a2bbbc24b9b73927ca9712a8b4137446e336cd0a
 SHA512:
-  metadata.gz: caf3fbc0b32e823a3877525841ab46948fdedbda6791da8006ded3c194229aad7add1c01df82f60b406606a34481a40535662036b2f21caf1ea953ed58ae3eab
-  data.tar.gz: 0d372655a21b4f2ebf04973a6fa41ae4e24e1bab2851bfef69c6ba866a2e38231cdc2a13f4c3afb7a267f56c7a5e3040d88c4ce0602f6b4392b9216fd57d6f2a
+  metadata.gz: 1601dd8a7fae2e9c8f89a52556c8f931d3712d71648300aef0e3dae226c9998b7b1fa35e7fa0ce151d943e961473e012ca382b718bb50b44000f5a43e4d667b8
+  data.tar.gz: 7c4e9696009e01bea1908cd3212d4625cc0ac3e03205d1cd69e4471f9aec4f3add7f101e58b393df210658e6be2c2d42b5d4a2ddedd954f832053505e291f232

data/lib/stoplight/data_store/fail_safe.rb

@@ -48,13 +48,13 @@ module Stoplight
       end
 
       def get_metadata(config)
-        with_fallback(EmptyMetadata, config) do
+        with_fallback(Metadata.new, config) do
           data_store.get_metadata(config)
         end
       end
 
       def record_failure(config, failure)
-        with_fallback(EmptyMetadata, config) do
+        with_fallback(Metadata.new, config) do
           data_store.record_failure(config, failure)
         end
       end
@@ -66,13 +66,13 @@ module Stoplight
       end
 
       def record_recovery_probe_success(config, **args)
-        with_fallback(EmptyMetadata, config) do
+        with_fallback(Metadata.new, config) do
           data_store.record_recovery_probe_success(config, **args)
         end
       end
 
       def record_recovery_probe_failure(config, failure)
-        with_fallback(EmptyMetadata, config) do
+        with_fallback(Metadata.new, config) do
           data_store.record_recovery_probe_failure(config, failure)
         end
       end

data/lib/stoplight/data_store/memory.rb

@@ -7,6 +7,7 @@ module Stoplight
     # @see Base
     class Memory < Base
       include MonitorMixin
+
       KEY_SEPARATOR = ":"
 
       def initialize
@@ -29,16 +30,16 @@ module Stoplight
       # @return [Stoplight::Metadata]
       def get_metadata(config)
         light_name = config.name
-        window_end = Time.now
-        recovery_window = (window_end - config.cool_off_time + 1)..window_end
 
         synchronize do
+          current_time = Time.now
+          recovery_window = (current_time - config.cool_off_time)..current_time
           recovered_at = @metadata[light_name].recovered_at
           window = if config.window_size
-            window_start = [recovered_at, (window_end - config.window_size + 1)].compact.max
-            (window_start..window_end)
+            window_start = [recovered_at, (current_time - config.window_size)].compact.max
+            (window_start..current_time)
           else
-            (..window_end)
+            (..current_time)
           end
 
           errors = @errors[config.name].count do |request_time|
@@ -57,6 +58,7 @@ module Stoplight
           end
 
           @metadata[light_name].with(
+            current_time:,
             errors:,
             successes:,
             recovery_probe_errors:,
@@ -170,17 +172,14 @@ module Stoplight
           cleanup(@recovery_probe_successes[light_name], window_size: config.cool_off_time)
 
           metadata = @metadata[light_name]
-          recovery_started_at = metadata.recovery_started_at || request_time
           @metadata[light_name] = if metadata.last_success_at.nil? || request_time > metadata.last_success_at
             metadata.with(
               last_success_at: request_time,
-              recovery_started_at:,
               consecutive_errors: 0,
               consecutive_successes: metadata.consecutive_successes.succ
             )
           else
             metadata.with(
-              recovery_started_at:,
               consecutive_errors: 0,
               consecutive_successes: metadata.consecutive_successes.succ
             )
@@ -259,9 +258,7 @@ module Stoplight
 
         synchronize do
           metadata = @metadata[light_name]
-          if metadata.recovery_started_at
-            false
-          else
+          if metadata.recovery_started_at.nil?
             @metadata[light_name] = metadata.with(
               recovery_started_at: current_time,
               recovery_scheduled_after: nil,
@@ -269,6 +266,13 @@ module Stoplight
               breached_at: nil
             )
             true
+          else
+            @metadata[light_name] = metadata.with(
+              recovery_scheduled_after: nil,
+              recovered_at: nil,
+              breached_at: nil
+            )
+            false
           end
         end
       end

data/lib/stoplight/data_store/redis.rb

@@ -94,8 +94,8 @@ module Stoplight
       def get_metadata(config)
         detect_clock_skew
 
-        window_end = Time.now
-        window_end_ts = window_end.to_i
+        current_time = Time.now
+        window_end_ts = current_time.to_i
         window_start_ts = window_end_ts - [config.window_size, Base::METRICS_RETENTION_TIME].compact.min.to_i
         recovery_window_start_ts = window_end_ts - config.cool_off_time.to_i
 
@@ -133,10 +133,11 @@ module Stoplight
         last_error = normalize_failure(last_error_json, config.error_notifier) if last_error_json
 
         Metadata.new(
-          successes: successes,
-          errors: errors,
-          recovery_probe_successes: recovery_probe_successes,
-          recovery_probe_errors: recovery_probe_errors,
+          current_time:,
+          successes:,
+          errors:,
+          recovery_probe_successes:,
+          recovery_probe_errors:,
           last_error:,
           **meta_hash
         )

data/lib/stoplight/light/green_run_strategy.rb

@@ -12,10 +12,11 @@ module Stoplight
       # Executes the provided code block when the light is in the green state.
       #
       # @param fallback [Proc, nil] A fallback proc to execute in case of an error.
+      # @param metadata [Stoplight::Metadata] Metadata capturing the current state of the light.
       # @yield The code block to execute.
       # @return [Object] The result of the code block if successful.
       # @raise [Exception] Re-raises the error if it is not tracked or no fallback is provided.
-      def execute(fallback, &code)
+      def execute(fallback, metadata:, &code)
         # TODO: Consider implementing sampling rate to limit the memory footprint
         code.call.tap { record_success }
       rescue => error

data/lib/stoplight/light/red_run_strategy.rb

@@ -12,9 +12,10 @@ module Stoplight
       # Executes the fallback proc when the light is in the red state.
       #
       # @param fallback [Proc, nil] A fallback proc to execute instead of the code block.
+      # @param metadata [Stoplight::Metadata] Metadata capturing the current state of the light.
       # @return [Object, nil] The result of the fallback proc if provided.
       # @raise [Stoplight::Error::RedLight] Raises an error if no fallback is provided.
-      def execute(fallback)
+      def execute(fallback, metadata:)
         if fallback
           fallback.call(nil)
         else

data/lib/stoplight/light/run_strategy.rb

@@ -22,7 +22,9 @@ module Stoplight
         @data_store = config.data_store
       end
 
-      def execute(fallback, &code)
+      # @param fallback [Proc, nil] A fallback proc to execute in case of an error.
+      # @param metadata [Stoplight::Metadata] Metadata capturing the current state of the light.
+      def execute(fallback, metadata:, &code)
         raise NotImplementedError, "Subclasses must implement the execute method"
       end
     end

data/lib/stoplight/light/yellow_run_strategy.rb

@@ -13,10 +13,12 @@ module Stoplight
       # Executes the provided code block when the light is in the yellow state.
       #
       # @param fallback [Proc, nil] A fallback proc to execute in case of an error.
+      # @param metadata [Stoplight::Metadata] Metadata capturing the current state of the light.
       # @yield The code block to execute.
       # @return [Object] The result of the code block if successful.
       # @raise [Exception] Re-raises the error if it is not tracked or no fallback is provided.
-      def execute(fallback, &code)
+      def execute(fallback, metadata:, &code)
+        transition_to_yellow(metadata:)
         # TODO: We need to employ a probabilistic approach here to avoid "thundering herd" problem
         code.call.tap { record_recovery_probe_success }
       rescue => error
@@ -47,6 +49,18 @@ module Stoplight
         recover(metadata)
       end
 
+      # @param metadata [Stoplight::Metadata]
+      # @return [void]
+      def transition_to_yellow(metadata:)
+        return unless metadata.color == Color::YELLOW
+
+        if metadata.recovery_scheduled_after && config.data_store.transition_to_color(config, Color::YELLOW)
+          config.notifiers.each do |notifier|
+            notifier.notify(config, Color::RED, Color::YELLOW, nil)
+          end
+        end
+      end
+
       private def recover(metadata)
         recovery_result = config.traffic_recovery.determine_color(config, metadata)
 
@@ -60,7 +74,7 @@ module Stoplight
         when TrafficRecovery::YELLOW
           if data_store.transition_to_color(config, Color::YELLOW)
             config.notifiers.each do |notifier|
-              notifier.notify(config, Color::GREEN, Color::YELLOW, nil)
+              notifier.notify(config, Color::RED, Color::YELLOW, nil)
             end
           end
         when TrafficRecovery::RED

data/lib/stoplight/light.rb

@@ -32,10 +32,7 @@ module Stoplight
     #
     # @return [String]
     def state
-      config
-        .data_store
-        .get_metadata(config)
-        .locked_state
+      metadata.locked_state
     end
 
     # Returns current color:
@@ -49,10 +46,7 @@ module Stoplight
     #
     # @return [String] returns current light color
     def color
-      config
-        .data_store
-        .get_metadata(config)
-        .color
+      metadata.color
     end
 
     # Runs the given block of code with this circuit breaker
@@ -72,8 +66,10 @@ module Stoplight
     def run(fallback = nil, &code)
       raise ArgumentError, "nothing to run. Please, pass a block into `Light#run`" unless block_given?
 
-      strategy = state_strategy_factory(color)
-      strategy.execute(fallback, &code)
+      metadata.then do |metadata|
+        strategy = state_strategy_factory(metadata.color)
+        strategy.execute(fallback, metadata:, &code)
+      end
     end
 
     # Locks light in either +State::LOCKED_RED+ or +State::LOCKED_GREEN+
@@ -186,5 +182,10 @@ module Stoplight
     def reconfigure(config)
       self.class.new(config)
     end
+
+    # @return [Stoplight::Metadata]
+    def metadata
+      config.data_store.get_metadata(config)
+    end
   end
 end

data/lib/stoplight/metadata.rb

@@ -16,9 +16,11 @@ module Stoplight
     :locked_state,
     :recovery_scheduled_after,
     :recovery_started_at,
-    :recovered_at
+    :recovered_at,
+    :current_time
   ) do
     def initialize(
+      current_time: Time.now,
       successes: 0,
       errors: 0,
       recovery_probe_successes: 0,
@@ -49,6 +51,7 @@ module Stoplight
         recovery_scheduled_after: (Time.at(Integer(recovery_scheduled_after)) if recovery_scheduled_after),
         recovery_started_at: (Time.at(Integer(recovery_started_at)) if recovery_started_at),
         recovered_at: (Time.at(Integer(recovered_at)) if recovered_at),
+        current_time:,
       )
     end
 
@@ -59,17 +62,16 @@ module Stoplight
     # @param kwargs [Hash{Symbol => Object}]
     # @return [Metadata]
     def with(**kwargs)
-      self.class.new(**to_h.merge(kwargs))
+      self.class.new(**to_h.merge(current_time: Time.now, **kwargs))
     end
 
-    # @param at [Time] (Time.now) the moment of time when the color is determined
     # @return [String] one of +Color::GREEN+, +Color::RED+, or +Color::YELLOW+
-    def color(at: Time.now)
+    def color
       if locked_state == State::LOCKED_GREEN
         Color::GREEN
       elsif locked_state == State::LOCKED_RED
         Color::RED
-      elsif (recovery_scheduled_after && recovery_scheduled_after < at) || recovery_started_at
+      elsif (recovery_scheduled_after && recovery_scheduled_after < current_time) || recovery_started_at
         Color::YELLOW
       elsif breached_at
         Color::RED

data/lib/stoplight/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stoplight
 version: !ruby/object:Gem::Version
-  version: 5.3.5
+  version: 5.3.8
 platform: ruby
 authors:
 - Cameron Desautels
@@ -76,7 +76,6 @@ files:
 - lib/stoplight/data_store/redis/transition_to_red.lua
 - lib/stoplight/data_store/redis/transition_to_yellow.lua
 - lib/stoplight/default.rb
-- lib/stoplight/empty_metadata.rb
 - lib/stoplight/error.rb
 - lib/stoplight/failure.rb
 - lib/stoplight/light.rb

data/lib/stoplight/empty_metadata.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  EmptyMetadata = Metadata.new
-end