unleash 5.1.1 → 6.0.5.pre

data/lib/unleash/constraint.rb

@@ -1,117 +0,0 @@
-require 'date'
-module Unleash
-  class Constraint
-    attr_accessor :context_name, :operator, :value, :inverted, :case_insensitive
-
-    OPERATORS = {
-      IN: ->(context_v, constraint_v){ constraint_v.include? context_v.to_s },
-      NOT_IN: ->(context_v, constraint_v){ !constraint_v.include? context_v.to_s },
-      STR_STARTS_WITH: ->(context_v, constraint_v){ constraint_v.any?{ |v| context_v.start_with? v } },
-      STR_ENDS_WITH: ->(context_v, constraint_v){ constraint_v.any?{ |v| context_v.end_with? v } },
-      STR_CONTAINS: ->(context_v, constraint_v){ constraint_v.any?{ |v| context_v.include? v } },
-      NUM_EQ: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x - y).abs < Float::EPSILON } },
-      NUM_LT: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x > y) } },
-      NUM_LTE: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x >= y) } },
-      NUM_GT: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x < y) } },
-      NUM_GTE: ->(context_v, constraint_v){ on_valid_float(constraint_v, context_v){ |x, y| (x <= y) } },
-      DATE_AFTER: ->(context_v, constraint_v){ on_valid_date(constraint_v, context_v){ |x, y| (x < y) } },
-      DATE_BEFORE: ->(context_v, constraint_v){ on_valid_date(constraint_v, context_v){ |x, y| (x > y) } },
-      SEMVER_EQ: ->(context_v, constraint_v){ on_valid_version(constraint_v, context_v){ |x, y| (x == y) } },
-      SEMVER_GT: ->(context_v, constraint_v){ on_valid_version(constraint_v, context_v){ |x, y| (x < y) } },
-      SEMVER_LT: ->(context_v, constraint_v){ on_valid_version(constraint_v, context_v){ |x, y| (x > y) } },
-      FALLBACK_VALIDATOR: ->(_context_v, _constraint_v){ false }
-    }.freeze
-
-    STRING_OPERATORS = [:STR_STARTS_WITH, :STR_ENDS_WITH, :STR_CONTAINS].freeze
-
-    LIST_OPERATORS = [:IN, :NOT_IN, :STR_STARTS_WITH, :STR_ENDS_WITH, :STR_CONTAINS].freeze
-
-    def initialize(context_name, operator, value = [], inverted: false, case_insensitive: false)
-      raise ArgumentError, "context_name is not a String" unless context_name.is_a?(String)
-
-      unless OPERATORS.include? operator.to_sym
-        Unleash.logger.warn "Operator #{operator} is not a supported operator, " \
-          "falling back to FALLBACK_VALIDATOR which skips this constraint."
-        operator = "FALLBACK_VALIDATOR"
-      end
-      self.log_inconsistent_constraint_configuration(operator.to_sym, value)
-
-      self.context_name = context_name
-      self.operator = operator.to_sym
-      self.value = value
-      self.inverted = !!inverted
-      self.case_insensitive = !!case_insensitive
-    end
-
-    def matches_context?(context)
-      Unleash.logger.debug "Unleash::Constraint matches_context? value: #{self.value} context.get_by_name(#{self.context_name})"
-      return false if context.nil?
-
-      match = matches_constraint?(context)
-      self.inverted ? !match : match
-    rescue KeyError
-      Unleash.logger.warn "Attemped to resolve a context key during constraint resolution: #{self.context_name} but it wasn't \
-      found on the context"
-      false
-    end
-
-    def self.on_valid_date(val1, val2)
-      val1 = DateTime.parse(val1)
-      val2 = val2.is_a?(DateTime) ? val2 : DateTime.parse(val2)
-      yield(val1, val2)
-    rescue ArgumentError, TypeError
-      Unleash.logger.warn "Unleash::ConstraintMatcher unable to parse either context_value (#{val1}) \
-      or constraint_value (#{val2}) into a date. Returning false!"
-      false
-    end
-
-    def self.on_valid_float(val1, val2)
-      val1 = Float(val1)
-      val2 = Float(val2)
-      yield(val1, val2)
-    rescue ArgumentError
-      Unleash.logger.warn "Unleash::ConstraintMatcher unable to parse either context_value (#{val1}) \
-      or constraint_value (#{val2}) into a number. Returning false!"
-      false
-    end
-
-    def self.on_valid_version(val1, val2)
-      val1 = Gem::Version.new(val1)
-      val2 = Gem::Version.new(val2)
-      yield(val1, val2)
-    rescue ArgumentError
-      Unleash.logger.warn "Unleash::ConstraintMatcher unable to parse either context_value (#{val1}) \
-      or constraint_value (#{val2}) into a version. Return false!"
-      false
-    end
-
-    # This should be a private method but for some reason this fails on Ruby 2.5
-    def log_inconsistent_constraint_configuration(operator, value)
-      Unleash.logger.warn "value is a String, operator is expecting an Array" if LIST_OPERATORS.include?(operator) && value.is_a?(String)
-      Unleash.logger.warn "value is an Array, operator is expecting a String" if !LIST_OPERATORS.include?(operator) && value.is_a?(Array)
-    end
-
-    private
-
-    def matches_constraint?(context)
-      Unleash.logger.debug "Unleash::Constraint matches_constraint? value: #{self.value} operator: #{self.operator} " \
-        " context.get_by_name(#{self.context_name})"
-
-      unless OPERATORS.include?(self.operator)
-        Unleash.logger.warn "Invalid constraint operator: #{self.operator}, this should be unreachable. Always returning false."
-        false
-      end
-
-      # when the operator is NOT_IN and there is no data, return true. In all other cases the operator doesn't match.
-      return self.operator == :NOT_IN unless context.include?(self.context_name)
-
-      v = self.value.dup
-      context_value = context.get_by_name(self.context_name)
-
-      # always return false, if we are comparing a non string with a string operator:
-      return false if !context_value.is_a?(String) && STRING_OPERATORS.include?(self.operator)
-
-      OPERATORS[self.operator].call(*self.case_insensitive ? [context_value.upcase, v.map(&:upcase)] : [context_value, v])
-    end
-  end
-end

