gitlab-labkit 1.14.0 → 1.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b563d434908c8c7473aeebf5be13bf8f1f6d4f9634cbbdb389581bb5c4b14953
-  data.tar.gz: 0b004077e12eb342c449856c7eadfcae558ea78b024eca86f4686cb7b06ef0b1
+  metadata.gz: 55b7255672a78e7ce050b17dee4a50b0c9ceadd2093986dc0d5d3822076423b0
+  data.tar.gz: fe70e4a910d27fa2d8d1a61216825bb811a8a43b9fbd75d4c0bd32220e8551b3
 SHA512:
-  metadata.gz: 03cd36c29407a01003104a8893d4afefdf452875e286b7535590ddae7febabf8fede9193de3946ac25008b11a3210b7a4454fd85638c654270039b94383cfb01
-  data.tar.gz: c9679d0fcb0aa67389801afeabc0fe1e625193f77eab5d41911451df82145a26e020761132ae0a1646b3e3720fbc7f7743d420f7ad1745c5d8f88443151ee777
+  metadata.gz: 38e4de6ac2d9e677a269f757e4c01a1bb1d9e3ce4cec0065512a03d07650339ae6e5f27415be76ba02cc316c56e5fd8d4922389e856da152be527800a6f58de6
+  data.tar.gz: 613915d89f71db61f3a984ae979d704753c9284d196dc7f31c92426b0f037ded2c0140ea9fc778dbbd42bb7c0ccfa0884b3d67e3ebc38b791bc84edfa6cb852d

data/lib/labkit/rate_limit/evaluator.rb

@@ -25,7 +25,7 @@ module Labkit
         # Intentionally broad: fail-open applies to any unexpected error (network,
         # timeout, OOM) not only Redis protocol errors.
         log_error(e, identifier)
-        Result.new(matched: false, error: true)
+        Result.new(matched: false, error: true, action: :allow)
       end
 
       private
@@ -37,7 +37,7 @@ module Labkit
           return evaluate_rule(rule, identifier)
         end
 
-        Result.new(matched: false)
+        Result.new(matched: false, action: :allow)
       end
 
       def rule_matches?(rule, identifier)
@@ -51,8 +51,9 @@ module Labkit
 
         count = incr_with_ttl(redis_key, resolved_period)
         exceeded = count > resolved_limit
+        action = exceeded ? rule.action : :allow
 
-        Result.new(matched: true, exceeded: exceeded, action: rule.action, rule: rule)
+        Result.new(matched: true, exceeded: exceeded, action: action, rule: rule)
       end
 
       def build_redis_key(rule, identifier)

data/lib/labkit/rate_limit/limiter.rb

@@ -20,14 +20,14 @@ module Labkit
       NAME_PATTERN = /\A[a-z0-9_]+\z/
 
       def initialize(name:, rules:, redis: nil, logger: nil)
-        resolved_logger = logger || RateLimit.config.logger || Labkit::Logging::JsonLogger.new($stdout)
-        validated_name = validate_name!(name, resolved_logger)
+        @logger = logger || RateLimit.config.logger || Labkit::Logging::JsonLogger.new($stdout)
+        @name = validate_name!(name)
 
         @evaluator = Evaluator.new(
-          name: validated_name,
-          rules: rules,
+          name: @name,
+          rules: prepare_rules(rules),
           redis: redis || RateLimit.config.redis,
-          logger: resolved_logger
+          logger: @logger
         )
       end
 
@@ -40,14 +40,53 @@ module Labkit
 
       private
 
-      def validate_name!(name, logger)
+      def validate_name!(name)
         raise ArgumentError, "name must be a non-empty String" unless name.is_a?(String) && !name.empty?
         return name if NAME_PATTERN.match?(name)
 
         raise ArgumentError, "Invalid name: #{name.inspect}. Must match /\\A[a-z0-9_]+\\z/" if Labkit.dev_or_test?
 
         sanitized = name.gsub(/[^a-z0-9_]/, "_")
