flagsmith 2.0.0 → 3.0.0

data/lib/flagsmith/engine/features/models.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative '../utils/hash_func'
+
+module Flagsmith
+  module Engine
+    # FeatureStateModel
+    class FeatureState
+      include Flagsmith::Engine::Utils::HashFunc
+
+      attr_reader :feature, :enabled, :django_id, :uuid, :feature_segment
+      attr_accessor :multivariate_feature_state_values
+
+      def initialize(params = {})
+        @feature = params.fetch(:feature)
+        @enabled = params.fetch(:enabled)
+        @feature_segment = params.fetch(:feature_segment, nil)
+        @django_id = params.fetch(:django_id, nil)
+        @feature_state_value = params.fetch(:feature_state_value, nil)
+        @uuid = params.fetch(:uuid, SecureRandom.uuid)
+        @multivariate_feature_state_values = params.fetch(:multivariate_feature_state_values, [])
+      end
+
+      attr_writer :feature_state_value
+
+      def get_value(identity_id = nil)
+        return multivariate_value(identity_id) if identity_id && multivariate_feature_state_values.length.positive?
+
+        @feature_state_value
+      end
+
+      alias set_value feature_state_value=
+      alias feature_state_uuid uuid
+      alias enabled? enabled
+
+      def multivariate_value(identity_id)
+        percentage_value = hashed_percentage_for_object_ids([django_id || uuid, identity_id])
+
+        start_percentage = 0
+        multivariate_feature_state_values.sort.each do |multi_fs_value|
+          limit = multi_fs_value.percentage_allocation + start_percentage
+
+          if start_percentage <= percentage_value && percentage_value < limit
+            return multi_fs_value.multivariate_feature_option.value
+          end
+
+          start_percentage = limit
+        end
+        @feature_state_value
+      end
+
+      # Returns `true` if `self` is higher segment priority than `other`
+      # (i.e. has lower value for feature_segment.priority)
+      # NOTE:
+      #     A segment will be considered higher priority only if:
+      #     1. `other` does not have a feature segment
+      #        (i.e: it is an environment feature state or it's a
+      #        feature state with feature segment but from an old document
+      #        that does not have `feature_segment.priority`)
+      #        but `self` does.
+      #     2. `other` have a feature segment with high priority
+      def higher_segment_priority?(other)
+        feature_segment.priority.to_i < (other&.feature_segment&.priority || Float::INFINITY)
+      rescue TypeError, NoMethodError
+        false
+      end
+
+      class << self
+        def build(json)
+          multivariate_feature_state_values = build_multivariate_values(json[:multivariate_feature_state_values])
+          attributes = json.slice(:uuid, :enabled, :django_id, :feature_state_value)
+                           .merge(feature: Flagsmith::Engine::Feature.build(json[:feature]))
+                           .merge(multivariate_feature_state_values: multivariate_feature_state_values)
+          if json.key?(:feature_segment) && !json[:feature_segment].nil?
+            attributes = attributes.merge(
+              feature_segment: Flagsmith::Engine::Features::Segment.new(json[:feature_segment])
+            )
+          end
+          new(**attributes)
+        end
+
+        def build_multivariate_values(multivariate_feature_state_values)
+          return [] unless multivariate_feature_state_values&.any?
+
+          multivariate_feature_state_values.map do |fsv|
+            Flagsmith::Engine::Features::MultivariateStateValue.build(fsv)
+          end
+        end
+      end
+    end
+
+    # FeatureModel
+    class Feature
+      attr_reader :id, :name, :type
+
+      def initialize(id:, name:, type:)
+        @id = id
+        @name = name
+        @type = type
+      end
+
+      def ==(other)
+        return false if other.nil?
+
+        id == other.id
+      end
+
+      class << self
+        def build(json)
+          new(**json.slice(:id, :name, :type))
+        end
+      end
+    end
+
+    module Features
+      # MultivariateFeatureOptionModel
+      class MultivariateOption
+        attr_reader :value, :id
+
+        def initialize(value:, id: nil)
+          @value = value
+          @id = id
+        end
+
+        class << self
+          def build(json)
+            new(**json.slice(:id, :value))
+          end
+        end
+      end
+
+      # MultivariateFeatureStateValueModel
+      class MultivariateStateValue
+        attr_reader :id, :multivariate_feature_option, :percentage_allocation, :mv_fs_value_uuid
+
+        def initialize(id:, multivariate_feature_option:, percentage_allocation:, mv_fs_value_uuid: SecureRandom.uuid)
+          @id = id
+          @percentage_allocation = percentage_allocation
+          @multivariate_feature_option = multivariate_feature_option
+          @mv_fs_value_uuid = mv_fs_value_uuid
+        end
+
+        def <=>(other)
+          return false if other.nil?
+
+          if !id.nil? && !other.id.nil?
+            id - other.id
+          else
+            mv_fs_value_uuid <=> other.mv_fs_value_uuid
+          end
+        end
+
+        class << self
+          def build(json)
+            new(
+              **json.slice(:id, :percentage_allocation, :mv_fs_value_uuid)
+                    .merge(multivariate_feature_option: MultivariateOption.build(json[:multivariate_feature_option]))
+            )
+          end
+        end
+      end
+
+      # FeatureSegment
+      class Segment
+        attr_reader :priority
+
+        def initialize(params = {})
+          @priority = params[:priority].nil? ? nil : params[:priority].to_i
+        end
+      end
+    end
+  end
+end

