featureflip 2.12.0 → 2.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9ade6e604108bf5c72e9b0d69dee554ef6c929004db80b56e4d184980de4ee1
-  data.tar.gz: 32c424cf3af497320ad75dc8f23baf336b086f3e8bdf867da20e8e7ce4f96e70
+  metadata.gz: c4c086d9a3b50763d562f2a79ef07aa449ddbdb1b88446d8fee98948d7c3933c
+  data.tar.gz: bf96d5faeb953a5219f1de18d5ff85d404b5fbf3daa783550b3b64837b0c72bc
 SHA512:
-  metadata.gz: 5e5d545c1410cac76b7603008f9708a40e6c257e82e8142b1d799fcfc2b5475500072e764a6828b43300fade2cbede2936b82bf1e3e043131606317600ea2985
-  data.tar.gz: b8727a3ddf735c16c4d0094472721ba2ad53fb5bca323024a7d3291b993730efb583cc1683375aea9ba8d3235b523dac252ddac1f82fcc0799718d49337b5065
+  metadata.gz: 2a2a87d48a71704a9b2885885a55c74f664497be27703bb4dcb83463756347f771803cfa6608f2c2512b8cff19a982a21ab72d76c52ec53a45fd3d5187f02f45
+  data.tar.gz: be23805658d9ce4f0ba3c4a49f0fde25ea8e2e05e0da8497ab4ec94b557ee9d554b1ed870782acf6df2cbe8476bc5691ae8728eb4438a1259b304c09d91fc4fa

data/lib/featureflip/evaluation/canonical_number.rb

@@ -5,11 +5,14 @@ module Featureflip
     # BucketValueFormatter.CanonicalNumber, so every SDK hashes one number to one
     # bucket. Used only on the bucket path; condition evaluation is unaffected.
     module CanonicalNumber
-      # A BigDecimal with no fractional part keeps its exact integer digits (like the
-      # engine's raw integer text); anything else goes through Float (#4236).
+      # A BigDecimal below 1e21 with no fractional part keeps its exact integer digits (like
+      # the engine's raw integer text); anything else goes through Float (#4236). The 1e21
+      # cap is where ECMAScript spelling turns exponential, and stops BigDecimal("1E+999999999")
+      # expanding to a billion digits per evaluation (#4246). BigDecimal#exponent is n in
+      # 0.ddd * 10**n, so |d| < 1e21 is exponent <= 21.
       def self.format_big_decimal(d)
         return format(d.to_f) unless d.finite?
-        return d.to_i.to_s if d.frac.zero?
+        return d.to_i.to_s if d.exponent <= 21 && d.frac.zero?
 
         format(d.to_f)
       end

data/lib/featureflip/evaluation/condition_evaluator.rb

@@ -1,3 +1,4 @@
+require_relative "context_attribute"
 require "time"
 
 module Featureflip
@@ -10,7 +11,7 @@ module Featureflip
       REGEX_TIMEOUT_SECONDS = 0.1
 
       def evaluate_condition(condition, context)
-        attr_value = context[condition.attribute]
+        attr_value = ContextAttribute.resolve(context, condition.attribute)
 
         return condition.negate if attr_value.nil?
 

data/lib/featureflip/evaluation/context_attribute.rb

@@ -0,0 +1,24 @@
+module Featureflip
+  module Evaluation
+    # Looks an attribute up in an evaluation context hash.
+    #
+    # "user_id" is the canonical spelling of the user identifier and "userId" is
+    # accepted as an alias (#4518). A lookup of exactly one of the two returns
+    # "user_id" when it is non-nil, else "userId" when it is non-nil, else nil.
+    # An empty string is a value and does not fall through. Every other key,
+    # including other casings, is an ordinary attribute.
+    module ContextAttribute
+      module_function
+
+      def resolve(context, attribute)
+        if attribute == "user_id" || attribute == "userId"
+          value = context["user_id"]
+          value = context["userId"] if value.nil?
+          value
+        else
+          context[attribute]
+        end
+      end
+    end
+  end
+end

data/lib/featureflip/evaluation/evaluator.rb

@@ -1,3 +1,4 @@
+require_relative "context_attribute"
 require_relative "condition_evaluator"
 require_relative "bucketing"
 require_relative "canonical_number"
@@ -164,7 +165,7 @@ module Featureflip
       end
 
       def warn_unbucketable(flag, rule_id, serve)
-        UnbucketableWarnings.warn(@logger, flag.key, rule_id, serve.bucket_by || "userId")
+        UnbucketableWarnings.warn(@logger, flag.key, rule_id, serve.bucket_by || "user_id")
       end
 
       # Returns the variation key to serve, or nil when a Rollout serve can't bucket
@@ -178,13 +179,13 @@ module Featureflip
       end
 
       def resolve_rollout(serve, context)
-        bucket_by = serve.bucket_by || "userId"
-        bucket_value = context[bucket_by]
-        # Alias "userId" <-> "user_id" for the built-in user identifier
-        bucket_value = context["user_id"] if bucket_value.nil? && bucket_by == "userId"
-        bucket_value = context["userId"] if bucket_value.nil? && bucket_by == "user_id"
+        bucket_by = serve.bucket_by || "user_id"
+        # "user_id" and "userId" resolve the same identity (user_id first).
+        bucket_value = ContextAttribute.resolve(context, bucket_by)
         bucket_value_str =