-        logger.warn(message: "rate_limit_invalid_name", name: name, sanitized: sanitized)
+        @logger.warn(message: "rate_limit_invalid_name", name: name, sanitized: sanitized)
+        sanitized
+      end
+
+      # Validates and deduplicates rule names before passing rules to Evaluator.
+      # In dev/test: raises on invalid format or duplicate names.
+      # In production: sanitizes invalid names (WARN) and drops duplicates (WARN, first wins).
+      # Returns an array of rules with sanitized names.
+      def prepare_rules(rules)
+        seen = {}
+        rules.each_with_index.filter_map do |rule, idx|
+          sanitized = sanitize_rule_name(rule.name)
+
+          if seen.key?(sanitized)
+            raise ArgumentError, "Duplicate rule name #{sanitized.inspect} at index #{idx}" if Labkit.dev_or_test?
+
+            @logger.warn(
+              message: "rate_limit_duplicate_rule_name",
+              name: sanitized,
+              dropped_occurrence: idx
+            )
+            next nil
+          end
+
+          seen[sanitized] = true
+          sanitized == rule.name ? rule : rule.with(name: sanitized) # rubocop:disable CodeReuse/ActiveRecord
+        end
+      end
+
+      def sanitize_rule_name(name)
+        s = name.to_s
+        return s if RULE_NAME_PATTERN.match?(s) && s.length <= RULE_NAME_MAX_LENGTH
+
+        sanitized = s.downcase.gsub(/[^a-z0-9_]/, "_")[0, RULE_NAME_MAX_LENGTH]
+        sanitized = "unnamed_rule" if sanitized.empty?
+        @logger.warn(
+          message: "rate_limit_invalid_rule_name",
+          original_name: s,
+          sanitized_name: sanitized
+        )
         sanitized
       end
     end

data/lib/labkit/rate_limit/result.rb

@@ -5,11 +5,16 @@ module Labkit
     # Result is the return value of Limiter#check.
     # matched?  - true if a rule's match conditions were satisfied
     # exceeded? - true if the matched rule's counter exceeded its limit
-    # action    - :block or :log (nil when matched? is false)
+    # action    - the outcome: what the caller should do
+    #             :block = rule matched, exceeded, rule configured to block
+    #             :log   = rule matched, exceeded, rule configured to log only
+    #             :allow = rule matched but count within limit, or
+    #                      no rule matched, or error (fail-open)
+    #             The rule's configured action is available via rule.action
     # rule      - the matched Rule object (nil when matched? is false)
     # error?    - true if Redis was unavailable; result fails open (exceeded? is false)
     Result = Data.define(:matched, :exceeded, :action, :rule, :error) do
-      def initialize(matched:, exceeded: false, action: nil, rule: nil, error: false)
+      def initialize(matched:, action:, exceeded: false, rule: nil, error: false)
         super
       end
 

data/lib/labkit/rate_limit/rule.rb

@@ -2,6 +2,10 @@
 
 module Labkit
   module RateLimit
+    KNOWN_ACTIONS = [:block, :log].freeze
+    RULE_NAME_PATTERN = /\A[a-z0-9_]+\z/
+    RULE_NAME_MAX_LENGTH = 64
+
     # Rule is a value object describing a single rate limit rule.
     # name            - stable identifier used in Redis keys and log entries
     # match           - hash of identifier key/value pairs that must all match for
@@ -10,14 +14,31 @@ module Labkit
     # period          - window in seconds; may be a callable (resolved per check)
     # action          - :block (enforce) or :log (count and log, but do not block)
     # characteristics - identifier keys used to build the compound Redis counter key
+    #
+    # +name+ must be a lowercase alphanumeric-and-underscore string of at most 64
+    # characters. It is used as the middle segment of every Redis counter key for
+    # this rule, so changing a rule's name mid-window abandons its in-flight counters.
     Rule = Data.define(:name, :match, :limit, :period, :action, :characteristics) do
       def initialize(name:, limit:, period:, characteristics:, match: {}, action: :block)
+        raise ArgumentError, "name must be a String or Symbol, got #{name.class}" unless name.is_a?(String) || name.is_a?(Symbol)
+
+        name_str = name.to_s
+        raise ArgumentError, "name must not be empty" if name_str.empty?
+
+        action_sym = action.to_sym
+        raise ArgumentError, "Invalid action: #{action.inspect}. Must be one of: #{KNOWN_ACTIONS.inspect}" unless KNOWN_ACTIONS.include?(action_sym)
+
+        if Labkit.dev_or_test?
+          raise ArgumentError, "Invalid rule name: #{name.inspect}. Must match /\\A[a-z0-9_]+\\z/" unless RULE_NAME_PATTERN.match?(name_str)
+          raise ArgumentError, "Rule name too long: #{name.inspect}. Maximum 64 characters" if name_str.length > RULE_NAME_MAX_LENGTH
+        end
+
         super(
-          name: name.to_s.tr(":", "_"),
+          name: name_str.freeze,
           match: match.transform_keys(&:to_sym).freeze,
           limit: limit,
           period: period,
-          action: action.to_sym,
+          action: action_sym,
           characteristics: Array(characteristics).map(&:to_sym).freeze
         )
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-labkit
 version: !ruby/object:Gem::Version
-  version: 1.14.0
+  version: 1.15.1
 platform: ruby
 authors:
 - Andrew Newdigate