stoplight 5.8.3 → 6.0.0.rc2

data/lib/stoplight/infrastructure/redis/storage/registry.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Stoplight
+  module Infrastructure
+    module Redis
+      module Storage
+        class Registry
+          def initialize(redis:, key_space:, clock:, config_serializer:)
+            @redis = redis
+            @key_space = key_space
+            @clock = clock
+            @config_serializer = config_serializer
+          end
+
+          def ids
+            @redis.with do |conn|
+              conn.hkeys(key)
+            end
+          end
+
+          def register(config)
+            @redis.with do |conn|
+              conn.hset(
+                key,
+                config.id,
+                {
+                  meta: {
+                    version: 1,
+                    registered_at: @clock.current_time.to_i
+                  },
+                  config: @config_serializer.call(config)
+                }.to_json
+              )
+            end
+          end
+
+          def unregister(id)
+            @redis.with do |conn|
+              conn.hdel(key, id)
+            end
+          end
+
+          def all_configs
+            raw_lights_info = @redis.with do |conn|
+              conn.hgetall(key)
+            end
+            return [] unless raw_lights_info
+            raw_lights_info.filter_map do |_, config|
+              next unless config
+
+              begin
+                JSON.parse(config)["config"]
+              rescue JSON::ParserError
+                nil
+              end
+            end
+          end
+
+          def config_for(id)
+            raw_light_info = @redis.with do |conn|
+              conn.hget(key, id)
+            end
+            return unless raw_light_info
+            light_info = JSON.parse(raw_light_info)
+            light_info["config"]
+          end
+
+          private def key = @key_space.join("lights")
+        end
+      end
+    end
+  end
+end

data/lib/stoplight/infrastructure/redis/storage/scripting.rb

@@ -4,12 +4,63 @@ module Stoplight
   module Infrastructure
     module Redis
       module Storage
-        class Scripting < Infrastructure::Redis::DataStore::Scripting
-          SCRIPTS_ROOT = __dir__ => String
+        class Scripting
+          SCRIPTS_ROOT = T.must(__dir__)
           private_constant :SCRIPTS_ROOT
 
+          INCLUDE_DIRECTIVE = /^--\s*@include\s+([\w\-\/]+)$/
+          private_constant :INCLUDE_DIRECTIVE
+
           class << self
-            def default_scripts_root = SCRIPTS_ROOT
+            def default_scripts_path = [SCRIPTS_ROOT]
+          end
+
+          def initialize(redis:, scripts_path: self.class.default_scripts_path)
+            @scripts_path = scripts_path
+            @redis = redis
+            @shas = Hash.new do |hash, script_name|
+              hash[script_name] = Digest::SHA1.hexdigest(resolve_source(script_name))
+            end
+          end
+
+          def call(script_name, keys: [], args: [])
+            retried = false
+
+            begin
+              @redis.then do |client|
+                client.evalsha(@shas[script_name], keys: keys.map(&:to_s), argv: args.map(&:to_s))
+              end
+            rescue ::Redis::CommandError => error
+              if error.message.include?("NOSCRIPT") && !retried
+                retried = true
+                reload_script(script_name)
+                retry
+              else
+                raise error
+              end
+            end
+          end
+
+          private
+
+          def reload_script(script_name)
+            warn "Stoplight is unable to find the script '#{script_name}' in Redis's script cache. Reloading and retrying..."
+            @redis.then { |client| client.script(:load, resolve_source(script_name)) }
+          end
+
+          # Redis's Lua sandbox has no `require`, so an included script is spliced in as source text.
+          def resolve_source(script_name)
+            file_name = "#{script_name}.lua"
+
+            @scripts_path.each do |path|
+              script_path = File.join(path, file_name)
+              if File.exist?(script_path)
+                source = File.read(script_path)
+                return source.gsub(INCLUDE_DIRECTIVE) { resolve_source(T.must(Regexp.last_match(1))) }
+              end
+            end
+
+            raise Errno::ENOENT, "No such file #{file_name} @ #{@scripts_path}"
           end
         end
       end

data/lib/stoplight/infrastructure/redis/storage/state/transition_to_green.lua

@@ -1,5 +1,7 @@
+-- @include now
+
 local meta_key = KEYS[1]
-local current_ts = tonumber(ARGV[1])
+local current_ts = now() / 1000
 
 --  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)