-          if bucket_value.nil? then ""
+          # An Array or Hash (a JSON array or object, empty or not) has no spelling every
+          # SDK shares, so it can't be bucketed, like a missing value (#4572).
+          if bucket_value.nil? || bucket_value.is_a?(Array) || bucket_value.is_a?(Hash) then ""
           elsif bucket_value.is_a?(Float) then CanonicalNumber.format(bucket_value)
           elsif defined?(::BigDecimal) && bucket_value.is_a?(::BigDecimal) then CanonicalNumber.format_big_decimal(bucket_value)
           else bucket_value.to_s
@@ -196,7 +197,7 @@ module Featureflip
         # empty key. Mirrors the engine + C#/Java SDK evaluators.
         return serve.variation || "" if (serve.variations || []).empty?
 
-        # A missing, nil or empty bucket value can't be bucketed: return nil so the caller
+        # A missing, nil, empty or non-scalar bucket value can't be bucketed: return nil so the caller
         # skips the rule (or serves the fallthrough's variation) instead of hashing the empty
         # string into an arbitrary bucket. Whitespace, "0", 0 and false bucket normally (#4236).
         return nil if bucket_value_str == ""

data/lib/featureflip/shared_core.rb

@@ -185,7 +185,7 @@ module Featureflip
 
       flag = @store.get_flag(key)
       unless flag
-        record_evaluation(key, context, nil)
+        record_evaluation(key, context, nil, reason: "FlagNotFound")
         notify_inspectors(key, context, default_value, reason: "FlagNotFound")
         return Models::EvaluationDetail.new(value: default_value, reason: "FlagNotFound")
       end
@@ -224,7 +224,10 @@ module Featureflip
         reason = "Error"
       end
 
-      record_evaluation(key, context, result.variation_key)
+      record_evaluation(
+        key, context, result.variation_key,
+        reason: reason, rule_id: result.rule_id, prerequisite_key: result.prerequisite_key
+      )
       notify_inspectors(
         key, context, value,
         reason: reason,
@@ -244,6 +247,7 @@ module Featureflip
       # Prerequisite-resolution failures return PrerequisiteFailed cleanly through
       # the evaluator; this rescue only fires on unexpected exceptions (malformed
       # config, programming errors), so prerequisite_key has no defined value.
+      record_evaluation(key, context, nil, reason: "Error")
       notify_inspectors(key, context, default_value, reason: "Error")
       Models::EvaluationDetail.new(value: default_value, reason: "Error", prerequisite_key: nil)
     end
@@ -521,16 +525,36 @@ module Featureflip
       event
     end
 
-    def record_evaluation(key, context, variation_key)
+    # The kebab-case reason categories the Evaluation event carries (#4268), so
+    # the source of traffic reads the same whichever SDK reported it. The
+    # PascalCase names stay the public EvaluationDetail API; only the event is
+    # translated.
+    WIRE_REASONS = {
+      "RuleMatch" => "rule-match",
+      "Fallthrough" => "fallthrough",
+      "FlagDisabled" => "flag-disabled",
+      "FlagNotFound" => "flag-not-found",
+      "PrerequisiteFailed" => "prerequisite-failed",
+      "Error" => "error"
+    }.freeze
+
+    # +ruleId+ rides only on a rule match: an Error read can still carry the rule
+    # that selected a malformed variation, and that rule did not serve the
+    # traffic. Absent optionals are compacted away so they are omitted, never null.
+    def record_evaluation(key, context, variation_key, reason:, rule_id: nil, prerequisite_key: nil)
       return unless @event_processor
 
-      @event_processor.queue_event(compact_event({
+      event = {
         type: "Evaluation",
         flagKey: key,
         userId: resolve_event_user_id(context),
         variation: variation_key,
-        timestamp: Time.now.utc.iso8601
-      }))
+        timestamp: Time.now.utc.iso8601,
+        prerequisiteKey: prerequisite_key,
+        reason: WIRE_REASONS[reason],
+        ruleId: reason == "RuleMatch" ? rule_id : nil
+      }
+      @event_processor.queue_event(event.compact)
     end
 
     # Fire the registered evaluation inspectors. Called once per variation call

data/lib/featureflip/version.rb

@@ -1,3 +1,3 @@
 module Featureflip
-  VERSION = "2.12.0"
+  VERSION = "2.13.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: featureflip
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.13.1
 platform: ruby
 authors:
 - Featureflip
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-22 00:00:00.000000000 Z
+date: 2026-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -81,6 +81,7 @@ files:
 - lib/featureflip/evaluation/bucketing.rb
 - lib/featureflip/evaluation/canonical_number.rb
 - lib/featureflip/evaluation/condition_evaluator.rb
+- lib/featureflip/evaluation/context_attribute.rb
 - lib/featureflip/evaluation/evaluator.rb
 - lib/featureflip/evaluation/unbucketable_warnings.rb
 - lib/featureflip/events/event.rb