splitclient-rb 8.3.1 → 8.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b17d201426172454ca4aafc72ffa49363c20386fb5e6515e1e734d6e915f18
-  data.tar.gz: 473d7bf15d91b38d18a05006c0ebee6c013319add4153ac40245f674398ba5d0
+  metadata.gz: 49270eca968d09db0947f123ef98071ebf93abe96fd70cca06ae9775fc79c334
+  data.tar.gz: 7205c421419bd3ab6da82eeb00361ca008d7d936eb2cc3bf83b404967f7615eb
 SHA512:
-  metadata.gz: e9c0aa0c613fb3abb35bda295ad1a9726e9ecc994b64d909b8ea12fa9b63f950785c2c46afb1592a8405871370e1dadc3ffed9e874781752a572209238b032de
-  data.tar.gz: 412dc67a3514a67def649c74db278cb3c006b8bcfbebc9cc1b231f9c9d7e565754e2b1dcc2729e1eabce33818fb2d1311d9bbcff96f715bab55b0a5413ee2358
+  metadata.gz: 9e79b5ea033863981678658a28a6444caef7564d38aad5d4a3b22d60ac569d5574b6cfba0e46a71e590a89b22eabea3ab8103f23320ce2101d96b106712e6eeb
+  data.tar.gz: 2f1d582dc82f396cc50400252b38155924677dc593c0a3524c2080b3d1bb93b781ee66563b2939ac064bd080296ad4797fcb0021030fa8827c799934e8bf11a7

data/CHANGES.txt

@@ -1,5 +1,13 @@
 CHANGES
 