data/lib/unleash/feature_toggle.rb

@@ -1,253 +0,0 @@
-require 'unleash/activation_strategy'
-require 'unleash/constraint'
-require 'unleash/variant_definition'
-require 'unleash/variant'
-require 'unleash/strategy/util'
-require 'securerandom'
-
-module Unleash
-  class FeatureToggle
-    attr_accessor :name, :enabled, :dependencies, :strategies, :variant_definitions
-
-    FeatureEvaluationResult = Struct.new(:enabled?, :strategy)
-
-    def initialize(params = {}, segment_map = {})
-      params = {} if params.nil?
-
-      self.name       = params.fetch('name', nil)
-      self.enabled    = params.fetch('enabled', false)
-      self.dependencies = params.fetch('dependencies', [])
-
-      self.strategies = initialize_strategies(params, segment_map)
-      self.variant_definitions = initialize_variant_definitions(params)
-    end
-
-    def to_s
-      "<FeatureToggle: name=#{name},enabled=#{enabled},strategies=#{strategies},variant_definitions=#{variant_definitions}>"
-    end
-
-    def is_enabled?(context)
-      result = am_enabled?(context)
-
-      choice = result ? :yes : :no
-      Unleash.toggle_metrics.increment(name, choice) unless Unleash.configuration.disable_metrics
-
-      result
-    end
-
-    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)
-
-      evaluation_result = evaluate(context)
-
-      group_id = evaluation_result.strategy&.params.to_h['groupId'] || self.name
-
-      variant = resolve_variant(context, evaluation_result, group_id)
-
-      choice = evaluation_result.enabled? ? :yes : :no
-      Unleash.toggle_metrics.increment_variant(self.name, choice, variant.name) unless Unleash.configuration.disable_metrics
-
-      variant.feature_enabled = evaluation_result.enabled?
-
-      variant
-    end
-
-    def self.disabled_variant
-      Unleash::Variant.new(name: 'disabled', enabled: false, feature_enabled: false)
-    end
-
-    private
-
-    def resolve_variant(context, evaluation_result, group_id)
-      variant_strategy_stickiness = evaluation_result.strategy&.params.to_h['stickiness'] || 'default'
-      variant_definitions = evaluation_result.strategy&.variant_definitions
-      variant_definitions = self.variant_definitions if variant_definitions.nil? || variant_definitions.empty?
-      return Unleash::FeatureToggle.disabled_variant unless evaluation_result.enabled?
-      return Unleash::FeatureToggle.disabled_variant if sum_variant_defs_weights(variant_definitions) <= 0
-
-      variant_from_override_match(context, variant_definitions) ||
-        variant_from_weights(context, resolve_stickiness(variant_definitions, variant_strategy_stickiness), variant_definitions, group_id)
-    end
-
-    def resolve_stickiness(variant_definitions, variant_strategy_stickiness)
-      variant_definitions&.map(&:stickiness)&.compact&.first || variant_strategy_stickiness
-    end
-
-    # only check if it is enabled, do not do metrics
-    def am_enabled?(context)
-      evaluate(context).enabled?
-    end
-
-    def parent_dependencies_satisfied?(context)
-      dependencies.empty? || dependencies.all?{ |parent| evaluate_parent(parent, context) }
-    end
-
-    def evaluate_parent(parent, context)
-      parent_toggle = get_parent(parent["feature"])
-      return false if parent_toggle.nil? || !parent_toggle.dependencies.empty?
-
-      evaluation_result = parent_toggle.is_enabled?(context)
-      return !evaluation_result if parent["enabled"] == false
-
-      return false unless evaluation_result
-
-      return evaluation_result if parent["variants"].nil? || parent["variants"].empty?
-
-      parent["variants"].include?(parent_toggle.get_variant(context).name)
-    end
-
-    def get_parent(feature)
-      toggle_as_hash = Unleash&.toggles&.find{ |toggle| toggle['name'] == feature }
-      if toggle_as_hash.nil?
-        Unleash.logger.debug "Unleash::Client.is_enabled? feature: #{feature} not found"
-        return nil
-      end
-
-      Unleash::FeatureToggle.new(toggle_as_hash, Unleash&.segment_cache)
-    end
-
-    def evaluate(context)
-      evaluation_result =
-        if !parent_dependencies_satisfied?(context)
-          FeatureEvaluationResult.new(false, nil)
-        elsif !self.enabled
-          FeatureEvaluationResult.new(false, nil)
-        elsif self.strategies.empty?
-          FeatureEvaluationResult.new(true, nil)
-        else
-          strategy = self.strategies.find{ |s| strategy_enabled?(s, context) && strategy_constraint_matches?(s, context) }
-          FeatureEvaluationResult.new(!strategy.nil?, strategy)
-        end
-
-      Unleash.logger.debug "Unleash::FeatureToggle (enabled:#{self.enabled}) " \
-        "and Strategies combined with constraints returned #{evaluation_result})"
-      evaluation_result
-    end
-
-    def strategy_enabled?(strategy, context)
-      r = Unleash.strategies.fetch(strategy.name).is_enabled?(strategy.params, context)
-      Unleash.logger.debug "Unleash::FeatureToggle.strategy_enabled? Strategy #{strategy.name} returned #{r} with context: #{context}"
-      r
-    end
-
-    def strategy_constraint_matches?(strategy, context)
-      return false if strategy.disabled
-
-      strategy.constraints.empty? || strategy.constraints.all?{ |c| c.matches_context?(context) }
-    end
-
-    def sum_variant_defs_weights(variant_definitions)
-      variant_definitions.map(&:weight).reduce(0, :+)
-    end
-
-    def variant_salt(context, stickiness = "default")
-      begin
-        return context.get_by_name(stickiness) if !context.nil? && stickiness != "default"
-      rescue KeyError
-        Unleash.logger.warn "Custom stickiness key (#{stickiness}) not found in the provided context #{context}. " \
-          "Falling back to default behavior."
-      end
-      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
-    end
-
-    def variant_from_override_match(context, variant_definitions)
-      variant_definition = variant_definitions.find{ |vd| vd.override_matches_context?(context) }
-      return nil if variant_definition.nil?
-
-      Unleash::Variant.new(name: variant_definition.name, enabled: true, payload: variant_definition.payload)
-    end
-
-    def variant_from_weights(context, stickiness, variant_definitions, group_id)
-      variant_weight = Unleash::Strategy::Util.get_normalized_number(
-        variant_salt(context, stickiness),
-        group_id,
-        Unleash::Strategy::Util::VARIANT_NORMALIZER_SEED,
-        sum_variant_defs_weights(variant_definitions)
-      )
-      prev_weights = 0
-
-      variant_definition = variant_definitions
-        .find do |v|
-          res = (prev_weights + v.weight >= variant_weight)
-          prev_weights += v.weight
-          res
-        end
-      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)
-      unless ['NilClass', 'Unleash::Context'].include? context.class.name
-        Unleash.logger.error "Provided context is not of the correct type #{context.class.name}, " \
-          "please use Unleash::Context. Context set to nil."
-        context = nil
-      end
-      context
-    end
-
-    def initialize_strategies(params, segment_map)
-      (params.fetch('strategies', []) || [])
-        .select{ |s| s.has_key?('name') && Unleash.strategies.includes?(s['name']) }
-        .map do |s|
-          ActivationStrategy.new(
-            s['name'],
-            s['parameters'],
-            resolve_constraints(s, segment_map),
-            resolve_variants(s)
-          )
-        end || []
-    end
-
-    def resolve_variants(strategy)
-      (strategy.fetch("variants", []) || [])
-        .select{ |variant| variant.is_a?(Hash) && variant.has_key?("name") }
-        .map do |variant|
-          VariantDefinition.new(
-            variant.fetch("name", ""),
-            variant.fetch("weight", 0),
-            variant.fetch("payload", nil),
-            variant.fetch("stickiness", nil),
-            variant.fetch("overrides", [])
-          )
-        end
-    end
-
-    def resolve_constraints(strategy, segment_map)
-      segment_constraints = (strategy["segments"] || []).map do |segment_id|
-        segment_map[segment_id]&.fetch("constraints")
-      end
-      (strategy.fetch("constraints", []) + segment_constraints).flatten.map do |constraint|
-        return nil if constraint.nil?
-
-        Constraint.new(
-          constraint.fetch('contextName'),
-          constraint.fetch('operator'),
-          constraint.fetch('value', nil) || constraint.fetch('values', nil),
-          inverted: constraint.fetch('inverted', false),
-          case_insensitive: constraint.fetch('caseInsensitive', false)
-        )
-      end
-    end
-
-    def initialize_variant_definitions(params)
-      (params.fetch('variants', []) || [])
-        .select{ |v| v.is_a?(Hash) && v.has_key?('name') }
-        .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
-end

