featureflip 2.7.0 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d0798d6f9dde45580a5345467cfcbc108b01a0bda1ed9c0224a6e58305ec9bd
-  data.tar.gz: d7a7ceca0d72477e0987ee83b0af3bdcee069f47add6ecc89a42bb7c9cb635e4
+  metadata.gz: 4dfdc2e9de3795a36a917d2a748184853bbd1c30362dd313ac70e386a4d0758c
+  data.tar.gz: e878ef6a553b2948435fc004b905f84015433b42625721d41311c5cb55e87654
 SHA512:
-  metadata.gz: 2546ac239e8b8c0b120caa1d8286ad9a58e4fe23900a58cb63343ad469e9e324548ebac72ea194c102c023e5de2ef2e88fd344c80d15beb49dfc18803a3bd711
-  data.tar.gz: 6393ec68c36a42813a537fa699e9801132606d273264c142b8d75082c0fc7d260160b27aac53306d49a14bd2d895de2da57e8284690c8affb031076a76500a47
+  metadata.gz: 871ae6a42bfcc7663a805a70935e2ac6b5a746a879df937343239f5f833c00be0990890f0ec47684a1beca0507160439274e26a606ef957510a3aa400d442929
+  data.tar.gz: d793281fb6b00d5cfeb5226c89c035fa17d6fad5d7af1876eac1c7d8c4c1290452c2067b6b9c8106795e4511451e43ef4debc399e660b245b3f7685507c494af

data/lib/featureflip/data_source/streaming.rb

@@ -36,7 +36,7 @@ module Featureflip
       RECONNECT_BASE_DELAY_SECONDS = 1
       MAX_BACKOFF_SECONDS = 30
 
-      def initialize(sdk_key:, config:, http_client:, on_flag_updated:, on_flag_deleted:, on_segment_updated:, on_error:, on_sync: nil, on_give_up: nil)
+      def initialize(sdk_key:, config:, http_client:, on_flag_updated:, on_flag_deleted:, on_segment_updated:, on_error:, on_sync: nil, on_fallback_to_polling: nil, on_recovered: nil)
         @sdk_key = sdk_key
         @config = config
         @http_client = http_client
@@ -45,10 +45,14 @@ module Featureflip
         @on_segment_updated = on_segment_updated
         @on_error = on_error
         @on_sync = on_sync
-        @on_give_up = on_give_up
+        @on_fallback_to_polling = on_fallback_to_polling
+        @on_recovered = on_recovered
         @stop_flag = false
         @thread = nil
         @retry_count = 0
+        # True between arming the polling fallback and the next delivered frame.
+        # Only ever touched from the streaming thread.
+        @fallback_active = false
         @current_event_type = nil
         @current_data = nil
         @line_buffer = String.new # ASCII-8BIT: raw read_body bytes concatenate safely
@@ -60,6 +64,7 @@ module Featureflip
       def start
         @stop_flag = false
         @retry_count = 0
+        @fallback_active = false
         @thread = Thread.new { run }
       end
 
@@ -112,9 +117,14 @@ module Featureflip
             # purposes — otherwise an accept-then-close server never accumulates
             # toward max_stream_retries and never degrades to polling.
             @retry_count += 1
-            if @retry_count > @config.max_stream_retries
-              @on_give_up&.call
-              break
+            # The fallback is ADDITIVE, never terminal (#3071). Polling covers the
+            # outage; this loop keeps retrying the stream underneath at the capped
+            # backoff, and the next delivered frame retires the poller. Breaking out
+            # here left the process polling — and blind to real-time updates — until
+            # it restarted, after only ~31s of unreachability.
+            if @retry_count > @config.max_stream_retries && !@fallback_active
+              @fallback_active = true
+              @on_fallback_to_polling&.call
             end
           end
 
@@ -189,6 +199,14 @@ module Featureflip
           @current_data = @current_data.nil? ? fragment : "#{@current_data}\n#{fragment}"
         elsif line.empty? && @current_event_type && @current_data
           @delivered_frame = true
+          # Retire the fallback poller HERE rather than when run() next comes round:
+          # connect() blocks in read_body for the whole lifetime of a healthy stream,
+          # so a reap on return would leave the poller alive that entire time, and its
+          # periodic whole-store replaces would revert deltas applied by this stream.
+          if @fallback_active
+            @fallback_active = false
+            @on_recovered&.call
+          end
           handle_event(@current_event_type, @current_data)
           @current_event_type = nil
           @current_data = nil

data/lib/featureflip/evaluation/condition_evaluator.rb

@@ -14,14 +14,19 @@ module Featureflip
 
         return condition.negate if attr_value.nil?
 
+        # Resolve the operator ONCE (#2374). Every subsequent decision that keys
+        # off it -- numeric coercion, dispatch -- must read the same normalised
+        # label, or a mis-cased operator takes some paths and not others.
+        operator = normalize_operator(condition.operator)
+
         # Issue #1458: when the attribute is a native numeric (Integer/Float —
         # Ruby's `true`/`false` are NOT Numeric, so booleans are naturally
         # excluded), the equality-family operators coerce the condition values to
         # numbers and compare numerically, so 1.0 matches "1". This mirrors the
         # engine's type-aware path and runs BEFORE stringification — a String
         # attribute (even "1.0") stays on the string path below.
