splitclient-rb 6.3.0 → 8.11.0

data/lib/splitclient-rb/engine/metrics/binary_search_latency_tracker.rb

@@ -42,75 +42,13 @@ module SplitIoClient
 
     MAX_LATENCY = 7481828
 
-    attr_accessor :latencies
-
-    def initialize
-      @latencies = Array.new(BUCKETS.length, 0)
-    end
-
-    #
-    # Increment the internal counter for the bucket this latency falls into.
-    # @param millis
-    #
-    def add_latency_millis(millis, return_index = false)
-      index = find_bucket_index(millis * 1000)
-
-      return index if return_index
-
-      @latencies[index] += 1
-      @latencies
-    end
-
-    # Increment the internal counter for the bucket this latency falls into.
-    # @param micros
-    def add_latency_micros(micros, return_index = false)
-      index = find_bucket_index(micros)
-
-      return index if return_index
-
-      @latencies[index] += 1
-      @latencies
-    end
-
-    # Returns the list of latencies buckets as an array.
-    #
-    #
-    # @return the list of latencies buckets as an array.
-    def get_latencies
-      @latencies
-    end
-
-    def get_latency(index)
-      return @latencies[index]
-    end
-
-    def clear
-      @latencies = Array.new(BUCKETS.length, 0)
-    end
-
-    #
-    # Returns the counts in the bucket this latency falls into.
-    # The latencies will not be updated.
-    # @param latency
-    # @return the bucket content for the latency.
-    #
-    def get_bucket_for_latency_millis(latency)
-      return @latencies[find_bucket_index(latency * 1000)]
-    end
-
-    #
-    # Returns the counts in the bucket this latency falls into.
-    # The latencies will not be updated.
-    # @param latency
-    # @return the bucket content for the latency.
-    #
-    def get_bucket_for_latency_micros(latency)
-      return @latencies[find_bucket_index(latency)]
+    def self.get_bucket(latency)
+      return find_bucket_index(latency * 1000)
     end
 
     private
 
-    def find_bucket_index(micros)
+    def self.find_bucket_index(micros)
       if (micros > MAX_LATENCY) then
         return BUCKETS.length - 1
       end

data/lib/splitclient-rb/engine/models/evaluation_options.rb

@@ -0,0 +1,9 @@
+module SplitIoClient::Engine::Models
+    class EvaluationOptions
+    attr_accessor :properties
+
+    def initialize(properties)
+        @properties = properties
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/event_active_subscriptions.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module Engine::Models
+    class EventActiveSubscriptions
+      attr_accessor :triggered, :handler
+
+      def initialize(triggered, handler)
+        @triggered = triggered
+        @handler = handler
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/events_metadata.rb

@@ -0,0 +1,10 @@
+module SplitIoClient::Engine::Models
+    class EventsMetadata
+    attr_accessor :type, :names
+
+    def initialize(type, names=nil)
+        @type = type
+        @names = names
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/fallback_treatment.rb

@@ -0,0 +1,11 @@
+module SplitIoClient::Engine::Models
+    class FallbackTreatment
+    attr_accessor :treatment, :config, :label
+
+    def initialize(treatment, config=nil, label=nil)
+        @treatment = treatment
+        @config = config
+        @label = label
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/fallback_treatments_configuration.rb

@@ -0,0 +1,36 @@
+module SplitIoClient::Engine::Models
+    class FallbackTreatmentsConfiguration
+    attr_accessor :global_fallback_treatment, :by_flag_fallback_treatment
+
+    def initialize(global_fallback_treatment=nil, by_flag_fallback_treatment=nil)
+        @global_fallback_treatment = build_global_fallback_treatment(global_fallback_treatment)
+        @by_flag_fallback_treatment = build_by_flag_fallback_treatment(by_flag_fallback_treatment)
+    end
+
+    private 
+
+    def build_global_fallback_treatment(global_fallback_treatment)
+      if global_fallback_treatment.is_a? String
+        return FallbackTreatment.new(global_fallback_treatment)
+      end
+      
+      global_fallback_treatment
+    end
+
+    def build_by_flag_fallback_treatment(by_flag_fallback_treatment)
+      return nil unless by_flag_fallback_treatment.is_a?(Hash)
+      processed_by_flag_fallback_treatment = Hash.new
+      
+      by_flag_fallback_treatment.each do |key, value|
+        if value.is_a? String
+          processed_by_flag_fallback_treatment[key] = FallbackTreatment.new(value)
+          next
+        end
+
+        processed_by_flag_fallback_treatment[key] = value
+      end
+
+      processed_by_flag_fallback_treatment
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/label.rb