data/lib/unleash/metrics.rb

@@ -1,41 +0,0 @@
-module Unleash
-  class Metrics
-    attr_accessor :features, :features_lock
-
-    def initialize
-      self.features = {}
-      self.features_lock = Mutex.new
-    end
-
-    def to_s
-      self.features_lock.synchronize do
-        return self.features.to_json
-      end
-    end
-
-    def increment(feature, choice)
-      raise "InvalidArgument choice must be :yes or :no" unless [:yes, :no].include? choice
-
-      self.features_lock.synchronize do
-        self.features[feature] = { yes: 0, no: 0 } unless self.features.include? feature
-        self.features[feature][choice] += 1
-      end
-    end
-
-    def increment_variant(feature, choice, variant)
-      self.features_lock.synchronize do
-        self.features[feature] = { yes: 0, no: 0 } unless self.features.include? feature
-        self.features[feature][choice] += 1
-        self.features[feature]['variants'] = {}     unless self.features[feature].include? 'variants'
-        self.features[feature]['variants'][variant] = 0 unless self.features[feature]['variants'].include? variant
-        self.features[feature]['variants'][variant] += 1
-      end
-    end
-
-    def reset
-      self.features_lock.synchronize do
-        self.features = {}
-      end
-    end
-  end
-end

data/lib/unleash/strategy/application_hostname.rb