+8.5.0 (Jan 17, 2025)
+- Fixed high cpu usage when unique keys are cleared every 24 hours.
+- Added support for the new impressions tracking toggle available on feature flags, both respecting the setting and including the new field being returned on SplitView type objects. Read more in our docs.
+
+8.4.0 (May 3, 2024)
+- Fixed issue preventing Impressopns and Events posting if client.destroy is called before the post threads started
+- Added support for targeting rules based on semantic versions (https://semver.org/).
+
 8.3.1 (Mar 22, 2024)
 - Fixed ruby process hanging due to failed thread.join command, when calling destroy and a http request still active.
 - Fixed streaming notification parser. Issue ref: https://github.com/splitio/ruby-client/issues/511

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright © 2024 Split Software, Inc.
+Copyright © 2025 Split Software, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/lib/splitclient-rb/cache/filter/bloom_filter.rb

@@ -8,8 +8,8 @@ module SplitIoClient
       class BloomFilter
         def initialize(capacity, false_positive_probability = 0.001)
           @capacity = capacity.round
-          m = best_m(capacity, false_positive_probability)
-          @ba = BitArray.new(m.round)
+          @m = best_m(capacity, false_positive_probability)
+          reset_filter
           @k = best_k(capacity)
         end
 
@@ -17,22 +17,26 @@ module SplitIoClient
           return false if contains?(string)
 
           positions = hashes(string)
-          
           positions.each { |position| @ba[position] = 1 }
 
           true
         end
-      
+
         def contains?(string)
           !hashes(string).any? { |ea| @ba[ea] == 0 }
         end
 
         def clear
-          @ba.size.times { |i| @ba[i] = 0 }
+          @ba = nil
+          reset_filter
         end
-      
+
         private
 
+        def reset_filter
+          @ba = BitArray.new(@m.round)
+        end
+
         # m is the required number of bits in the array
         def best_m(capacity, false_positive_probability)
           -(capacity * Math.log(false_positive_probability)) / (Math.log(2) ** 2)

data/lib/splitclient-rb/cache/repositories/events/memory_repository.rb

@@ -29,6 +29,10 @@ module SplitIoClient
             @adapter.clear
           end
 
+          def empty?
+            @adapter.empty?
+          end
+
           def batch
             return [] if @config.events_queue_size.zero?
 

data/lib/splitclient-rb/cache/repositories/events_repository.rb

@@ -25,6 +25,10 @@ module SplitIoClient
           @config.log_found_exception(__method__.to_s, e)
         end
 
+        def empty?
+          @repository.empty?
+         end
+
         protected
 
         def metadata

data/lib/splitclient-rb/cache/repositories/splits_repository.rb

@@ -5,6 +5,32 @@ module SplitIoClient
     module Repositories
       class SplitsRepository < Repository
         attr_reader :adapter
+        DEFAULT_CONDITIONS_TEMPLATE = [{
+          conditionType: "ROLLOUT",
+          matcherGroup: {
+              combiner: "AND",
+              matchers: [
+              {
+                  keySelector: nil,
+                  matcherType: "ALL_KEYS",
+                  negate: false,
+                  userDefinedSegmentMatcherData: nil,
+                  whitelistMatcherData: nil,
+                  unaryNumericMatcherData: nil,
+                  betweenMatcherData: nil,
+                  dependencyMatcherData: nil,
+                  booleanMatcherData: nil,
+                  stringMatcherData: nil
+              }]
+          },
+          partitions: [
+              {
+              treatment: "control",
+              size: 100
+              }
+          ],
+          label: "targeting rule type unsupported by sdk"
+        }]
 
         def initialize(config, flag_sets_repository, flag_set_filter)
           super(config)
@@ -155,6 +181,10 @@ module SplitIoClient
             remove_from_flag_sets(existing_split)
           end
 
+          if check_undefined_matcher(split)
+            @config.logger.warn("Feature Flag #{split[:name]} has undefined matcher, setting conditions to default template.")
+            split[:conditions] = SplitsRepository::DEFAULT_CONDITIONS_TEMPLATE
+          end
           if !split[:sets].nil?
             for flag_set in split[:sets]
               if !@flag_sets.flag_set_exist?(flag_set)
@@ -170,6 +200,18 @@ module SplitIoClient
           @adapter.set_string(namespace_key(".split.#{split[:name]}"), split.to_json)
         end
 
+        def check_undefined_matcher(split)
+          for condition in split[:conditions]
+            for matcher in condition[:matcherGroup][:matchers]
+              if !SplitIoClient::Condition.instance_methods(false).map(&:to_s).include?("matcher_#{matcher[:matcherType].downcase}")
+                @config.logger.error("Detected undefined matcher #{matcher[:matcherType].downcase} in feature flag #{split[:name]}")
+                return true
+              end
+            end
+          end
+          return false
+        end
+
         def remove_feature_flag(split)
           decrease_tt_name_count(split[:trafficTypeName])
           remove_from_flag_sets(split)

data/lib/splitclient-rb/clients/split_client.rb

@@ -96,7 +96,16 @@ module SplitIoClient
 
     def destroy
       @config.logger.info('Split client shutdown started...') if @config.debug_enabled
-
+      if !@config.cache_adapter.is_a?(SplitIoClient::Cache::Adapters::RedisAdapter) && @config.impressions_mode != :none &&
+          (!@impressions_repository.empty? || !@events_repository.empty?)
+        @config.logger.debug("Impressions and/or Events cache is not empty")
+        # Adding small delay to ensure sender threads are fully running
+        sleep(0.1)
+        if !@config.threads.key?(:impressions_sender) || !@config.threads.key?(:events_sender)
+          @config.logger.debug("Periodic data recording thread has not started yet, waiting for service startup.")
+          @config.threads[:start_sdk].join(5) if @config.threads.key?(:start_sdk)
+        end
+      end
       @config.threads.select { |name, thread| name.to_s.end_with? 'sender' }.values.each do |thread|
         thread.raise(SplitIoClient::SDKShutdownException)
         thread.join
@@ -258,7 +267,7 @@ module SplitIoClient
         to_return = Hash.new
         sanitized_feature_flag_names.each {|name|
           to_return[name.to_sym] = control_treatment_with_config
-          impressions << @impressions_manager.build_impression(matching_key, bucketing_key, name.to_sym, control_treatment_with_config.merge({ label: Engine::Models::Label::NOT_READY }), { attributes: attributes, time: nil })
+          impressions << { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, name.to_sym, control_treatment_with_config.merge({ :label => Engine::Models::Label::NOT_READY }), false, { attributes: attributes, time: nil }), :disabled => false }
         }
         @impressions_manager.track(impressions)
         return to_return
@@ -269,7 +278,6 @@ module SplitIoClient
         valid_feature_flag_names << feature_flag_name unless feature_flag_name.nil?
       }
       start = Time.now
-      impressions_total = []
 
       feature_flags = @splits_repository.splits(valid_feature_flag_names)
       treatments = Hash.new
@@ -282,15 +290,14 @@ module SplitIoClient
           next
         end
         treatments_labels_change_numbers, impressions = evaluate_treatment(feature_flag, key, bucketing_key, matching_key, attributes, calling_method)
-        impressions_total.concat(impressions) unless impressions.nil?
         treatments[key] =
         {
           treatment: treatments_labels_change_numbers[:treatment],
           config: treatments_labels_change_numbers[:config]
         }
+        @impressions_manager.track(impressions) unless impressions.empty?
       end
       record_latency(calling_method, start)
-      @impressions_manager.track(impressions_total) unless impressions_total.empty?
 
       treatments.merge(invalid_treatments)
     end
@@ -323,50 +330,50 @@ module SplitIoClient
       end
 
       feature_flag = @splits_repository.get_split(feature_flag_name)
-      treatments, impressions = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple)
+      treatments, impressions_decorator = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple)
 
-      @impressions_manager.track(impressions) unless impressions.nil?
+      @impressions_manager.track(impressions_decorator) unless impressions_decorator.nil?
       treatments
     end
 
     def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple = false)