@@ -4,4 +4,7 @@ class SplitIoClient::Engine::Models::Label
   EXCEPTION = 'exception'.freeze
   KILLED = 'killed'.freeze
   NOT_IN_SPLIT = 'not in split'.freeze
+  NOT_READY = 'not ready'.freeze
+  NOT_FOUND = 'definition not found'.freeze
+  PREREQUISITES_NOT_MET = 'prerequisites not met'.freeze
 end

data/lib/splitclient-rb/engine/models/sdk_event.rb

@@ -0,0 +1,4 @@
+class SplitIoClient::Engine::Models::SdkEvent
+  SDK_READY = 'SDK_READY'
+  SDK_UPDATE = 'SDK_UPDATE'
+end

data/lib/splitclient-rb/engine/models/sdk_event_type.rb

@@ -0,0 +1,4 @@
+class SplitIoClient::Engine::Models::SdkEventType
+  FLAG_UPDATE = 'FLAG_UPDATE'
+  SEGMENTS_UPDATE = 'SEGMENTS_UPDATE'
+end

data/lib/splitclient-rb/engine/models/sdk_internal_event.rb

@@ -0,0 +1,8 @@
+class SplitIoClient::Engine::Models::SdkInternalEvent
+  SDK_READY = 'SDK_READY'
+  FLAGS_UPDATED = 'FLAGS_UPDATED'
+  FLAG_KILLED_NOTIFICATION = 'FLAG_KILLED_NOTIFICATION'
+  SEGMENTS_UPDATED = 'SEGMENTS_UPDATED'
+  RB_SEGMENTS_UPDATED = 'RB_SEGMENTS_UPDATED'
+  LARGE_SEGMENTS_UPDATED = 'LARGE_SEGMENTS_UPDATED'
+end

data/lib/splitclient-rb/engine/models/sdk_internal_event_notification.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module Engine::Models
+    class SdkInternalEventNotification
+      attr_reader :internal_event, :metadata
+
+      def initialize(internal_event, metadata)
+        @internal_event = internal_event
+        @metadata = metadata
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/segment_type.rb

@@ -0,0 +1,4 @@
+class SplitIoClient::Engine::Models::SegmentType
+  STANDARD = 'standard'
+  RULE_BASED_SEGMENT = 'rule-based'
+end

data/lib/splitclient-rb/engine/models/split_http_response.rb

@@ -0,0 +1,19 @@
+module SplitIoClient
+  module Engine
+    module Models
+      class SplitHttpResponse
+        attr_accessor :status, :body
+
+        def initialize(status, body, success)
+          @status = status
+          @body = body
+          @success = success
+        end
+
+        def success?
+          @success
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/models/valid_sdk_event.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module Engine::Models
+    class ValidSdkEvent
+      attr_reader :sdk_event, :valid
+
+      def initialize(sdk_event, valid)
+        @sdk_event = sdk_event
+        @valid = valid
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/parser/condition.rb

@@ -11,13 +11,14 @@ module SplitIoClient
     # @returns [object] condition values
     attr_accessor :data
 
-    def initialize(condition)
+    def initialize(condition, config)
       @data = condition
       @partitions = set_partitions
+      @config = config
     end
 
     def create_condition_matcher(matchers)
-      CombiningMatcher.new(combiner, matchers) if combiner
+      CombiningMatcher.new(@config.split_logger, combiner, matchers) if combiner
     end
 
     #
@@ -45,11 +46,11 @@ module SplitIoClient
     end
 
     def negation_matcher(matcher)