data/lib/stoplight/infrastructure/redis/storage/state/transition_to_red.lua

@@ -1,6 +1,8 @@
+-- @include now
+
 local meta_key = KEYS[1]
-local current_ts = tonumber(ARGV[1])
-local recovery_scheduled_after_ts = tonumber(ARGV[2])
+local recovery_scheduled_after_ts = tonumber(ARGV[1])
+local current_ts = now() / 1000
 
 --  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)

data/lib/stoplight/infrastructure/redis/storage/state/transition_to_yellow.lua

@@ -1,5 +1,7 @@
+-- @include now
+
 local meta_key = KEYS[1]
-local current_ts = tonumber(ARGV[1])
+local current_ts = now() / 1000
 
 -- HSETNX returns 1 if field is new and was set, 0 if field already exists
 local became_yellow = redis.call('HSETNX', meta_key, 'recovery_started_at', current_ts)

data/lib/stoplight/infrastructure/redis/storage/state.rb

@@ -22,7 +22,7 @@ module Stoplight
         #     clock: SystemClock.new,
         #     redis: Redis.new,
         #     scripting: Scripting.new(redis:),
-        #     key_space: KeySpace.build(light_name: "payments", system_name: "main"),
+        #     key_space:,
         #     cool_off_time: 60
         #   )
         #
@@ -46,7 +46,7 @@ module Stoplight
             @clock = clock
             @cool_off_time = cool_off_time
 
-            @state_key = key_space.key(:state)
+            @state_key = key_space.join("state")
           end
 
           def set_state(state)
@@ -102,8 +102,8 @@ module Stoplight
           #
           def transition_to_green
             became_green = scripting.call(
-              :"state/transition_to_green",
-              args: [clock.current_time.to_f],
+              "state/transition_to_green",
+              args: [],
               keys: [state_key]
             )
             became_green == 1
@@ -113,8 +113,8 @@ module Stoplight
           #
           def transition_to_yellow
             became_yellow = scripting.call(
-              :"state/transition_to_yellow",
-              args: [clock.current_time.to_f],
+              "state/transition_to_yellow",
+              args: [],
               keys: [state_key]
             )
             became_yellow == 1
@@ -127,8 +127,8 @@ module Stoplight
             recovery_scheduled_after_ts = current_ts + cool_off_time
 
             became_red = scripting.call(
-              :"state/transition_to_red",
-              args: [current_ts, recovery_scheduled_after_ts],
+              "state/transition_to_red",
+              args: [recovery_scheduled_after_ts],
               keys: [state_key]
             )
 

data/lib/stoplight/infrastructure/redis/storage/unbounded_metrics/record_failure.lua

@@ -1,28 +1,27 @@
-local failure_ts = tonumber(ARGV[1])
-local failure_json = ARGV[2]
-local metrics_ttl = tonumber(ARGV[3])
+-- @include now
 
 local metrics_key = KEYS[1]
+local error_json = ARGV[1]
+local metrics_ttl = tonumber(ARGV[2])
 
 -- Update metadata
-local meta = redis.call('HMGET', metrics_key, 'last_error_at', 'consecutive_errors')
-local prev_failure_ts = tonumber(meta[1])
-local prev_consecutive_errors = tonumber(meta[2])
+local meta = redis.call('HMGET', metrics_key, 'consecutive_errors', "last_success_at")
+local prev_consecutive_errors = tonumber(meta[1])
+local last_success_at = meta[2]
+local failure_ts = now() / 1000.0
 
-if not prev_failure_ts or failure_ts > prev_failure_ts then
-  redis.call(
-    'HSET', metrics_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', metrics_key,
-    'consecutive_errors', (prev_consecutive_errors or 0) + 1,
-    'consecutive_successes', 0
-  )
-end
+local consecutive_errors = (prev_consecutive_errors or 0) + 1
+local consecutive_successes = 0
+
+-- Always update with current timestamp (out-of-order impossible with Redis time)
+redis.call(
+  'HSET', metrics_key,
+  'last_error_at', failure_ts,
+  'last_error_json', error_json,
+  'consecutive_errors', consecutive_errors,
+  'consecutive_successes', consecutive_successes
+)
 
 redis.call('EXPIRE', metrics_key, metrics_ttl)
+
+return {last_success_at, error_json, consecutive_errors, consecutive_successes}

data/lib/stoplight/infrastructure/redis/storage/unbounded_metrics/record_success.lua