@@ -1,26 +0,0 @@
-require 'socket'
-
-module Unleash
-  module Strategy
-    class ApplicationHostname < Base
-      attr_accessor :hostname
-
-      PARAM = 'hostnames'.freeze
-
-      def initialize
-        self.hostname = Socket.gethostname || 'undefined'
-      end
-
-      def name
-        'applicationHostname'
-      end
-
-      # need: :params['hostnames']
-      def is_enabled?(params = {}, _context = nil)
-        return false unless params.is_a?(Hash) && params.has_key?(PARAM)
-
-        params[PARAM].split(",").map(&:strip).map(&:downcase).include?(self.hostname)
-      end
-    end
-  end
-end

data/lib/unleash/strategy/base.rb

@@ -1,16 +0,0 @@
-module Unleash
-  module Strategy
-    class NotImplemented < RuntimeError
-    end
-
-    class Base
-      def name
-        raise NotImplemented, "Strategy is not implemented"
-      end
-
-      def is_enabled?(_params = {}, _context = nil)
-        raise NotImplemented, "Strategy is not implemented"
-      end
-    end
-  end
-end

data/lib/unleash/strategy/default.rb

@@ -1,13 +0,0 @@
-module Unleash
-  module Strategy
-    class Default < Base
-      def name
-        'default'
-      end
-
-      def is_enabled?(_params = {}, _context = nil)
-        true
-      end
-    end
-  end
-end