-      NegationMatcher.new(matcher)
+      NegationMatcher.new(@config.split_logger, matcher)
     end
 
     def matcher_all_keys(_params)
-      @matcher_all_keys ||= AllKeysMatcher.new
+      @matcher_all_keys ||= AllKeysMatcher.new(@config.split_logger)
     end
 
     # returns UserDefinedSegmentMatcher[object]
@@ -57,7 +58,7 @@ module SplitIoClient
       matcher = params[:matcher]
       segment_name = matcher[:userDefinedSegmentMatcherData] && matcher[:userDefinedSegmentMatcherData][:segmentName]
 
-      UserDefinedSegmentMatcher.new(params[:segments_repository], segment_name)
+      UserDefinedSegmentMatcher.new(params[:segments_repository], segment_name, @config.split_logger)
     end
 
     # returns WhitelistMatcher[object] the whitelist for this condition in case it has a whitelist matcher
@@ -72,7 +73,7 @@ module SplitIoClient
         white_list = (matcher[:whitelistMatcherData])[:whitelist]
         result =  { attribute: attribute, value: white_list }
       end
-      WhitelistMatcher.new(result)
+      WhitelistMatcher.new(result, @config.split_logger, @config.split_validator)
     end
 
     def matcher_equal_to(params)
@@ -80,7 +81,7 @@ module SplitIoClient
       attribute = (matcher[:keySelector])[:attribute]
       value = (matcher[:unaryNumericMatcherData])[:value]
       data_type = (matcher[:unaryNumericMatcherData])[:dataType]
-      EqualToMatcher.new(attribute: attribute, value: value, data_type: data_type)
+      EqualToMatcher.new({attribute: attribute, value: value, data_type: data_type}, @config.split_logger, @config.split_validator)
     end
 
     def matcher_greater_than_or_equal_to(params)
@@ -88,7 +89,7 @@ module SplitIoClient
       attribute = (matcher[:keySelector])[:attribute]
       value = (matcher[:unaryNumericMatcherData])[:value]
       data_type = (matcher[:unaryNumericMatcherData])[:dataType]
-      GreaterThanOrEqualToMatcher.new(attribute: attribute, value: value, data_type: data_type)
+      GreaterThanOrEqualToMatcher.new({attribute: attribute, value: value, data_type: data_type}, @config.split_logger, @config.split_validator)
     end
 
     def matcher_less_than_or_equal_to(params)
@@ -96,7 +97,7 @@ module SplitIoClient
       attribute = (matcher[:keySelector])[:attribute]
       value = (matcher[:unaryNumericMatcherData])[:value]
       data_type = (matcher[:unaryNumericMatcherData])[:dataType]
-      LessThanOrEqualToMatcher.new(attribute: attribute, value: value, data_type: data_type)
+      LessThanOrEqualToMatcher.new({attribute: attribute, value: value, data_type: data_type}, @config.split_logger, @config.split_validator)
     end
 
     def matcher_between(params)
@@ -105,79 +106,137 @@ module SplitIoClient
       start_value = (matcher[:betweenMatcherData])[:start]
       end_value = (matcher[:betweenMatcherData])[:end]
       data_type = (matcher[:betweenMatcherData])[:dataType]
-      BetweenMatcher.new(attribute: attribute, start_value: start_value, end_value: end_value, data_type: data_type)
+      BetweenMatcher.new({attribute: attribute, start_value: start_value, end_value: end_value, data_type: data_type}, @config.split_logger, @config.split_validator)
     end
 
     def matcher_equal_to_set(params)
       EqualToSetMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:whitelistMatcherData][:whitelist]
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
       )
     end
 
     def matcher_contains_any_of_set(params)
       ContainsAnyMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:whitelistMatcherData][:whitelist]
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
       )
     end
 
     def matcher_contains_all_of_set(params)
       ContainsAllMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:whitelistMatcherData][:whitelist]
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
       )
     end
 
     def matcher_part_of_set(params)
       PartOfSetMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:whitelistMatcherData][:whitelist]
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
       )
     end
 
     def matcher_starts_with(params)
       StartsWithMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:whitelistMatcherData][:whitelist]
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
       )
     end
 
     def matcher_ends_with(params)
       EndsWithMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:whitelistMatcherData][:whitelist]
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger
       )
     end
 
     def matcher_contains_string(params)
       ContainsMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:whitelistMatcherData][:whitelist]
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger, @config.split_validator
       )
     end
 
     def matcher_in_split_treatment(params)
       DependencyMatcher.new(
         params[:matcher][:dependencyMatcherData][:split],
-        params[:matcher][:dependencyMatcherData][:treatments]
+        params[:matcher][:dependencyMatcherData][:treatments],
+        @config.split_logger
       )
     end
 
     def matcher_equal_to_boolean(params)
       EqualToBooleanMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:booleanMatcherData]