@@ -1,26 +1,18 @@
-local request_ts = tonumber(ARGV[1])
-local metrics_ttl = tonumber(ARGV[2])
+-- @include now
 
 local metrics_key = KEYS[1]
+local metrics_ttl = tonumber(ARGV[1])
 
 -- Update metadata
-local meta = redis.call('HMGET', metrics_key, 'last_success_at', 'consecutive_successes')
-local prev_success_ts = tonumber(meta[1])
-local prev_consecutive_successes = tonumber(meta[2])
+local prev_consecutive_successes = tonumber(redis.call('HGET', metrics_key, 'consecutive_successes'))
+local request_ts = now() / 1000.0
 
-if not prev_success_ts or request_ts > prev_success_ts then
-  redis.call(
-    'HSET', metrics_key,
-    'last_success_at', request_ts,
-    'consecutive_errors', 0,
-    'consecutive_successes', (prev_consecutive_successes or 0) + 1
-  )
-else
-  redis.call(
-    'HSET', metrics_key,
-    'consecutive_errors', 0,
-    'consecutive_successes', (prev_consecutive_successes or 0) + 1
-  )
-end
+-- Always update with current timestamp (out-of-order impossible with Redis time)
+redis.call(
+  'HSET', metrics_key,
+  'last_success_at', request_ts,
+  'consecutive_errors', 0,
+  'consecutive_successes', (prev_consecutive_successes or 0) + 1
+)
 
 redis.call('EXPIRE', metrics_key, metrics_ttl)

data/lib/stoplight/infrastructure/redis/storage/unbounded_metrics.rb

@@ -58,7 +58,7 @@ module Stoplight
             @clock = clock
             @scripting = scripting
             @redis = redis
-            @metrics_key = key_space.key(:metrics)
+            @metrics_key = key_space.join("metrics")
           end
 
           # Get metrics for the current light
@@ -71,23 +71,15 @@ module Stoplight
               )
             end
 
-            Domain::MetricsSnapshot.new(
-              successes: nil, errors: nil,
-              consecutive_errors: consecutive_errors.to_i,
-              consecutive_successes: consecutive_successes.to_i,
-              last_error: deserialize_failure(last_error_json),
-              last_success_at: (clock.at(last_success_at.to_f) if last_success_at)
-            )
+            build_metrics_snapshot(consecutive_errors:, consecutive_successes:, last_error_json:, last_success_at:)
           end
 
           # Records successful circuit breaker execution
           #
           def record_success
-            timestamp = clock.current_time.to_f
-
             scripting.call(
-              :"unbounded_metrics/record_success",
-              args: [timestamp, metrics_ttl],
+              "unbounded_metrics/record_success",
+              args: [metrics_ttl],
               keys: [metrics_key]
             )
           end
@@ -97,16 +89,18 @@ module Stoplight
           def record_failure(exception)
             timestamp = clock.current_time.to_f
 