data/lib/unleash/strategy/flexible_rollout.rb

@@ -1,64 +0,0 @@
-require 'unleash/strategy/util'
-
-module Unleash
-  module Strategy
-    class FlexibleRollout < Base
-      def name
-        'flexibleRollout'
-      end
-
-      # need: params['percentage']
-      def is_enabled?(params = {}, context = nil)
-        return false unless params.is_a?(Hash)
-
-        stickiness = params.fetch('stickiness', 'default')
-        return false if context_invalid?(stickiness, context)
-
-        stickiness_id = resolve_stickiness(stickiness, context)
-
-        begin
-          percentage = Integer(params.fetch('rollout', 0))
-          percentage = 0 if percentage > 100 || percentage.negative?
-        rescue ArgumentError
-          return false
-        end
-
-        group_id = params.fetch('groupId', '')
-        normalized_number = Util.get_normalized_number(stickiness_id, group_id, 0)
-
-        return false if stickiness_id.nil?
-
-        (percentage.positive? && normalized_number <= percentage)
-      end
-
-      private
-
-      def context_invalid?(stickiness, context)
-        return false if ['random', 'default'].include?(stickiness)
-
-        !context.instance_of?(Unleash::Context)
-      end
-
-      def random
-        Random.rand(0..10_000)
-      end
-
-      def resolve_stickiness(stickiness, context)
-        case stickiness
-        when 'random'
-          random
-        when 'default'
-          return random unless context.instance_of?(Unleash::Context)
-
-          context&.user_id || context&.session_id || random
-        else
-          begin
-            context.get_by_name(stickiness)
-          rescue KeyError
-            nil
-          end
-        end
-      end
-    end
-  end
-end

data/lib/unleash/strategy/gradual_rollout_random.rb

@@ -1,24 +0,0 @@
-require 'unleash/strategy/util'
-
-module Unleash
-  module Strategy
-    class GradualRolloutRandom < Base
-      def name
-        'gradualRolloutRandom'
-      end
-
-      # need: params['percentage']
-      def is_enabled?(params = {}, _context = nil)
-        return false unless params.is_a?(Hash) && params.has_key?('percentage')
-
-        begin
-          percentage = Integer(params['percentage'] || 0)
-        rescue ArgumentError
-          return false
-        end
-
-        (percentage >= Random.rand(1..100))
-      end
-    end
-  end
-end