+        params[:matcher][:booleanMatcherData],
+        @config.split_logger
       )
     end
 
     def matcher_matches_string(params)
       MatchesStringMatcher.new(
         params[:matcher][:keySelector][:attribute],
-        params[:matcher][:stringMatcherData]
+        params[:matcher][:stringMatcherData],
+        @config.split_logger
       )
     end
 
+    def matcher_equal_to_semver(params)
+      EqualToSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:stringMatcherData],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_greater_than_or_equal_to_semver(params)
+      GreaterThanOrEqualToSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:stringMatcherData],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_less_than_or_equal_to_semver(params)
+      LessThanOrEqualToSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:stringMatcherData],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_between_semver(params)
+      BetweenSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:betweenStringMatcherData][:start],
+        params[:matcher][:betweenStringMatcherData][:end],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_in_list_semver(params)
+      InListSemverMatcher.new(
+        params[:matcher][:keySelector][:attribute],
+        params[:matcher][:whitelistMatcherData][:whitelist],
+        @config.split_logger, @config.split_validator
+      )
+    end
+
+    def matcher_in_rule_based_segment(params)
+      matcher = params[:matcher]
+      segment_name = matcher[:userDefinedSegmentMatcherData] && matcher[:userDefinedSegmentMatcherData][:segmentName]
+
+      RuleBasedSegmentMatcher.new(params[:segments_repository], params[:rule_based_segments_repository], segment_name, @config)
+    end
+
     #
     # @return [object] the negate value for this condition
     def negate
@@ -194,6 +253,8 @@ module SplitIoClient
     # @return [void]
     def set_partitions
       partitions_list = []
+      return partitions_list unless @data.key?(:partitions) or @data.key?('partitions')
+      
       @data[:partitions].each do |p|
         partition = SplitIoClient::Partition.new(p)
         partitions_list << partition

data/lib/splitclient-rb/engine/parser/evaluator.rb

@@ -2,53 +2,52 @@ module SplitIoClient
   module Engine
     module Parser
       class Evaluator
-        def initialize(segments_repository, splits_repository, multiple = false)
+        def initialize(segments_repository, splits_repository, rb_segment_repository, config)
           @splits_repository = splits_repository
           @segments_repository = segments_repository
-          @multiple = multiple
-          @cache = {}
+          @rb_segment_repository = rb_segment_repository
+          @config = config
         end
 
-        def call(keys, split, attributes = nil)
+        def evaluate_feature_flag(keys, feature_flag, attributes = nil)
           # DependencyMatcher here, split is actually a split_name in this case
-          cache_result = split.is_a? String
-          split = @splits_repository.get_split(split) if cache_result
-          digest = Digest::MD5.hexdigest("#{{matching_key: keys[:matching_key]}}#{split}#{attributes}")
+          cache_result = feature_flag.is_a? String
+          feature_flag = @splits_repository.get_split(feature_flag) if cache_result
+          evaluate_treatment(keys, feature_flag, attributes)
+        end
 
-          if Models::Split.archived?(split)
-            return treatment_hash(Models::Label::ARCHIVED, Models::Treatment::CONTROL, split[:changeNumber])
-          end
+        private
 
