unleash 4.4.4 → 6.4.0

data/lib/unleash/constraint.rb

@@ -1,115 +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
-
-    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 = DateTime.parse(val2)
-      yield(val1, val2)
-    rescue ArgumentError
-      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)
-
-      v.map!(&:upcase) if self.case_insensitive
-      context_value.upcase! if self.case_insensitive
-
-      OPERATORS[self.operator].call(context_value, v)
-    end
-  end
-end

data/lib/unleash/feature_toggle.rb

@@ -1,187 +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, :strategies, :variant_definitions
-
-    def initialize(params = {}, segment_map = {})
-      params = {} if params.nil?
-
-      self.name       = params.fetch('name', nil)
-      self.enabled    = params.fetch('enabled', false)
-
-      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)
-
-      toggle_enabled = am_enabled?(context)
-      variant = resolve_variant(context, toggle_enabled)
-
-      choice = toggle_enabled ? :yes : :no
-      Unleash.toggle_metrics.increment_variant(self.name, choice, variant.name) unless Unleash.configuration.disable_metrics
-      variant
-    end
-
-    def self.disabled_variant
-      Unleash::Variant.new(name: 'disabled', enabled: false)
-    end
-
-    private
-
-    def resolve_variant(context, toggle_enabled)
-      return Unleash::FeatureToggle.disabled_variant unless toggle_enabled
-      return Unleash::FeatureToggle.disabled_variant if sum_variant_defs_weights <= 0
-
-      variant_from_override_match(context) || variant_from_weights(context, resolve_stickiness)
-    end
-
-    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)
-      result =
-        if self.enabled
-          self.strategies.empty? ||
-            self.strategies.any? do |s|
-              strategy_enabled?(s, context) && strategy_constraint_matches?(s, context)
-            end
-        else
-          false
-        end
-
-      Unleash.logger.debug "Unleash::FeatureToggle (enabled:#{self.enabled} " \
-        "and Strategies combined with contraints returned #{result})"
-
-      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
-      self.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 = self.variant_definitions.find{ |vd| vd.override_matches_context?(context) }
-      return nil if variant.nil?
-
-      Unleash::Variant.new(name: variant.name, enabled: true, payload: variant.payload)
-    end
-
-    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 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)
-          )
-        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)
-
-        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..100)
-      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'] || "") <= 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'] || "") <= 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,16 +0,0 @@
-require 'murmurhash3'
-
-module Unleash
-  module Strategy
-    module Util
-      module_function
-
-      NORMALIZER = 100
-
-      # convert the two strings () into a number between 1 and base (100 by default)
-      def get_normalized_number(identifier, group_id, base = NORMALIZER)
-        MurmurHash3::V32.str_hash("#{group_id}:#{identifier}") % base + 1
-      end
-    end
-  end
-end

data/lib/unleash/variant_definition.rb

@@ -1,26 +0,0 @@
-require 'unleash/variant_override'
-
-module Unleash
-  class VariantDefinition
-    attr_accessor :name, :weight, :payload, :overrides, :stickiness
-
-    def initialize(name, weight = 0, payload = nil, stickiness = nil, overrides = []) # rubocop:disable Metrics/ParameterLists
-      self.name = name
-      self.weight = weight
-      self.payload = payload
-      self.stickiness = stickiness
-      self.overrides = (overrides || [])
-        .select{ |v| v.is_a?(Hash) && v.has_key?('contextName') }
-        .map{ |v| VariantOverride.new(v.fetch('contextName', ''), v.fetch('values', [])) } || []
-    end
-
-    def override_matches_context?(context)
-      self.overrides.select{ |o| o.matches_context?(context) }.first
-    end
-
-    def to_s
-      "<VariantDefinition: name=#{self.name},weight=#{self.weight},payload=#{self.payload},stickiness=#{self.stickiness}" \
-          ",overrides=#{self.overrides}>"
-    end
-  end
-end

data/lib/unleash/variant_override.rb

@@ -1,44 +0,0 @@
-module Unleash
-  class VariantOverride
-    attr_accessor :context_name, :values
-
-    def initialize(context_name, values = [])
-      self.context_name = context_name
-      self.values = values || []
-
-      validate
-    end
-
-    def to_s
-      "<VariantOverride: context_name=#{self.context_name},values=#{self.values}>"
-    end
-
-    def matches_context?(context)
-      raise ArgumentError, 'context must be of class Unleash::Context' unless context.instance_of?(Unleash::Context)
-
-      context_value =
-        case self.context_name
-        when 'userId'
-          context.user_id
-        when 'sessionId'
-          context.session_id
-        when 'remoteAddress'
-          context.remote_address
-        else
-          context.properties.fetch(self.context_name, nil)
-        end
-
-      Unleash.logger.debug "VariantOverride: context_name: #{context_name} context_value: #{context_value}"
-
-      self.values.include? context_value.to_s
-    end
-
-    private
-
-    def validate
-      raise ArgumentError, 'context_name must be a String' unless self.context_name.is_a?(String)
-      raise ArgumentError, 'values must be an Array of strings' unless self.values.is_a?(Array) \
-          && self.values.reject{ |v| v.is_a?(String) }.empty?
-    end
-  end
-end