data/lib/unleash/strategy/gradual_rollout_sessionid.rb

@@ -1,21 +0,0 @@
-require 'unleash/strategy/util'
-
-module Unleash
-  module Strategy
-    class GradualRolloutSessionId < Base
-      def name
-        'gradualRolloutSessionId'
-      end
-
-      # need: params['percentage'], params['groupId'], context.user_id,
-      def is_enabled?(params = {}, context = nil)
-        return false unless params.is_a?(Hash) && params.has_key?('percentage')
-        return false unless context.instance_of?(Unleash::Context)
-        return false if context.session_id.nil? || context.session_id.empty?
-
-        percentage = Integer(params['percentage'] || 0)
-        (percentage.positive? && Util.get_normalized_number(context.session_id, params['groupId'] || "", 0) <= percentage)
-      end
-    end
-  end
-end

data/lib/unleash/strategy/gradual_rollout_userid.rb

@@ -1,21 +0,0 @@
-require 'unleash/strategy/util'
-
-module Unleash
-  module Strategy
-    class GradualRolloutUserId < Base
-      def name
-        'gradualRolloutUserId'
-      end
-
-      # need: params['percentage'], params['groupId'], context.user_id,
-      def is_enabled?(params = {}, context = nil, _constraints = [])
-        return false unless params.is_a?(Hash) && params.has_key?('percentage')
-        return false unless context.instance_of?(Unleash::Context)
-        return false if context.user_id.nil? || context.user_id.empty?
-
-        percentage = Integer(params['percentage'] || 0)
-        (percentage.positive? && Util.get_normalized_number(context.user_id, params['groupId'] || "", 0) <= percentage)
-      end
-    end
-  end
-end

data/lib/unleash/strategy/remote_address.rb

@@ -1,36 +0,0 @@
-module Unleash
-  module Strategy
-    class RemoteAddress < Base
-      PARAM = 'IPs'.freeze
-
-      def name
-        'remoteAddress'
-      end
-
-      # need: params['IPs'], context.remote_address
-      def is_enabled?(params = {}, context = nil)
-        return false unless params.is_a?(Hash) && params.has_key?(PARAM)
-        return false unless params.fetch(PARAM, nil).is_a? String
-        return false unless context.instance_of?(Unleash::Context)
-
-        remote_address = ipaddr_or_nil_from_str(context.remote_address)
-
-        params[PARAM]
-          .split(',')
-          .map(&:strip)
-          .map{ |ipblock| ipaddr_or_nil_from_str(ipblock) }
-          .compact
-          .map{ |ipb| ipb.include? remote_address }
-          .any?
-      end
-
-      private
-
-      def ipaddr_or_nil_from_str(ip)
-        IPAddr.new(ip)
-      rescue StandardError
-        nil
-      end
-    end
-  end
-end

data/lib/unleash/strategy/user_with_id.rb

@@ -1,20 +0,0 @@
-module Unleash
-  module Strategy
-    class UserWithId < Base
-      PARAM = 'userIds'.freeze
-
-      def name
-        'userWithId'
-      end
-
-      # requires: params['userIds'], context.user_id,
-      def is_enabled?(params = {}, context = nil)
-        return false unless params.is_a?(Hash) && params.has_key?(PARAM)
-        return false unless params.fetch(PARAM, nil).is_a? String
-        return false unless context.instance_of?(Unleash::Context)
-
-        params[PARAM].split(",").map(&:strip).include?(context.user_id)
-      end
-    end
-  end
-end

data/lib/unleash/strategy/util.rb

@@ -1,17 +0,0 @@
-require 'murmurhash3'
-
-module Unleash
-  module Strategy
-    module Util
-      module_function
-
-      NORMALIZER = 100
-      VARIANT_NORMALIZER_SEED = 86_028_157
-
-      # convert the two strings () into a number between 1 and base (100 by default)
-      def get_normalized_number(identifier, group_id, seed, base = NORMALIZER)
-        MurmurHash3::V32.str_hash("#{group_id}:#{identifier}", seed) % base + 1
-      end
-    end
-  end
-end