-          treatment = if Models::Split.matchable?(split)
-            if @multiple && @cache[digest]
-              @cache[digest]
-            else
-              match(split, keys, attributes)
-            end
-          else
-            treatment_hash(Models::Label::KILLED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
+        def evaluate_treatment(keys, feature_flag, attributes)
+          if Models::Split.archived?(feature_flag)
+            return treatment_hash(Models::Label::ARCHIVED, Models::Treatment::CONTROL, feature_flag[:changeNumber])
           end
 
-          @cache[digest] = treatment if cache_result
+          treatment = if Models::Split.matchable?(feature_flag)
+                        match(feature_flag, keys, attributes)
+                      else
+                        treatment_hash(Models::Label::KILLED, feature_flag[:defaultTreatment], feature_flag[:changeNumber], split_configurations(feature_flag[:defaultTreatment], feature_flag))
+                      end
 
           treatment
         end
 
-        private
-
         def split_configurations(treatment, split)
           return nil if split[:configurations].nil?
           split[:configurations][treatment.to_sym]
         end
 
         def match(split, keys, attributes)
+
+          return treatment_hash(Models::Label::PREREQUISITES_NOT_MET, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split)) unless check_prerequisites_matcher(split, keys, attributes)
+
           in_rollout = false
           key = keys[:bucketing_key] ? keys[:bucketing_key] : keys[:matching_key]
           legacy_algo = (split[:algo] == 1 || split[:algo] == nil) ? true : false
           splitter = Splitter.new
 
           split[:conditions].each do |c|
-            condition = SplitIoClient::Condition.new(c)
+            condition = SplitIoClient::Condition.new(c, @config)
 
             next if condition.empty?
 
@@ -63,8 +62,7 @@ module SplitIoClient
 
               in_rollout = true
             end
-
-            condition_matched = matcher_type(condition).match?(
+            condition_matched = Helpers::EvaluatorHelper::matcher_type(condition, @segments_repository, @rb_segment_repository).match?(
               matching_key: keys[:matching_key],
               bucketing_key: keys[:bucketing_key],
               evaluator: self,
@@ -75,35 +73,19 @@ module SplitIoClient
 
             result = splitter.get_treatment(key, split[:seed], condition.partitions, split[:algo])
 
-            if result.nil?
-              return treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
-            else
-              return treatment_hash(c[:label], result, split[:changeNumber],split_configurations(result, split))
-            end
+            return treatment_from_result(result, split, c)
           end
 
           treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
         end
 
-        def matcher_type(condition)
-          matchers = []
-
-          @segments_repository.adapter.pipelined do
-            condition.matchers.each do |matcher|
-              matchers << if matcher[:negate]
-                condition.negation_matcher(matcher_instance(matcher[:matcherType], condition, matcher))
-              else
-                matcher_instance(matcher[:matcherType], condition, matcher)
-              end
-            end
-          end
-
-          final_matcher = condition.create_condition_matcher(matchers)
+        private
 
-          if final_matcher.nil?
-            @logger.error('Invalid matcher type')
+        def treatment_from_result(result, split, condition)
+          if result.nil?
+            return treatment_hash(Models::Label::NO_RULE_MATCHED, split[:defaultTreatment], split[:changeNumber], split_configurations(split[:defaultTreatment], split))
           else
-            final_matcher
+            return treatment_hash(condition[:label], result, split[:changeNumber],split_configurations(result, split))
           end
         end
 
@@ -111,11 +93,18 @@ module SplitIoClient
           { label: label, treatment: treatment, change_number: change_number, config: configurations }
         end
 
-        def matcher_instance(type, condition, matcher)
-          condition.send(
-            "matcher_#{type.downcase}",
-            matcher: matcher, segments_repository: @segments_repository
-          )
+        def check_prerequisites_matcher(split, keys, attributes)
+          if split.key?(:prerequisites) && !split[:prerequisites].nil?
+              prerequisites_matcher = SplitIoClient::PrerequisitesMatcher.new(split[:prerequisites], @config.split_logger) 
+              return prerequisites_matcher.match?(
+                  matching_key: keys[:matching_key],
+                  bucketing_key: keys[:bucketing_key],
+                  evaluator: self,
+                  attributes: attributes
+                )
+          end
+
+          true
         end
       end
     end