-      impressions = []
+      impressions_decorator = []
       begin
         start = Time.now
         if feature_flag.nil? && ready?
           @config.logger.warn("#{calling_method}: you passed #{feature_flag_name} that " \
             'does not exist in this environment, please double check what feature flags exist in the Split user interface')
-          return parsed_treatment(control_treatment.merge({ label: Engine::Models::Label::NOT_FOUND }), multiple), nil
+          return parsed_treatment(control_treatment.merge({ :label => Engine::Models::Label::NOT_FOUND }), multiple), nil
         end
-        treatment_data =
+
         if !feature_flag.nil? && ready?
-          @evaluator.evaluate_feature_flag(
+          treatment_data = @evaluator.evaluate_feature_flag(
             { bucketing_key: bucketing_key, matching_key: matching_key }, feature_flag, attributes
           )
+          impressions_disabled = feature_flag[:impressionsDisabled]
         else
           @config.logger.error("#{calling_method}: the SDK is not ready, results may be incorrect for feature flag #{feature_flag_name}. Make sure to wait for SDK readiness before using this method.")
-          control_treatment.merge({ label: Engine::Models::Label::NOT_READY })
+          treatment_data = control_treatment.merge({ :label => Engine::Models::Label::NOT_READY })
+          impressions_disabled = false
         end
 
         record_latency(calling_method, start)
-        impression = @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, treatment_data, { attributes: attributes, time: nil })
-        impressions << impression unless impression.nil?
+        impression_decorator = { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, treatment_data, impressions_disabled, { attributes: attributes, time: nil }), :disabled => impressions_disabled }
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
       rescue StandardError => e
         @config.log_found_exception(__method__.to_s, e)
-
         record_exception(calling_method)
+        impression_decorator = { :impression => @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, control_treatment, false, { attributes: attributes, time: nil }), :disabled => false }
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
 
-        impression = @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, control_treatment, { attributes: attributes, time: nil })
-        impressions << impression unless impression.nil?
-
-        return parsed_treatment(control_treatment.merge({ label: Engine::Models::Label::EXCEPTION }), multiple), impressions
+        return parsed_treatment(control_treatment.merge({ :label => Engine::Models::Label::EXCEPTION }), multiple), impressions_decorator
       end
 
-      return parsed_treatment(treatment_data, multiple), impressions
+      return parsed_treatment(treatment_data, multiple), impressions_decorator
     end
 
     def control_treatment
-      { treatment: Engine::Models::Treatment::CONTROL }
+      { :treatment => Engine::Models::Treatment::CONTROL }
     end
 
     def control_treatment_with_config

data/lib/splitclient-rb/engine/api/client.rb

@@ -10,6 +10,7 @@ module SplitIoClient
       end
 
       def get_api(url, api_key, params = {}, cache_control_headers = false)
+        api_client.options.params_encoder.sort_params = false
         api_client.get(url, params) do |req|
           req.headers = common_headers(api_key).merge('Accept-Encoding' => 'gzip')
           req.headers = req.headers.merge('Cache-Control' => 'no-cache') if cache_control_headers
@@ -29,7 +30,7 @@ module SplitIoClient
           req.headers = common_headers(api_key)
                         .merge('Content-Type' => 'application/json')
                         .merge(headers)
-          
+
           machine_ip = @config.machine_ip
           machine_name = @config.machine_name
 
@@ -55,6 +56,7 @@ module SplitIoClient
         @api_client ||= Faraday.new do |builder|
           builder.use SplitIoClient::FaradayMiddleware::Gzip
           builder.adapter :net_http_persistent
+          builder.options.params_encoder = Faraday::FlatParamsEncoder
         end
       end
 

data/lib/splitclient-rb/engine/api/splits.rb

@@ -4,6 +4,7 @@ module SplitIoClient
   module Api
     # Retrieves split definitions from the Split Backend
     class Splits < Client
+
       def initialize(api_key, config, telemetry_runtime_producer)
         super(config)
         @api_key = api_key
@@ -11,12 +12,12 @@ module SplitIoClient
         @flag_sets_filter = @config.flag_sets_filter
       end
 
-      def since(since, fetch_options = { cache_control_headers: false, till: nil, sets: nil })
+      def since(since, fetch_options = { cache_control_headers: false, till: nil, sets: nil})
         start = Time.now
 
-        params = { since: since }
-        params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
+        params = { s: SplitIoClient::Spec::FeatureFlags::SPEC_VERSION, since: since }
         params[:sets] = @flag_sets_filter.join(",") unless @flag_sets_filter.empty?
+        params[:till] = fetch_options[:till] unless fetch_options[:till].nil?
         @config.logger.debug("Fetching from splitChanges with #{params}: ")
         response = get_api("#{@config.base_uri}/splitChanges", @api_key, params, fetch_options[:cache_control_headers])
         if response.status == 414

