stoplight 5.3.1 → 5.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d9c236d51c7ba9b67ccbc0be19c1836b90b2a1b1f6b9e38cdfcfa28cfd85d5e
-  data.tar.gz: 85f04de041217bfd4ad1d0892d637847db62dba16e3dab8b00b5cb87b0c73725
+  metadata.gz: e14702003b76fde01b28e5266b392f5d55b2924c83365a0ab122f11aebf2e4a7
+  data.tar.gz: e9c1b348b2637aa66408de62a2bbbc24b9b73927ca9712a8b4137446e336cd0a
 SHA512:
-  metadata.gz: 6c5f9dfe0b88fb11ce8e2f830d73101ad39ed5a3c398d08e0ab4afd90c55246a4f62717f1eca4c1e463669ef123d8496e8525fc935b84f323ec7c15469d1db24
-  data.tar.gz: 267bac02ac372e70646820ffee6e6209fe6de8fd26658c2975cd08f079676cb5862e41a5154e1f58d6897f4ede79b5284fad1678310cc458867fcedc5466f874
+  metadata.gz: 1601dd8a7fae2e9c8f89a52556c8f931d3712d71648300aef0e3dae226c9998b7b1fa35e7fa0ce151d943e961473e012ca382b718bb50b44000f5a43e4d667b8
+  data.tar.gz: 7c4e9696009e01bea1908cd3212d4625cc0ac3e03205d1cd69e4471f9aec4f3add7f101e58b393df210658e6be2c2d42b5d4a2ddedd954f832053505e291f232

data/README.md

@@ -3,9 +3,8 @@
 [![Version badge][]][version]
 [![Build badge][]][build]
 [![Coverage badge][]][coverage]
-[![Climate badge][]][climate]
 
-Stoplight is traffic control for code. It's an implementation of the circuit breaker pattern in Ruby.
+Stoplight is a traffic control for code. It's an implementation of the circuit breaker pattern in Ruby.
 
 ---
 
@@ -103,7 +102,7 @@ light.color # => "red"
 After one minute, the light transitions to yellow, allowing a test execution:
 
 ```ruby
-# Wait for the cool off time
+# Wait for the cool-off time
 sleep 60
 light.run { 1 / 1 } #=> 1
 ```
@@ -130,7 +129,7 @@ receives `nil`. In both cases, the return value of the fallback becomes the retu
 
 ## Admin Panel
 
-Stoplight goes with a built-in Admin Panel that can track all active Lights and manually lock them in the desired state (`Green` or `Red`). Locking lights in certain states might be helpful in scenarios like E2E testing.
+Stoplight comes with a built-in Admin Panel that can track all active Lights and manually lock them in the desired state (`Green` or `Red`). Locking lights in certain states might be helpful in scenarios like E2E testing.
 
 To add Admin Panel protected by basic authentication to your Rails project, add this configuration to your `config/routes.rb` file.
 
@@ -378,7 +377,12 @@ single successful recovery probe will resume traffic flow.
 
 ### Data Store
 
-Stoplight uses an in-memory data store out of the box:
+Stoplight officially supports three data stores:
+- In-memory data store
+- Redis
+- Valkey
+
+By default, Stoplight uses an in-memory data store:
 
 ```ruby
 require "stoplight"
@@ -386,7 +390,9 @@ Stoplight::Default::DATA_STORE
 # => #<Stoplight::DataStore::Memory:...>
 ```
 
-For production environments, you'll likely want to use a persistent data store. Currently, [Redis] is the supported option:
+#### Redis for Production
+
+For production environments, you'll likely want to use a persistent data store. One of the supported options is [Redis].
 
 ```ruby
 # Configure Redis as the data store
@@ -399,9 +405,32 @@ Stoplight.configure do |config|
 end
 ```
 
-#### Connection Pooling with Redis
+#### Valkey Support
 