-            scripting.call(
-              :"unbounded_metrics/record_failure",
-              args: [timestamp, serialize_exception(exception, timestamp:), metrics_ttl],
+            last_success_at, last_error_json, consecutive_errors, consecutive_successes = scripting.call(
+              "unbounded_metrics/record_failure",
+              args: [serialize_exception(exception, timestamp:), metrics_ttl],
               keys: [metrics_key]
             )
+
+            build_metrics_snapshot(consecutive_errors:, consecutive_successes:, last_error_json:, last_success_at:)
           end
 
           def clear
             redis.with do |client|
-              client.hdel(metrics_key, "last_success_at", "last_error_json", "consecutive_errors", "consecutive_successes")
+              client.hdel(metrics_key, "last_success_at", "last_error_at", "last_error_json", "consecutive_errors", "consecutive_successes")
             end
           end
 
@@ -116,6 +110,16 @@ module Stoplight
           attr_reader :scripting
           attr_reader :metrics_key
           attr_reader :clock
+
+          def build_metrics_snapshot(consecutive_errors:, consecutive_successes:, last_error_json:, last_success_at:)
+            Domain::MetricsSnapshot.new(
+              successes: nil, errors: nil,
+              consecutive_errors: consecutive_errors.to_i,
+              consecutive_successes: consecutive_successes.to_i,
+              last_error: deserialize_failure(last_error_json),
+              last_success_at: (clock.at(last_success_at.to_f) if last_success_at)
+            )
+          end
         end
       end
     end

data/lib/stoplight/infrastructure/redis/storage/window_metrics/_evict.lua

@@ -0,0 +1,44 @@
+-- Subtracts each evicted bucket's counts from the running totals before deleting it, so
+-- total_successes/total_failures stay exact. Window is the half-open interval
+-- (bucket_ts - window_size, bucket_ts] - events at or before window_start are excluded.
+--
+-- O(K), K = buckets that had writes and are now stale. K <= window_size in steady state,
+-- but a long idle gap can dump the whole backlog into one call on the next write.
+--
+-- HMGET/HDEL splat fields through unpack(), capped at 8000 args - verified across every
+-- Redis/Valkey version this gem supports - so eviction runs in fixed-size batches.
+-- ZRANGE/ZREMRANGEBYSCORE aren't variadic and skip that limit; keeping both in the same
+-- atomic script call as the batched loop means ZREMRANGEBYSCORE always deletes exactly
+-- what ZRANGE read.
+local EVICT_BATCH_SIZE = 1000
+
+local function evict_buckets(metrics_key, ts_index_key, window_start)
+  local buckets = redis.call('ZRANGE', ts_index_key, '-inf', window_start, 'BYSCORE')
+  if #buckets == 0 then
+    return
+  end
+
+  for from = 1, #buckets, EVICT_BATCH_SIZE do
+    local to = math.min(from + EVICT_BATCH_SIZE - 1, #buckets)
+
+    local fields = {}
+    for i = from, to do
+      fields[#fields + 1] = buckets[i] .. ':f'
+      fields[#fields + 1] = buckets[i] .. ':s'
+    end
+
+    local values = redis.call('HMGET', metrics_key, unpack(fields))
+
+    local failures, successes = 0, 0
+    for i = 1, #values, 2 do
+      failures = failures + (tonumber(values[i]) or 0)
+      successes = successes + (tonumber(values[i + 1]) or 0)
+    end
+
+    redis.call('HINCRBY', metrics_key, 'total_failures', -failures)
+    redis.call('HINCRBY', metrics_key, 'total_successes', -successes)
+    redis.call('HDEL', metrics_key, unpack(fields))
+  end
+
+  redis.call('ZREMRANGEBYSCORE', ts_index_key, '-inf', window_start)
+end

data/lib/stoplight/infrastructure/redis/storage/window_metrics/metrics_snapshot.lua

@@ -1,26 +1,19 @@
-local number_of_metric_buckets = tonumber(ARGV[1])
-local window_start_ts = tonumber(ARGV[2])
-local window_end_ts = tonumber(ARGV[3])
-local metrics_fields = {}
-for idx = 4, #ARGV do
-  table.insert(metrics_fields, ARGV[idx])
-end
+-- @include now
+-- @include window_metrics/_evict
 
-local metrics_key = KEYS[1]
+local window_size = tonumber(ARGV[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 metrics_key  = KEYS[1]
+local ts_index_key = KEYS[2]
 
-local offset = 2
-local successes = count_events(2, number_of_metric_buckets, window_start_ts)
+local current_ts = now() / 1000.0
+evict_buckets(metrics_key, ts_index_key, math.floor(current_ts) - window_size)
 
-offset = offset + number_of_metric_buckets
-local errors = count_events(offset, number_of_metric_buckets, window_start_ts)
+-- copy arguments starting from index 2 to fields' tail
+local fields = {'total_successes','total_failures', unpack(ARGV, 2) }
+local metrics = redis.call('HMGET', metrics_key, unpack(fields))
 
-local metrics = redis.call('HMGET',  metrics_key, unpack(metrics_fields))
-return {successes, errors, unpack(metrics)}
+metrics[1] = tonumber(metrics[1]) or 0 -- total_successes
+metrics[2] = tonumber(metrics[2]) or 0 -- total_failures
+
+return metrics

data/lib/stoplight/infrastructure/redis/storage/window_metrics/record_failure.lua

@@ -1,36 +1,38 @@
-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 metrics_key = KEYS[1]
-local failures_key = KEYS[2]
-
--- Record failure
-if failures_key ~= nil then
-  redis.call('ZADD', failures_key, failure_ts, failure_id)
-  redis.call('EXPIRE', failures_key, bucket_ttl) -- Not supported in Redis 6.2:, 'NX')
-end
-
--- Update metadata
-local meta = redis.call('HMGET', metrics_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', metrics_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', metrics_key,
-    'consecutive_errors', (prev_consecutive_errors or 0) + 1,
-    'consecutive_successes', 0
-  )
-end
-redis.call('EXPIRE', metrics_key, metadata_ttl) -- Not supported in Redis 6.2:, 'GT')
+-- @include now
+-- @include window_metrics/_evict
+
+local failure_json = ARGV[1]
+local window_size  = tonumber(ARGV[2])
+local metadata_ttl = tonumber(ARGV[3])
+
+local metrics_key  = KEYS[1]
+local ts_index_key = KEYS[2]
+local request_ts   = now() / 1000.0
+local bucket_ts    = math.floor(request_ts)
+
+evict_buckets(metrics_key, ts_index_key, bucket_ts - window_size)
+
+local bucket = 'bucket:' .. bucket_ts
+redis.call('HINCRBY', metrics_key, bucket .. ':f', 1)
+redis.call('HINCRBY', metrics_key, 'total_failures', 1)
+redis.call('ZADD', ts_index_key, bucket_ts, bucket)
+
+local consecutive_errors = redis.call('HINCRBY', metrics_key, 'consecutive_errors', 1)
+
+-- Always update with current timestamp (out-of-order impossible with Redis time)
+redis.call(
+  'HSET', metrics_key,
+  'last_error_at', request_ts,
+  'last_error_json', failure_json,
+  'consecutive_successes', 0
+)
+
+redis.call('EXPIRE', metrics_key, metadata_ttl)
+redis.call('EXPIRE', ts_index_key, metadata_ttl)
+
+local result = redis.call('HMGET', metrics_key, 'last_success_at', 'total_successes', 'total_failures')
+local last_success_at = result[1]
+local total_successes = tonumber(result[2]) or 0
+local total_failures = tonumber(result[3]) or 0
+
+return {total_successes, total_failures, last_success_at, failure_json, consecutive_errors, 0}

data/lib/stoplight/infrastructure/redis/storage/window_metrics/record_success.lua

@@ -1,35 +1,28 @@
-local request_ts = tonumber(ARGV[1])
-local request_id = ARGV[2]
-local bucket_ttl = tonumber(ARGV[3])
-local metadata_ttl = tonumber(ARGV[4])
+-- @include now
+-- @include window_metrics/_evict
 
-local metrics_key = KEYS[1]
-local successes_key = KEYS[2]
+local window_size  = tonumber(ARGV[1])
+local metadata_ttl = tonumber(ARGV[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
+local metrics_key  = KEYS[1]
+local ts_index_key = KEYS[2]
+local request_ts   = now() / 1000.0
+local bucket_ts    = math.floor(request_ts)
 
--- Update metadata
-local meta = redis.call('HMGET', metrics_key, 'last_success_at', 'consecutive_successes')
-local prev_success_ts = tonumber(meta[1])
-local prev_consecutive_successes = tonumber(meta[2])
+evict_buckets(metrics_key, ts_index_key, bucket_ts - window_size)
 
-if not prev_success_ts or request_ts > prev_success_ts then
-  redis.call(
-    'HSET', metrics_key,
-    'last_success_at', request_ts,
-    'consecutive_errors', 0,
-    'consecutive_successes', (prev_consecutive_successes or 0) + 1
-  )
-else
-  redis.call(
-    'HSET', metrics_key,
-    'consecutive_errors', 0,
-    'consecutive_successes', (prev_consecutive_successes or 0) + 1
-  )
-end
+local bucket = 'bucket:' .. bucket_ts
+redis.call('HINCRBY', metrics_key, bucket .. ':s', 1)
+redis.call('HINCRBY', metrics_key, 'total_successes', 1)
+redis.call('ZADD', ts_index_key, bucket_ts, bucket)
 
-redis.call('EXPIRE', metrics_key, metadata_ttl) -- Not supported in Redis 6.2:, 'GT')
+-- Always update with current timestamp (out-of-order impossible with Redis time)
+redis.call(
+  'HSET', metrics_key,
+  'last_success_at', request_ts,
+  'consecutive_errors', 0
+)
+
+redis.call('HINCRBY', metrics_key, 'consecutive_successes', 1)
+redis.call('EXPIRE', metrics_key, metadata_ttl)
+redis.call('EXPIRE', ts_index_key, metadata_ttl)