data/lib/splitclient-rb/engine/auth_api_client.rb

@@ -14,7 +14,7 @@ module SplitIoClient
 
       def authenticate(api_key)
         start = Time.now
-        response = @api_client.get_api(@config.auth_service_url, api_key)
+        response = @api_client.get_api("#{@config.auth_service_url}?s=#{SplitIoClient::Spec::FeatureFlags::SPEC_VERSION}", api_key)
 
         return process_success(response, start) if response.success?
 

data/lib/splitclient-rb/engine/common/impressions_manager.rb

@@ -18,19 +18,16 @@ module SplitIoClient
           @unique_keys_tracker = unique_keys_tracker
         end
 
-        def build_impression(matching_key, bucketing_key, split_name, treatment, params = {})
-          impression_data = impression_data(matching_key, bucketing_key, split_name, treatment, params[:time])
-
+        def build_impression(matching_key, bucketing_key, split_name, treatment_data, impressions_disabled, params = {})
+          impression_data = impression_data(matching_key, bucketing_key, split_name, treatment_data, params[:time])
           begin
-            case @config.impressions_mode
-            when :debug #  In DEBUG mode we should calculate the pt only.
-              impression_data[:pt] = @impression_observer.test_and_set(impression_data)
-            when :none # In NONE mode we should track the total amount of evaluations and the unique keys.
+            if @config.impressions_mode == :none || impressions_disabled
               @impression_counter.inc(split_name, impression_data[:m])
               @unique_keys_tracker.track(split_name, matching_key)
+            elsif @config.impressions_mode == :debug #  In DEBUG mode we should calculate the pt only.
+              impression_data[:pt] = @impression_observer.test_and_set(impression_data)
             else # In OPTIMIZED mode we should track the total amount of evaluations and deduplicate the impressions.
               impression_data[:pt] = @impression_observer.test_and_set(impression_data)
-
               @impression_counter.inc(split_name, impression_data[:m]) unless impression_data[:pt].nil?
             end
           rescue StandardError => e
@@ -40,24 +37,25 @@ module SplitIoClient
           impression(impression_data, params[:attributes])
         end
 
-        def track(impressions)
-          return if impressions.empty?
-
-          stats = { dropped: 0, queued: 0, dedupe: 0 }
-          begin
-            case @config.impressions_mode
-            when :none
-              return
-            when :debug
-              track_debug_mode(impressions, stats)
-            when :optimized
-              track_optimized_mode(impressions, stats)
+        def track(impressions_decorator)
+          return if impressions_decorator.empty?
+
+          impressions_decorator.each do |impression_decorator|
+            impression_router.add_bulk([impression_decorator[:impression]])
+            stats = { dropped: 0, queued: 0, dedupe: 0 }
+            begin
+              next if @config.impressions_mode == :none || impression_decorator[:disabled]
+
+              if @config.impressions_mode == :debug
+                track_debug_mode([impression_decorator[:impression]], stats)
+              else
+                track_optimized_mode([impression_decorator[:impression]], stats)
+              end
+            rescue StandardError => e
+              @config.log_found_exception(__method__.to_s, e)
+            ensure
+              record_stats(stats)
             end
-          rescue StandardError => e
-            @config.log_found_exception(__method__.to_s, e)
-          ensure
-            record_stats(stats)
-            impression_router.add_bulk(impressions)
           end
         end
 
@@ -126,11 +124,10 @@ module SplitIoClient
 
         def track_optimized_mode(impressions, stats)
           optimized_impressions = impressions.select { |imp| should_queue_impression?(imp[:i]) }
-
+          stats[:dedupe] = impressions.length - optimized_impressions.length
           return if optimized_impressions.empty?
 
           stats[:dropped] = @impressions_repository.add_bulk(optimized_impressions)
-          stats[:dedupe] = impressions.length - optimized_impressions.length
           stats[:queued] = optimized_impressions.length - stats[:dropped]
         end
       end