-For high-traffic applications or when you want to control a number of opened connections to Redis:
+Stoplight also supports [Valkey], a drop-in replacement for Redis.  
+Just point your Redis client to a Valkey instance and configure Stoplight as usual:
+
+```ruby
+# ...
+# We assume that Valkey is available on 127.0.0.1:6379 address
+valkey = Redis.new(url: "redis://127.0.0.1:6379")
+data_store = Stoplight::DataStore::Redis.new(valkey)
+
+Stoplight.configure do |config|
+  config.data_store = data_store
+  # ...
+end
+```
+
+#### DragonflyDB Support
+
+Although Stoplight does not officially support [DragonflyDB], it can be used with it. For details, you may refer to the official [DragonflyDB documentation].
+
+**NOTE**: Compatibility with [DragonflyDB] is not guaranteed, and results may vary. However, you are welcome to contribute to the project if you find any issues.
+
+#### Connection Pooling
+
+For high-traffic applications or when you want to control the number of open connections to the Data Store:
 
 ```ruby
 require "connection_pool"
@@ -415,7 +444,7 @@ end
 
 ### Notifiers
 
-Stoplight notifies when lights change state. Configure how these notifications are delivered:
+Stoplight notifies when the lights change state. Configure how these notifications are delivered:
 
 ```ruby
 # Log to a specific logger
@@ -540,9 +569,45 @@ stoplight = Stoplight("test-#{rand}")
 
 ## Maintenance Policy
 