data/lib/flagsmith/engine/identities/models.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Flagsmith
+  module Engine
+    # IdentityModel
+    class Identity
+      attr_reader :identifier, :environment_api_key, :created_date, :identity_features,
+                  :identity_traits, :identity_uuid, :django_id
+
+      def initialize(params)
+        @identity_uuid = params.fetch(:identity_uuid, SecureRandom.uuid)
+        @created_date = params[:created_date].is_a?(String) ? Date.parse(params[:created_date]) : params[:created_date]
+        @identity_traits = params.fetch(:identity_traits, [])
+        @identity_features = params.fetch(:identity_features, Flagsmith::Engine::Identities::FeaturesList.new)
+        @environment_api_key = params.fetch(:environment_api_key)
+        @identifier = params.fetch(:identifier)
+        @django_id = params.fetch(:django_id, nil)
+      end
+
+      def composite_key
+        Identity.generate_composite_key(@environment_api_key, @identifier)
+      end
+
+      def update_traits(traits)
+        existing_traits = {}
+        @identity_traits.each { |trait| existing_traits[trait.key] = trait }
+
+        traits.each do |trait|
+          if trait.value.nil?
+            existing_traits.delete(trait.key)
+          else
+            existing_traits[trait.key] = trait
+          end
+        end
+
+        @identity_traits = existing_traits.values
+      end
+
+      class << self
+        def generate_composite_key(env_key, identifier)
+          "#{env_key}_#{identifier}"
+        end
+
+        def build(json)
+          identity_features = Flagsmith::Engine::Identities::FeaturesList.build(json[:identity_features])
+          identity_traits = json.fetch(:identity_traits, [])
+                                .map { |t| Flagsmith::Engine::Identities::Trait.build(t) }
+
+          Identity.new(
+            **json.slice(:identifier, :identity_uuid, :environment_api_key, :created_date, :django_id)
+                  .merge(identity_features: identity_features, identity_traits: identity_traits)
+          )
+        end
+      end
+    end
+
+    module Identities
+      # TraitModel
+      class Trait
+        attr_reader :trait_value, :trait_key
+
+        def initialize(trait_key:, trait_value:)
+          @trait_key = trait_key
+          @trait_value = trait_value
+        end
+
+        alias key trait_key
+        alias value trait_value
+
+        class << self
+          def build(json)
+            new(**json.slice(:trait_key, :trait_value))
+          end
+        end
+      end
+
+      class NotUniqueFeatureState < StandardError; end
+
+      # IdentityFeaturesList
+      class FeaturesList
+        include Enumerable
+
+        def initialize(list = [])
+          @list = []
+          list.each { |item| @list << item }
+        end
+
+        def <<(item)
+          @list.each do |v|
+            next unless v.django_id == item.django_id
+
+            raise NotUniqueFeatureState, "Feature state for this feature already exists, django_id: #{django_id}"
+          end
+          @list << item
+        end
+
+        alias push <<
+
+        def each(&block)
+          @list.each { |item| block&.call(item) || item }
+        end
+
+        class << self
+          def build(identity_features)
+            return new unless identity_features&.any?
+
+            new(
+              identity_features.map { |f| Flagsmith::Engine::FeatureState.build(f) }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flagsmith/engine/organisations/models.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Flagsmith
+  module Engine
+    # OrganisationModel
+    class Organisation
+      attr_reader :id, :name, :feature_analitycs, :stop_serving_flags, :persist_trait_data
+
+      def initialize(id:, name:, stop_serving_flags:, persist_trait_data:, feature_analitycs: nil)
+        @id = id
+        @name = name
+        @feature_analitycs = feature_analitycs
+        @stop_serving_flags = stop_serving_flags
+        @persist_trait_data = persist_trait_data
+      end
+
+      def unique_slug
+        "#{id}-#{name}"
+      end
+
+      class << self
+        def build(json)
+          new(**json.slice(:id, :name, :feature_analitycs, :stop_serving_flags, :persist_trait_data))
+        end
+      end
+    end
+  end
+end

data/lib/flagsmith/engine/projects/models.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Flagsmith
+  module Engine
+    # ProjectModel
+    class Project
+      attr_reader :id, :name, :organisation
+      attr_accessor :segments, :hide_disabled_flags
+
+      def initialize(id:, name:, organisation:, hide_disabled_flags:, segments: [])
+        @id = id
+        @name = name
+        @hide_disabled_flags = hide_disabled_flags
+        @organisation = organisation
+        @segments = segments
+      end
+
+      class << self
+        def build(json)
+          segments = json.fetch(:segments, []).map { |s| Flagsmith::Engine::Segment.build(s) }
+
+          new(
+            **json.slice(:id, :name, :hide_disabled_flags)
+                  .merge(organisation: Flagsmith::Engine::Organisation.build(json[:organisation]))
+                  .merge(segments: segments)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/flagsmith/engine/segments/constants.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Flagsmith
+  module Engine
+    module Segments
+      module Constants
+        # Segment Rules
+        ALL_RULE = 'ALL'
+        ANY_RULE = 'ANY'
+        NONE_RULE = 'NONE'
+
+        RULE_TYPES = [ALL_RULE, ANY_RULE, NONE_RULE].freeze
+
+        # Segment Condition Operators
+        EQUAL = 'EQUAL'
+        GREATER_THAN = 'GREATER_THAN'
+        LESS_THAN = 'LESS_THAN'
+        LESS_THAN_INCLUSIVE = 'LESS_THAN_INCLUSIVE'
+        CONTAINS = 'CONTAINS'
+        GREATER_THAN_INCLUSIVE = 'GREATER_THAN_INCLUSIVE'
+        NOT_CONTAINS = 'NOT_CONTAINS'
+        NOT_EQUAL = 'NOT_EQUAL'
+        REGEX = 'REGEX'
+        PERCENTAGE_SPLIT = 'PERCENTAGE_SPLIT'
+
+        CONDITION_OPERATORS = [
+          EQUAL,
+          GREATER_THAN,
+          LESS_THAN,
+          LESS_THAN_INCLUSIVE,
+          CONTAINS,
+          GREATER_THAN_INCLUSIVE,
+          NOT_CONTAINS,
+          NOT_EQUAL,
+          REGEX,
+          PERCENTAGE_SPLIT
+        ].freeze
+      end
+    end
+  end
+end

data/lib/flagsmith/engine/segments/evaluator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+require_relative '../utils/hash_func'
+
+module Flagsmith
+  module Engine
+    module Segments
+      # Evaluator methods
+      module Evaluator
+        include Flagsmith::Engine::Segments::Constants
+        include Flagsmith::Engine::Utils::HashFunc
+
+        def get_identity_segments(environment, identity, override_traits = nil)
+          environment.project.segments.select do |s|
+            evaluate_identity_in_segment(identity, s, override_traits)
+          end
+        end
+
+        # Evaluates whether a given identity is in the provided segment.
+        #
+        # :param identity: identity model object to evaluate
+        # :param segment: segment model object to evaluate
+        # :param override_traits: pass in a list of traits to use instead of those on the
+        #     identity model itself
+        # :return: True if the identity is in the segment, False otherwise
+        def evaluate_identity_in_segment(identity, segment, override_traits = nil)
+          segment.rules&.length&.positive? &&
+            segment.rules.all? do |rule|
+              traits_match_segment_rule(
+                override_traits || identity.identity_traits,
+                rule,
+                segment.id,
+                identity.django_id || identity.composite_key
+              )
+            end
+        end
+
+        def traits_match_segment_rule(identity_traits, rule, segment_id, identity_id)
+          matching_block = lambda { |condition|
+            traits_match_segment_condition(identity_traits, condition, segment_id, identity_id)
+          }
+
+          matches_conditions =
+            if rule.conditions&.length&.positive?
+              rule.conditions.send(rule.matching_function, &matching_block)
+            else true
+            end
+
+          matches_conditions &&
+            rule.rules.all? { |r| traits_match_segment_rule(identity_traits, r, segment_id, identity_id) }
+        end
+
+        def traits_match_segment_condition(identity_traits, condition, segment_id, identity_id)
+          if condition.operator == PERCENTAGE_SPLIT
+            return hashed_percentage_for_object_ids([segment_id, identity_id]) <= condition.value.to_f
+          end
+
+          trait = identity_traits.find { |t| t.key == condition.property }
+
+          return condition.match_trait_value?(trait.value) if trait
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/flagsmith/engine/segments/models.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative 'constants'
+
+module Flagsmith
+  module Engine
+    # SegmentModel
+    class Segment
+      attr_reader :id, :name
+      attr_accessor :rules, :feature_states
+
+      def initialize(id:, name:, rules: [], feature_states: [])
+        @id = id
+        @name = name
+        @rules = rules
+        @feature_states = feature_states
+      end
+
+      class << self
+        def build(json)
+          feature_states = json.fetch(:feature_states, []).map { |fs| Flagsmith::Engine::FeatureState.build(fs) }
+          rules = json.fetch(:rules, []).map { |rule| Flagsmith::Engine::Segments::Rule.build(rule) }
+
+          new(
+            **json.slice(:id, :name)
+                  .merge(feature_states: feature_states, rules: rules)
+          )
+        end
+      end
+    end
+
+    module Segments
+      # SegmentConditionModel
+      class Condition
+        include Constants
+        attr_reader :operator, :value, :property
+
+        MATCHING_FUNCTIONS = {
+          EQUAL => ->(other_value, self_value) { other_value == self_value },
+          GREATER_THAN => ->(other_value, self_value) { other_value > self_value },
+          GREATER_THAN_INCLUSIVE => ->(other_value, self_value) { other_value >= self_value },
+          LESS_THAN => ->(other_value, self_value) { other_value < self_value },
+          LESS_THAN_INCLUSIVE => ->(other_value, self_value) { other_value <= self_value },
+          NOT_EQUAL => ->(other_value, self_value) { other_value != self_value },
+          CONTAINS => ->(other_value, self_value) { other_value.include? self_value },
+
+          NOT_CONTAINS => ->(other_value, self_value) { !other_value.include? self_value },
+          REGEX => ->(other_value, self_value) { other_value.match? self_value }
+        }.freeze
+
+        def initialize(operator:, value:, property: nil)
+          @operator = operator
+          @value = value
+          @property = property
+        end
+
+        def match_trait_value?(trait_value)
+          if @value.is_a?(String) && @value.match?(/:semver$/)
+            trait_value = Semantic::Version.new(trait_value.gsub(/:semver$/, ''))
+          end
+
+          type_as_trait_value = format_to_type_of(trait_value)
+          formatted_value = type_as_trait_value ? type_as_trait_value.call(@value) : @value
+
+          MATCHING_FUNCTIONS[operator]&.call(trait_value, formatted_value)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def format_to_type_of(input)
+          {
+            'String' => ->(v) { v.to_s },
+            'Semantic::Version' => ->(v) { Semantic::Version.new(v.to_s.gsub(/:semver$/, '')) },
+            'TrueClass' => ->(v) { ['True', 'true', 'TRUE', true, 1, '1'].include?(v) ? true : false },
+            'FalseClass' => ->(v) { ['False', 'false', 'FALSE', false, 0, '0'].include?(v) ? false : true },
+            'Integer' => ->(v) { v.to_i },
+            'Float' => ->(v) { v.to_f }
+          }[input.class.to_s]
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        class << self
+          def build(json)
+            new(**json.slice(:operator, :value).merge(property: json[:property_]))
+          end
+        end
+      end
+
+      # SegmentRuleModel
+      class Rule
+        include Constants
+        MATCHING_FUNCTIONS = {
+          ANY_RULE => :any?,
+          ALL_RULE => :all?,
+          NONE_RULE => :none?
+        }.freeze
+
+        attr_accessor :type, :rules, :conditions
+
+        def initialize(type: nil, rules: [], conditions: [])
+          @type = type
+          @rules = rules
+          @conditions = conditions
+        end
+
+        def matching_function
+          MATCHING_FUNCTIONS[type]
+        end
+
+        class << self
+          def build(json)
+            rules = json.fetch(:rules, []).map { |r| Flagsmith::Engine::Segments::Rule.build(r) }
+            conditions = json.fetch(:conditions, []).map { |c| Flagsmith::Engine::Segments::Condition.build(c) }
+            new(
+              type: json[:type], rules: rules, conditions: conditions
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flagsmith/engine/utils/hash_func.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Flagsmith
+  module Engine
+    module Utils
+      # HashFunction
+      module HashFunc
+        # Given a list of object ids, get a floating point number between 0 (inclusive) and
+        # 100 (exclusive) based on the hash of those ids. This should give the same value
+        # every time for any list of ids.
+        #
+        # :param object_ids: list of object ids to calculate the hash for
+        # :param iterations: num times to include each id in the generated string to hash
+        # :return: (float) number between 0 (inclusive) and 100 (exclusive)
+        def hashed_percentage_for_object_ids(object_ids, iterations = 1)
+          to_hash = (object_ids.map(&:to_s) * iterations).flatten.join(',')
+
+          hashed_value = Digest::MD5.hexdigest(to_hash.encode('utf-8'))
+          hashed_value_as_int = hashed_value.to_i(16)
+          value = ((hashed_value_as_int % 9999).to_f / 9998) * 100
+
+          # since we want a number between 0 (inclusive) and 100 (exclusive), in the
+          # unlikely case that we get the exact number 100, we call the method again
+          # and increase the number of iterations to ensure we get a different result
+          return hashed_percentage_for_object_ids(object_ids, iterations + 1) if value == 100
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/flagsmith/hash_slice.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Flagsmith
+  # Hash#slice was added in ruby version 2.5
+  module HashSlice
+    def slice(*keys)
+      select { |key, _value| keys.include?(key) }
+    end
+  end
+end
+
+Hash.include Flagsmith::HashSlice if RUBY_VERSION < '2.5.0'

data/lib/flagsmith/sdk/analytics_processor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Flagsmith
+  # Used to control how often we send data(in seconds)
+  class AnalyticsProcessor
+    ENDPOINT = 'analytics/flags/'
+    TIMER = 10
+    attr_reader :last_flushed, :timeout, :analytics_data
+
+    # AnalyticsProcessor is used to track how often individual Flags are evaluated within
+    # the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.
+    #
+    # data[:environment_key] environment key obtained from the Flagsmith UI
+    # data[:base_api_url] base api url to override when using self hosted version
+    # data[:timeout] used to tell requests to stop waiting for a response after a
+    #                given number of seconds
+    def initialize(data)
+      @last_flushed = Time.now
+      @analytics_data = {}
+      @api_client = data.fetch(:api_client)
+      @timeout = data.fetch(:timeout, 3)
+    end
+
+    # Sends all the collected data to the api asynchronously and resets the timer
+    def flush
+      return if @analytics_data.empty?
+
+      @api_client.post(ENDPOINT, @analytics_data.to_json)
+
+      @analytics_data = {}
+      @last_flushed = Time.now
+    end
+
+    def track_feature(feature_id)
+      @analytics_data[feature_id] = @analytics_data.fetch(feature_id, 0) + 1
+      flush if (Time.now - @last_flushed) > TIMER * 1000
+    end
+  end
+end