data/lib/splitclient-rb/engine/matchers/between_semver_matcher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class BetweenSemverMatcher < Matcher
+    MATCHER_TYPE = 'BETWEEN_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, start_value, end_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver_start = SplitIoClient::Semver.build(start_value, logger)
+      @semver_end = SplitIoClient::Semver.build(end_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'BetweenSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      if value_to_match.nil? || @semver_start.nil? || @semver_end.nil?
+        @logger.error('betweenStringMatcherData is required for BETWEEN_SEMVER matcher type')
+        return false
+
+      end
+      matches = ([0, -1].include?(@semver_start.compare(value_to_match)) &&
+                 [0, 1].include?(@semver_end.compare(value_to_match)))
+      @logger.debug("[BetweenMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/equal_to_semver_matcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class EqualToSemverMatcher < Matcher
+    MATCHER_TYPE = 'EQUAL_TO_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, string_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver = SplitIoClient::Semver.build(string_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'EqualsToSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      return false unless check_semver_value_to_match(value_to_match, MATCHER_TYPE)
+
+      matches = (@semver.version == value_to_match.version)
+      @logger.debug("[EqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/greater_than_or_equal_to_semver_matcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class GreaterThanOrEqualToSemverMatcher < Matcher
+    MATCHER_TYPE = 'GREATER_THAN_OR_EQUAL_TO_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, string_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver = SplitIoClient::Semver.build(string_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'GreaterThanOrEqualsToSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      return false unless check_semver_value_to_match(value_to_match, MATCHER_TYPE)
+
+      matches = [0, 1].include?(value_to_match.compare(@semver))
+      @logger.debug("[GreaterThanOrEqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/in_list_semver_matcher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class InListSemverMatcher < Matcher
+    MATCHER_TYPE = 'IN_LIST_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, list_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver_list = []
+
+      list_value.map do |item|
+        version = SplitIoClient::Semver.build(item, logger)
+        @semver_list << version unless version.nil?
+      end
+      @logger = logger
+    end
+
+    def match?(args)
+      return false if @semver_list.empty? || !verify_semver_arg?(args, 'InListSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      if value_to_match.nil?
+        @logger.error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type')
+        return false
+
+      end
+      matches = (@semver_list.map { |item| item.version == value_to_match.version }).any? { |item| item == true }
+      @logger.debug("[InListSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/less_than_or_equal_to_semver_matcher.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class LessThanOrEqualToSemverMatcher < Matcher
+    MATCHER_TYPE = 'LESS_THAN_OR_EQUAL_TO_SEMVER'
+
+    attr_reader :attribute
+
+    def initialize(attribute, string_value, logger, validator)
+      super(logger)
+      @validator = validator
+      @attribute = attribute
+      @semver = SplitIoClient::Semver.build(string_value, logger)
+      @logger = logger
+    end
+
+    def match?(args)
+      return false unless verify_semver_arg?(args, 'LessThanOrEqualsToSemverMatcher')
+
+      value_to_match = SplitIoClient::Semver.build(args[:attributes][@attribute.to_sym], @logger)
+      return false unless check_semver_value_to_match(value_to_match, MATCHER_TYPE)
+
+      matches = [0, -1].include?(value_to_match.compare(@semver))
+      @logger.debug("[LessThanOrEqualsToSemverMatcher] #{value_to_match} matches -> #{matches}")
+      matches
+    end
+  end
+end

data/lib/splitclient-rb/engine/matchers/matcher.rb

@@ -30,5 +30,23 @@ module SplitIoClient
     def string_type?
       false
     end
+
+    private
+
+    def verify_semver_arg?(args, matcher_name)
+      @logger.debug("[#{matcher_name}] evaluating value and attributes.")
+      return false unless @validator.valid_matcher_arguments(args)
+
+      true
+    end
+
+    def check_semver_value_to_match(value_to_match, matcher_spec_name)
+      if value_to_match.nil? || @semver.nil?
+        @logger.error("stringMatcherData is required for #{matcher_spec_name} matcher type")
+        return false
+
+      end
+      true
+    end
   end
 end

data/lib/splitclient-rb/engine/matchers/semver.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  class Semver
+    METADATA_DELIMITER = '+'
+    PRE_RELEASE_DELIMITER = '-'
+    VALUE_DELIMITER = '.'
+
+    attr_reader :major, :minor, :patch, :pre_release, :is_stable, :version
+
+    def initialize(version)
+      @major = 0
+      @minor = 0
+      @patch = 0
+      @pre_release = []
+      @is_stable = false
+      @version = ''
+      @metadata = ''
+      parse(version)
+    end
+
+    #
+    # Class builder
+    #
+    # @param version [String] raw version as read from splitChanges response.
+    #
+    # @return [type] Semver instance
+    def self.build(version, logger)
+      new(version)
+    rescue NoMethodError => e
+      logger.error("Failed to parse Semver data, incorrect data type:  #{e}")
+      nil
+    rescue StandardError => e
+      logger.error("Failed to parse Semver data:  #{e}")
+      nil
+    end
+
+    #
+    # Check if there is any metadata characters in version.
+    #
+    # @return [type] String semver without the metadata
+    #
+    def remove_metadata_if_exists(old_version)
+      index = old_version.index(METADATA_DELIMITER)
+      return old_version if index.nil?
+
+      @metadata = old_version[index + 1, old_version.length]
+      old_version[0, index]
+    end
+
+    # Compare the current Semver object to a given Semver object, return:
+    #      0: if self == passed
+    #      1: if self > passed
+    #      -1: if self < passed
+    #
+    # @param to_compare [trype] splitio.models.grammar.matchers.semver.Semver object
+    #
+    # @returns [Integer] based on comparison
+    def compare(to_compare)
+      return 0 if @version == to_compare.version
+
+      # Compare major, minor, and patch versions numerically
+      result = compare_attributes(to_compare)
+      return result if result != 0
+
+      # Compare pre-release versions lexically
+      compare_pre_release(to_compare)
+    end
+
+    private
+
+    def integer?(value)
+      !!value.match(/^(\d)+$/)
+    end
+
+    #
+    # Parse the string in version to update the other internal variables
+    #
+    def parse(old_version)
+      without_metadata = remove_metadata_if_exists(old_version)
+
+      index = without_metadata.index(PRE_RELEASE_DELIMITER)
+      if index.nil?
+        @is_stable = true
+      else
+        pre_release_data = without_metadata[index + 1..-1]
+        without_metadata = without_metadata[0, index]
+        @pre_release = pre_release_data.split(VALUE_DELIMITER)
+      end
+      assign_major_minor_and_patch(without_metadata)
+    end
+
+    #
+    # Set the major, minor and patch internal variables based on string passed.
+    #
+    # @param version [String] raw version containing major.minor.patch numbers.
+    def assign_major_minor_and_patch(version)
+      parts = version.split(VALUE_DELIMITER)
+      if parts.length != 3 ||
+         !(integer?(parts[0]) &&
+           integer?(parts[1]) &&
+           integer?(parts[2]))
+        raise "Unable to convert to Semver, incorrect format: #{version}"
+      end
+
+      @major = parts[0].to_i
+      @minor = parts[1].to_i
+      @patch = parts[2].to_i
+      @version = "#{@major}#{VALUE_DELIMITER}#{@minor}#{VALUE_DELIMITER}#{@patch}"
+      @version += parse_pre_release
+      @version += "#{METADATA_DELIMITER}#{@metadata}" unless @metadata.empty?
+    end
+
+    def parse_pre_release
+      return '' if @pre_release.empty?
+
+      pre_parsed = []
+      @pre_release.each do |pre_digit|
+        pre_digit = pre_digit.to_i if integer?(pre_digit)
+        pre_parsed << pre_digit
+      end
+      "#{PRE_RELEASE_DELIMITER}#{pre_parsed.join('.')}"
+    end
+
+    #
+    # Compare 2 variables and return int as follows:
+    #    0: if var1 == var2
+    #    1: if var1 > var2
+    #    -1: if var1 < var2
+    #
+    # @param var1 [type] String/Integer object that accept ==, < or > operators
+    # @param var2 [type] String/Integer object that accept ==, < or > operators
+    #
+    # @returns [Integer] based on comparison
+    def compare_vars(var1, var2)
+      return 0 if var1 == var2
+
+      return 1 if var1 > var2
+
+      -1
+    end
+
+    # Compare the current Semver object's major, minor, patch and is_stable attributes to a given Semver object, return:
+    #      0: if self == passed
+    #      1: if self > passed
+    #      -1: if self < passed
+    #
+    # @param to_compare [trype] splitio.models.grammar.matchers.semver.Semver object
+    #
+    # @returns [Integer] based on comparison
+    def compare_attributes(to_compare)
+      result = compare_vars(@major, to_compare.major)
+      return result if result != 0
+
+      result = compare_vars(@minor, to_compare.minor)
+      return result if result != 0
+
+      result = compare_vars(@patch, to_compare.patch)
+      return result if result != 0
+
+      return -1 if !@is_stable && to_compare.is_stable
+
+      return 1 if @is_stable && !to_compare.is_stable
+
+      0
+    end
+
+    # Compare the current Semver object's pre_release attribute to a given Semver object, return:
+    #      0: if self == passed
+    #      1: if self > passed
+    #      -1: if self < passed
+    #
+    # @param to_compare [trype] splitio.models.grammar.matchers.semver.Semver object
+    #
+    # @returns [Integer] based on comparison
+    def compare_pre_release(to_compare)
+      min_length = get_pre_min_length(to_compare)
+      0.upto(min_length - 1) do |i|
+        next if @pre_release[i] == to_compare.pre_release[i]
+
+        if integer?(@pre_release[i]) && integer?(to_compare.pre_release[i])
+          return compare_vars(@pre_release[i].to_i, to_compare.pre_release[i].to_i)
+
+        end
+
+        return compare_vars(@pre_release[i], to_compare.pre_release[i])
+      end
+      # Compare lengths of pre-release versions
+      compare_vars(@pre_release.length, to_compare.pre_release.length)
+    end
+
+    # Get minimum of current Semver object's pre_release attributes length to a given Semver object
+    #
+    # @param to_compare [trype] splitio.models.grammar.matchers.semver.Semver object
+    #
+    # @returns [Integer]
+    def get_pre_min_length(to_compare)
+      [@pre_release.length, to_compare.pre_release.length].min
+    end
+  end
+end

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

@@ -189,6 +189,47 @@ module SplitIoClient
       )
     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
+
     #
     # @return [object] the negate value for this condition
     def negate

data/lib/splitclient-rb/engine/synchronizer.rb

@@ -48,7 +48,7 @@ module SplitIoClient
           events_sender
           start_telemetry_sync_task
         end
-        
+
         impressions_count_sender
         start_unique_keys_tracker_task
       end
@@ -175,7 +175,7 @@ module SplitIoClient
 
       # Starts thread which loops constantly and sends impressions to the Split API
       def impressions_sender
-        ImpressionsSender.new(@impressions_repository, @config, @impressions_api).call unless @config.impressions_mode == :none
+        ImpressionsSender.new(@impressions_repository, @config, @impressions_api).call
       end
 
       # Starts thread which loops constantly and sends events to the Split API
@@ -185,7 +185,7 @@ module SplitIoClient
 
       # Starts thread which loops constantly and sends impressions count to the Split API
       def impressions_count_sender
-        ImpressionsCountSender.new(@config, @impression_counter, @impressions_sender_adapter).call unless @config.impressions_mode == :debug
+        ImpressionsCountSender.new(@config, @impression_counter, @impressions_sender_adapter).call
       end
 
       def start_telemetry_sync_task
@@ -203,7 +203,7 @@ module SplitIoClient
       def sync_splits_and_segments
         @config.logger.debug('Synchronizing feature flags and segments ...') if @config.debug_enabled
         splits_result = @split_fetcher.fetch_splits
-        
+
         splits_result[:success] && @segment_fetcher.fetch_segments
       end
     end

data/lib/splitclient-rb/helpers/repository_helper.rb

@@ -13,6 +13,13 @@ module SplitIoClient
             next
           end
 
+          unless feature_flag.key?(:impressionsDisabled)
+            feature_flag[:impressionsDisabled] = false
+            if config.debug_enabled
+              config.logger.debug("feature flag (#{feature_flag[:name]}) does not have impressionsDisabled field, setting it to false")
+            end
+          end
+
           config.logger.debug("storing feature flag (#{feature_flag[:name]})") if config.debug_enabled
           to_add.push(feature_flag)
         end

data/lib/splitclient-rb/managers/split_manager.rb

@@ -107,7 +107,8 @@ module SplitIoClient
           change_number: split[:changeNumber],
           configs: split[:configurations] || {},
           sets: split[:sets] || [],
-          default_treatment: split[:defaultTreatment]
+          default_treatment: split[:defaultTreatment],
+          impressions_disabled: split[:impressionsDisabled]
         }
     end
 

data/lib/splitclient-rb/spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Spec
+    class FeatureFlags
+      SPEC_VERSION = "1.1"
+    end
+  end
+end

data/lib/splitclient-rb/split_factory.rb

@@ -230,11 +230,6 @@ module SplitIoClient
     end
 
     def build_unique_keys_tracker
-      if @config.impressions_mode != :none
-        @unique_keys_tracker = Engine::Impressions::NoopUniqueKeysTracker.new
-        return
-      end
-
       bf = Cache::Filter::BloomFilter.new(30_000_000)
       filter_adapter = Cache::Filter::FilterAdapter.new(@config, bf)
       cache = Concurrent::Hash.new
@@ -242,8 +237,7 @@ module SplitIoClient
     end
 
     def build_impressions_observer
-      if (@config.cache_adapter == :redis && @config.impressions_mode != :optimized) ||
-         (@config.cache_adapter == :memory && @config.impressions_mode == :none)
+      if (@config.cache_adapter == :redis && @config.impressions_mode != :optimized)
         @impression_observer = Observers::NoopImpressionObserver.new
       else
         @impression_observer = Observers::ImpressionObserver.new
@@ -251,12 +245,7 @@ module SplitIoClient
     end
 
     def build_impression_counter
-      case @config.impressions_mode
-      when :debug
-        @impression_counter = Engine::Common::NoopImpressionCounter.new
-      else
-        @impression_counter = Engine::Common::ImpressionCounter.new
-      end
+      @impression_counter = Engine::Common::ImpressionCounter.new
     end
 
     def build_impressions_sender_adapter

data/lib/splitclient-rb/split_logger.rb

@@ -11,5 +11,13 @@ module SplitIoClient
       def log_if_transport(message)
         @config.logger.debug(message) if @config.transport_debug_enabled
       end
+
+      def error(message)
+        @config.logger.error(message)
+      end
+
+      def debug(message)
+        @config.logger.debug(message) if @config.debug_enabled
+      end
   end
 end

data/lib/splitclient-rb/sse/notification_manager_keeper.rb

@@ -14,8 +14,8 @@ module SplitIoClient
         @telemetry_runtime_producer = telemetry_runtime_producer
         @status_queue = status_queue
         @publisher_available = Concurrent::AtomicBoolean.new(true)
-        @publishers_pri = Concurrent::AtomicFixnum.new
-        @publishers_sec = Concurrent::AtomicFixnum.new
+        @publishers_pri = Concurrent::AtomicFixnum.new(2)
+        @publishers_sec = Concurrent::AtomicFixnum.new(2)
       end
 
       def handle_incoming_occupancy_event(event)

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '8.3.1'
+  VERSION = '8.5.0'
 end

data/lib/splitclient-rb.rb

@@ -90,6 +90,12 @@ require 'splitclient-rb/engine/matchers/dependency_matcher'
 require 'splitclient-rb/engine/matchers/equal_to_boolean_matcher'
 require 'splitclient-rb/engine/matchers/equal_to_matcher'
 require 'splitclient-rb/engine/matchers/matches_string_matcher'
+require 'splitclient-rb/engine/matchers/semver'
+require 'splitclient-rb/engine/matchers/equal_to_semver_matcher'
+require 'splitclient-rb/engine/matchers/greater_than_or_equal_to_semver_matcher'
+require 'splitclient-rb/engine/matchers/less_than_or_equal_to_semver_matcher'
+require 'splitclient-rb/engine/matchers/between_semver_matcher'
+require 'splitclient-rb/engine/matchers/in_list_semver_matcher'
 require 'splitclient-rb/engine/evaluator/splitter'
 require 'splitclient-rb/engine/impressions/noop_unique_keys_tracker'
 require 'splitclient-rb/engine/impressions/unique_keys_tracker'
@@ -105,6 +111,8 @@ require 'splitclient-rb/engine/sync_manager'
 require 'splitclient-rb/engine/synchronizer'
 require 'splitclient-rb/utilitites'
 
+require 'splitclient-rb/spec.rb'
+
 # SSE
 require 'splitclient-rb/sse/event_source/client'
 require 'splitclient-rb/sse/event_source/event_parser'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 8.3.1
+  version: 8.5.0
 platform: ruby
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-25 00:00:00.000000000 Z
+date: 2025-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: allocation_stats
@@ -489,6 +489,7 @@ files:
 - lib/splitclient-rb/engine/impressions/unique_keys_tracker.rb
 - lib/splitclient-rb/engine/matchers/all_keys_matcher.rb
 - lib/splitclient-rb/engine/matchers/between_matcher.rb
+- lib/splitclient-rb/engine/matchers/between_semver_matcher.rb
 - lib/splitclient-rb/engine/matchers/combiners.rb
 - lib/splitclient-rb/engine/matchers/combining_matcher.rb
 - lib/splitclient-rb/engine/matchers/contains_all_matcher.rb
@@ -498,13 +499,18 @@ files:
 - lib/splitclient-rb/engine/matchers/ends_with_matcher.rb
 - lib/splitclient-rb/engine/matchers/equal_to_boolean_matcher.rb
 - lib/splitclient-rb/engine/matchers/equal_to_matcher.rb
+- lib/splitclient-rb/engine/matchers/equal_to_semver_matcher.rb
 - lib/splitclient-rb/engine/matchers/equal_to_set_matcher.rb
 - lib/splitclient-rb/engine/matchers/greater_than_or_equal_to_matcher.rb
+- lib/splitclient-rb/engine/matchers/greater_than_or_equal_to_semver_matcher.rb
+- lib/splitclient-rb/engine/matchers/in_list_semver_matcher.rb
 - lib/splitclient-rb/engine/matchers/less_than_or_equal_to_matcher.rb
+- lib/splitclient-rb/engine/matchers/less_than_or_equal_to_semver_matcher.rb
 - lib/splitclient-rb/engine/matchers/matcher.rb
 - lib/splitclient-rb/engine/matchers/matches_string_matcher.rb
 - lib/splitclient-rb/engine/matchers/negation_matcher.rb
 - lib/splitclient-rb/engine/matchers/part_of_set_matcher.rb
+- lib/splitclient-rb/engine/matchers/semver.rb
 - lib/splitclient-rb/engine/matchers/set_matcher.rb
 - lib/splitclient-rb/engine/matchers/starts_with_matcher.rb
 - lib/splitclient-rb/engine/matchers/user_defined_segment_matcher.rb
@@ -526,6 +532,7 @@ files:
 - lib/splitclient-rb/helpers/thread_helper.rb
 - lib/splitclient-rb/helpers/util.rb
 - lib/splitclient-rb/managers/split_manager.rb
+- lib/splitclient-rb/spec.rb
 - lib/splitclient-rb/split_config.rb
 - lib/splitclient-rb/split_factory.rb
 - lib/splitclient-rb/split_factory_builder.rb
@@ -587,7 +594,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.0.9
 signing_key:
 specification_version: 4
 summary: Ruby client for split SDK.