-        if attr_value.is_a?(Numeric) && NUMERIC_EQUALITY_OPERATORS.include?(condition.operator)
-          return evaluate_numeric_equality(condition, attr_value)
+        if attr_value.is_a?(Numeric) && NUMERIC_EQUALITY_OPERATORS.include?(operator)
+          return evaluate_numeric_equality(condition, operator, attr_value)
         end
 
         # Pass the raw (case-preserved) strings to the operator dispatcher.
@@ -31,7 +36,7 @@ module Featureflip
         str_value = attr_value.to_s
         targets = condition.values.map(&:to_s)
 
-        result = evaluate_operator(condition.operator, str_value, targets)
+        result = evaluate_operator(operator, str_value, targets)
 
         # Issue #2262: an unrecognised operator fails CLOSED. `!nil` is `true`
         # in Ruby, so without this guard a negated unknown operator would match
@@ -66,7 +71,7 @@ module Featureflip
       # The equality-family operators that get type-aware numeric coercion when
       # the attribute is a native Numeric (Issue #1458). Relational/string ops
       # are deliberately excluded — only these four coerce.
-      NUMERIC_EQUALITY_OPERATORS = %w[Equals NotEquals In NotIn].freeze
+      NUMERIC_EQUALITY_OPERATORS = %w[equals notequals in notin].freeze
       private_constant :NUMERIC_EQUALITY_OPERATORS
 
       # A parsed semantic version: the release core as dot-separated numeric
@@ -105,29 +110,47 @@ module Featureflip
       DAYS_IN_MONTH = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze
       private_constant :DAYS_IN_MONTH
 
+      # The single definition of "recognised operator" shared by the four
+      # string-typed SDKs (js, go, ruby, php) -- see #2374. Strips underscores
+      # and folds case, so the canonical PascalCase the API emits ("NotEquals"),
+      # the concatenated form go accepted ("notequals", "NOTEQUALS") and the
+      # snake_case form php accepted ("not_equals") all resolve to one label.
+      #
+      # This SDK previously matched the PascalCase labels EXACTLY, so every
+      # mis-cased spelling was simply unknown and failed closed. Normalising by
+      # removal makes the shared rule a superset of what each SDK accepted
+      # before, so no SDK gets stricter and no configuration that evaluated
+      # before stops doing so. The concatenated labels stay unambiguous under
+      # this mapping -- no two operator names collide once underscores go.
+      def normalize_operator(operator)
+        operator.to_s.delete("_").downcase
+      end
+
+      # `operator` arrives already normalised, so the labels below are the
+      # concatenated lowercase form rather than the wire PascalCase.
       def evaluate_operator(operator, value, targets)
         # Case-insensitive views for the string/relational/date operators.
         ci_value = value.downcase
         ci_targets = targets.map(&:downcase)
 
         case operator
-        when "Equals"
+        when "equals"
           ci_targets.any? { |t| ci_value == t }
-        when "NotEquals"
+        when "notequals"
           ci_targets.all? { |t| ci_value != t }
-        when "Contains"
+        when "contains"
           ci_targets.any? { |t| ci_value.include?(t) }
-        when "NotContains"
+        when "notcontains"
           ci_targets.all? { |t| !ci_value.include?(t) }
-        when "StartsWith"
+        when "startswith"
           ci_targets.any? { |t| ci_value.start_with?(t) }
-        when "EndsWith"
+        when "endswith"
           ci_targets.any? { |t| ci_value.end_with?(t) }
-        when "In"
+        when "in"
           ci_targets.include?(ci_value)
-        when "NotIn"
+        when "notin"
           !ci_targets.include?(ci_value)
-        when "MatchesRegex"
+        when "matchesregex"
           # Case-sensitive matching on the original-case value and pattern,
           # mirroring the engine (RegexOptions.None). Case-insensitivity is
           # opt-in via the (?i) inline flag in the pattern.
@@ -145,13 +168,13 @@ module Featureflip
         # against ANY condition value (mirroring the server engine), not just
         # values[0]. `.any?` over an empty array is false, so empty values
         # returns false without error.
-        when "GreaterThan"
+        when "greaterthan"
           ci_targets.any? { |t| compare_numeric(ci_value, t, :>) }
-        when "GreaterThanOrEqual"
+        when "greaterthanorequal"
           ci_targets.any? { |t| compare_numeric(ci_value, t, :>=) }
-        when "LessThan"
+        when "lessthan"
           ci_targets.any? { |t| compare_numeric(ci_value, t, :<) }
-        when "LessThanOrEqual"
+        when "lessthanorequal"
           ci_targets.any? { |t| compare_numeric(ci_value, t, :<=) }
         # Date operators compare against the RAW value/targets, not the
         # lowercased copies: downcasing breaks ISO-8601 parsing (the "Z" UTC