-Stoplight supports the latest three minor versions of Ruby, which currently are: `3.2.x`, `3.3.x`, and `3.4.x`. Changing
-the minimum supported Ruby version is not considered a breaking change. We support the current stable Redis
-version (`7.4.x`) and the latest release of the previous major version (`6.2.x`)
+We focus on supporting current, secure versions rather than maintaining extensive backwards compatibility. We follow 
+semantic versioning and give reasonable notice before dropping support.
+
+### Stoplight Version Support
+
+We only actively support the latest major version of Stoplight.
+
+* ✅ Bug fixes and new features go to the current major version only (e.g., if you're on 4.x, upgrade to 5.x for fixes)
+* ✅ Upgrade guidance is provided in release notes for major version changes
+* ✅ We won't break compatibility in patch/minor releases
+* ✅ We may accept community-contributed security patches for the previous major version
+* ❌ We don't backport fixes to old Stoplight major versions
+* ❌ We don't add new features to old Stoplight major versions
+
+### What We Support
+
+**Ruby**: Major versions that receive security updates (see [Ruby Maintenance Branches]):
+
+* Currently: Ruby 3.2.x, 3.3.x and 3.4.x
+* We test against these versions in CI
+
+**Data Stores**: Current supported versions from upstream (versions that receive security updates):
+
+* Redis: 8.0.x, 7.4.x, 7.2.x, 6.2.x (following [Redis's support policy])
+* Valkey: 8.0.x, 7.2.x (following [Valkey's support policy])
+* We test against the latest version of each major release
+
+For dependencies:
+* ✅ We test all supported dependency combinations in CI
+* ✅ We investigate bug reports on supported dependency versions
+* ❌ We don't test unsupported dependency versions (e.g., Ruby 3.1, Redis 5.x)
+* ❌ We don't fix bugs specific to unsupported dependencies
+
+### When We Drop Support
+
+* Ruby: When Ruby core team ends security support, we drop it in our next major release
+* Data Stores: When Redis/Valkey ends maintenance, we drop it in our next major release
+
+Example: "Ruby 3.2 reaches end-of-life in March 2026, so Stoplight 6.0 will require Ruby 3.3+"
 
 ## Development
 
@@ -563,14 +628,12 @@ Fowler’s [CircuitBreaker][] article.
 [build]: https://github.com/bolshakov/stoplight/actions?query=branch%3Amaster
 [Coverage badge]: https://img.shields.io/coveralls/bolshakov/stoplight/master.svg?label=coverage
 [coverage]: https://coveralls.io/r/bolshakov/stoplight
-[Climate badge]: https://api.codeclimate.com/v1/badges/3451c2d281ffa345441a/maintainability
-[climate]: https://codeclimate.com/github/bolshakov/stoplight
 [stoplight-admin]: https://github.com/bolshakov/stoplight-admin
 [Semantic Versioning]: http://semver.org/spec/v2.0.0.html
 [the change log]: CHANGELOG.md
 [stoplight-sentry]: https://github.com/bolshakov/stoplight-sentry
 [stoplight-honeybadger]: https://github.com/qoqa/stoplight-honeybadger
-[notifier interface documentation]: https://github.com/bolshakov/stoplight/blob/master/lib/stoplight/notifier/generic.rb
+[notifier interface documentation]: https://github.com/bolshakov/stoplight/blob/main/lib/stoplight/notifier/generic.rb
 [camdez]: https://github.com/camdez
 [tfausak]: https://github.com/tfausak
 [bolshakov]: https://github.com/bolshakov
@@ -579,3 +642,9 @@ Fowler’s [CircuitBreaker][] article.
 [CircuitBreaker]: http://martinfowler.com/bliki/CircuitBreaker.html
 [Redis]: https://redis.io/
 [Git Flow wiki page]: https://github.com/bolshakov/stoplight/wiki/Git-Flow
+[Valkey]: https://valkey.io/
+[Ruby Maintenance Branches]: https://www.ruby-lang.org/en/downloads/branches/
+[Redis's support policy]: https://redis.io/about/releases/
+[Valkey's support policy]: https://valkey.io/topics/releases/
+[DragonflyDB]: https://www.dragonflydb.io/
+[DragonflyDB documentation]: https://www.dragonflydb.io/docs/managing-dragonfly/scripting#script-flags

data/lib/stoplight/data_store/fail_safe.rb

@@ -54,7 +54,7 @@ module Stoplight
       end
 
       def record_failure(config, failure)
-        with_fallback(nil, 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(nil, 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(nil, 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/get_metadata.lua

@@ -11,7 +11,7 @@ local metadata_key = KEYS[1]
 -- 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, recovered_at)
+  window_start_ts = math.max(window_start_ts, tonumber(recovered_at))
 end
 
 local function count_events(start_idx, bucket_count, start_ts)

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,28 +49,42 @@ 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)
 
         case recovery_result
-        when Color::GREEN
+        when TrafficRecovery::GREEN
           if data_store.transition_to_color(config, Color::GREEN)
             config.notifiers.each do |notifier|
               notifier.notify(config, Color::YELLOW, Color::GREEN, nil)
             end
           end
-        when Color::YELLOW
+        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 Color::RED
+        when TrafficRecovery::RED
           if data_store.transition_to_color(config, Color::RED)
             config.notifiers.each do |notifier|
               notifier.notify(config, Color::YELLOW, Color::RED, nil)
             end
           end
+        when TrafficRecovery::PASS
+          # No state change, do nothing
         else
           raise "recovery strategy returned an expected color: #{recovery_result}"
         end

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,13 +16,15 @@ module Stoplight
     :locked_state,
     :recovery_scheduled_after,
     :recovery_started_at,
-    :recovered_at
+    :recovered_at,
+    :current_time
   ) do
     def initialize(
-      successes: nil,
-      errors: nil,
-      recovery_probe_successes: nil,
-      recovery_probe_errors: nil,
+      current_time: Time.now,
+      successes: 0,
+      errors: 0,
+      recovery_probe_successes: 0,
+      recovery_probe_errors: 0,
       last_error_at: nil,
       last_success_at: nil,
       consecutive_errors: 0,
@@ -35,31 +37,41 @@ module Stoplight
       recovered_at: nil
     )
       super(
-        recovery_probe_successes:,
-        recovery_probe_errors:,
-        successes:,
-        errors:,
+        recovery_probe_successes: recovery_probe_successes.to_i,
+        recovery_probe_errors: recovery_probe_errors.to_i,
+        successes: successes.to_i,
+        errors: errors.to_i,
         last_error_at: (Time.at(Integer(last_error_at)) if last_error_at),
         last_success_at: (Time.at(Integer(last_success_at)) if last_success_at),
-        consecutive_errors: Integer(consecutive_errors),
-        consecutive_successes: Integer(consecutive_successes),
+        consecutive_errors: consecutive_errors.to_i,
+        consecutive_successes: consecutive_successes.to_i,
         last_error:,
         breached_at: (Time.at(Integer(breached_at)) if breached_at),
         locked_state: locked_state || State::UNLOCKED,
         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
 
-    # @param at [Time] (Time.now) the moment of time when the color is determined
+    # Creates a new Metadata instance with updated attributes. This method overrides
+    # the default +with+ method provided by +Data.define+ to ensure constructor
+    # logic is applied.
+    #
+    # @param kwargs [Hash{Symbol => Object}]
+    # @return [Metadata]
+    def with(**kwargs)
+      self.class.new(**to_h.merge(current_time: Time.now, **kwargs))
+    end
+
     # @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
@@ -72,7 +84,7 @@ module Stoplight
     #
     # @return [Float]
     def error_rate
-      if successes.nil? || errors.nil? || (successes + errors).zero?
+      if (successes + errors).zero?
         0.0
       else
         errors.fdiv(successes + errors)

data/lib/stoplight/traffic_recovery/base.rb

@@ -49,10 +49,7 @@ module Stoplight
       #
       # @param config [Stoplight::Light::Config]
       # @param metadata [Stoplight::Metadata]
-      # @return [String] One of the Stoplight::Color constants:
-      #   - Stoplight::Color::RED: Recovery failed, block all traffic
-      #   - Stoplight::Color::YELLOW: Continue recovery process
-      #   - Stoplight::Color::GREEN: Recovery successful, return to normal traffic flow
+      # @return [TrafficRecovery::Decision]
       def determine_color(config, metadata)
         raise NotImplementedError
       end

data/lib/stoplight/traffic_recovery/consecutive_successes.rb

@@ -49,16 +49,18 @@ module Stoplight
       #
       # @param config [Stoplight::Light::Config]
       # @param metadata [Stoplight::Metadata]
-      # @return [String]
+      # @return [TrafficRecovery::Decision]
       def determine_color(config, metadata)
+        return TrafficRecovery::PASS if metadata.color != Color::YELLOW
+
         recovery_started_at = metadata.recovery_started_at || metadata.recovery_scheduled_after
 
         if metadata.last_error_at && metadata.last_error_at >= recovery_started_at
-          Color::RED
+          TrafficRecovery::RED
         elsif [metadata.consecutive_successes, metadata.recovery_probe_successes].min >= config.recovery_threshold
-          Color::GREEN
+          TrafficRecovery::GREEN
         else
-          Color::YELLOW
+          TrafficRecovery::YELLOW
         end
       end
     end

data/lib/stoplight/traffic_recovery.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Stoplight
+  module TrafficRecovery
+    Decision = Data.define(:decision)
+    GREEN = Decision.new("green")
+    YELLOW = Decision.new("yellow")
+    RED = Decision.new("red")
+    PASS = Decision.new("pass")
+  end
+end

data/lib/stoplight/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Stoplight
-  VERSION = Gem::Version.new("5.3.1")
+  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.1
+  version: 5.3.8
 platform: ruby
 authors:
 - Cameron Desautels
@@ -97,6 +97,7 @@ files:
 - lib/stoplight/traffic_control/base.rb
 - lib/stoplight/traffic_control/consecutive_errors.rb
 - lib/stoplight/traffic_control/error_rate.rb
+- lib/stoplight/traffic_recovery.rb
 - lib/stoplight/traffic_recovery/base.rb
 - lib/stoplight/traffic_recovery/consecutive_successes.rb
 - lib/stoplight/version.rb