feature_toggle.rb in unleash-4.0.0

- old
+ new

@@ -30,27 +30,34 @@
       Unleash.toggle_metrics.increment(name, choice) unless Unleash.configuration.disable_metrics
 
       result
     end
 
-    def get_variant(context, fallback_variant = disabled_variant)
+    def get_variant(context, fallback_variant = Unleash::FeatureToggle.disabled_variant)
       raise ArgumentError, "Provided fallback_variant is not of type Unleash::Variant" if fallback_variant.class.name != 'Unleash::Variant'
 
       context = ensure_valid_context(context)
 
-      return disabled_variant unless self.enabled && am_enabled?(context, true)
-      return disabled_variant if sum_variant_defs_weights <= 0
+      return Unleash::FeatureToggle.disabled_variant unless self.enabled && am_enabled?(context, true)
+      return Unleash::FeatureToggle.disabled_variant if sum_variant_defs_weights <= 0
 
-      variant = variant_from_override_match(context)
-      variant = variant_from_weights(context) if variant.nil?
+      variant = variant_from_override_match(context) || variant_from_weights(context, resolve_stickiness)
 
       Unleash.toggle_metrics.increment_variant(self.name, variant.name) unless Unleash.configuration.disable_metrics
       variant
     end
 
+    def self.disabled_variant
+      Unleash::Variant.new(name: 'disabled', enabled: false)
+    end
+
     private
 
+    def resolve_stickiness
+      self.variant_definitions&.map(&:stickiness)&.compact&.first || "default"
+    end
+
     # only check if it is enabled, do not do metrics
     def am_enabled?(context, default_result)
       result =
         if self.enabled
           self.strategies.empty? ||
@@ -75,19 +82,16 @@
 
     def strategy_constraint_matches?(strategy, context)
       strategy.constraints.empty? || strategy.constraints.all?{ |c| c.matches_context?(context) }
     end
 
-    def disabled_variant
-      Unleash::Variant.new(name: 'disabled', enabled: false)
-    end
-
     def sum_variant_defs_weights
       self.variant_definitions.map(&:weight).reduce(0, :+)
     end
 
-    def variant_salt(context)
+    def variant_salt(context, stickiness = "default")
+      return context.get_by_name(stickiness) unless stickiness == "default"
       return context.user_id unless context.user_id.to_s.empty?
       return context.session_id unless context.session_id.to_s.empty?
       return context.remote_address unless context.remote_address.to_s.empty?
 
       SecureRandom.random_number
@@ -98,21 +102,21 @@
       return nil if variant.nil?
 
       Unleash::Variant.new(name: variant.name, enabled: true, payload: variant.payload)
     end
 
-    def variant_from_weights(context)
-      variant_weight = Unleash::Strategy::Util.get_normalized_number(variant_salt(context), self.name, sum_variant_defs_weights)
+    def variant_from_weights(context, stickiness)
+      variant_weight = Unleash::Strategy::Util.get_normalized_number(variant_salt(context, stickiness), self.name, sum_variant_defs_weights)
       prev_weights = 0
 
       variant_definition = self.variant_definitions
         .find do |v|
           res = (prev_weights + v.weight >= variant_weight)
           prev_weights += v.weight
           res
         end
-      return disabled_variant if variant_definition.nil?
+      return self.disabled_variant if variant_definition.nil?
 
       Unleash::Variant.new(name: variant_definition.name, enabled: true, payload: variant_definition.payload)
     end
 
     def ensure_valid_context(context)
@@ -148,9 +152,10 @@
         .map do |v|
           VariantDefinition.new(
             v.fetch('name', ''),
             v.fetch('weight', 0),
             v.fetch('payload', nil),
+            v.fetch('stickiness', nil),
             v.fetch('overrides', [])
           )
         end || []
     end
   end