@@ -159,23 +182,23 @@ module Featureflip
         # to UTC instants — offsets are honored, no-offset strings are assumed
         # UTC, and a bare integer is treated as Unix seconds — so an unparseable
         # operand matches nothing instead of falling back to a string compare.
-        when "Before"
+        when "before"
           targets.any? { |t| compare_datetime(value, t, :<) }
-        when "After"
+        when "after"
           targets.any? { |t| compare_datetime(value, t, :>) }
         # Semantic-version operators compare against the RAW value/targets:
         # prerelease precedence is case-sensitive (semver §11), so the casing
         # preserved by `evaluate_condition` must not be folded here. An
         # unparseable version matches nothing, like the numeric/date operators.
-        when "SemverEquals"
+        when "semverequals"
           targets.any? { |t| compare_semver(value, t, :==) }
-        when "SemverGreaterThan"
+        when "semvergreaterthan"
           targets.any? { |t| compare_semver(value, t, :>) }
-        when "SemverGreaterThanOrEqual"
+        when "semvergreaterthanorequal"
           targets.any? { |t| compare_semver(value, t, :>=) }
-        when "SemverLessThan"
+        when "semverlessthan"
           targets.any? { |t| compare_semver(value, t, :<) }
-        when "SemverLessThanOrEqual"
+        when "semverlessthanorequal"
           targets.any? { |t| compare_semver(value, t, :<=) }
         else
           # Unrecognised operator. `nil` — NOT `false` — so the caller can tell
@@ -190,21 +213,21 @@ module Featureflip
       # numerically against the attribute. Equals/In match if ANY value is equal;
       # NotEquals/NotIn are their negation. The `negate` flag is then applied,
       # mirroring `evaluate_condition`'s tail.
-      def evaluate_numeric_equality(condition, attr_value)
+      def evaluate_numeric_equality(condition, operator, attr_value)
         target = attr_value.to_f
         any_equal = condition.values.any? do |v|
           n = parse_numeric(v)
           n && n == target
         end
 
-        positive = NUMERIC_EQUALITY_POSITIVE_OPERATORS.include?(condition.operator)
+        positive = NUMERIC_EQUALITY_POSITIVE_OPERATORS.include?(operator)
         result = positive ? any_equal : !any_equal
         condition.negate ? !result : result
       end
 
       # Equals/In are the "positive" members of the equality family (match on
       # equality); NotEquals/NotIn negate the same any-equal test.
-      NUMERIC_EQUALITY_POSITIVE_OPERATORS = %w[Equals In].freeze
+      NUMERIC_EQUALITY_POSITIVE_OPERATORS = %w[equals in].freeze
       private_constant :NUMERIC_EQUALITY_POSITIVE_OPERATORS
 
       # Strict literal parse of a condition value to a Float, reusing the same

data/lib/featureflip/shared_core.rb

@@ -276,6 +276,11 @@ module Featureflip
       @streaming_handler&.stop
       @polling_handler&.stop
       @event_processor&.stop
+      # Clear both before restarting: start_polling refuses to start a second
+      # poller while one is referenced, so a stopped-but-referenced handler here
+      # would leave a restarted non-streaming core with no data source at all.
+      @streaming_handler = nil
+      @polling_handler = nil
 
       if @config.streaming
         start_streaming
@@ -361,18 +366,35 @@ module Featureflip
         on_segment_updated: ->(flags, segments) { @store.init(flags, segments) },
         on_sync: ->(flags, segments) { @store.init(flags, segments) },
         on_error: ->(_err) { },
-        on_give_up: -> { fallback_to_polling }
+        on_fallback_to_polling: -> { fallback_to_polling },
+        on_recovered: -> { stop_fallback_polling }
       )
       @streaming_handler.start
     end
 
     def fallback_to_polling
-      @config.logger&.warn("Featureflip: streaming retries exhausted, falling back to polling")
-      @streaming_handler = nil
+      @config.logger&.warn(
+        "Featureflip: streaming retries exhausted, falling back to polling while the stream keeps retrying"
+      )
+      # The handler is NOT cleared: it is still running and still trying to reopen
+      # the stream (#3071). Clearing it here is what used to make the fallback
+      # permanent — nothing would have restarted streaming.
       start_polling
     end
 
+    def stop_fallback_polling
+      return if @polling_handler.nil?
+
+      @config.logger&.info("Featureflip: stream recovered, stopping polling fallback")
+      @polling_handler.stop
+      @polling_handler = nil
+    end
+
     def start_polling
+      # Reachable from both start_data_source and the streaming fallback; a second
+      # call must not leak a second polling thread.
+      return if @polling_handler
+
       @polling_handler = DataSource::PollingHandler.new(
         http_client: @http_client,
         config: @config,

data/lib/featureflip/version.rb

@@ -1,3 +1,3 @@
 module Featureflip
-  VERSION = "2.7.0"
+  VERSION = "2.9.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: featureflip
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.9.0
 platform: ruby
 authors:
 - Featureflip
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-26 00:00:00.000000000 Z
+date: 2026-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger