kameleoon-client-ruby 3.17.3 → 3.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0d4abc01c7fc06b5cc0b0613dde8a40e004d6d11b358092398498a2c59ee766
-  data.tar.gz: ec89564082cb1b270a9453c63741f1ae505c46dcbbc52fd583927b603a98a26f
+  metadata.gz: dde5f6ebb9e6779b9bf8d4edbdded4e11b82aa642ec046bd2493306e0b2a7ad8
+  data.tar.gz: 5a15f627b2832ec10f001ef7ee061fa31c6dbd618b02ec55ff9d1d66ee17d5a8
 SHA512:
-  metadata.gz: 7b1e31f65a0c314810b5e020570d52cee18bc1a6cbe41bbdc564114dd9136257e78c06fd55b07a04106d42bfa996a3f979438647105df7d18d299cdb282dbc1d
-  data.tar.gz: df793d553ff36d2e98e118fe5c2bc846417900958d81262bb9ec7fe0dc233a86420bb9c93b793b91beec097a073dba81907dee2290fa1b7b82ddf03dd297a59f
+  metadata.gz: 91d3f34ab6855ed62d571fa5d40b85a04504926f2d38650c9b62f052bd9f0b79b0ce95ece6636fa37ecc5062020f2361bc5e0e8af80383b0d2b377dffd5919e7
+  data.tar.gz: c2e5efd80b73d5f8ce9c48a6f069aadda0fc7d1a6bc390a2d98af4a8a69b36928bac0188c77406bd793d8db6c4701df24838c67efc89b98d4d0e6b7e425b9c68

data/lib/kameleoon/configuration/data_file.rb

@@ -13,12 +13,13 @@ module Kameleoon
     class DataFile
       attr_reader :last_modified, :settings, :segments, :audience_tracking_segments, :feature_flags, :me_groups,
                   :has_any_targeted_delivery_rule, :feature_flag_by_id, :rule_info_by_exp_id, :variation_by_id,
-                  :custom_data_info, :experiment_ids_with_js_css_variable, :holdout
+                  :custom_data_info, :experiment_ids_with_js_css_variable, :holdout, :date_modified
 
       def to_s
         'DataFile{' \
           "environment:#{@environment}," \
           "last_modified:#{@last_modified}," \
+          "date_modified:#{@date_modified}," \
           "feature_flags:#{@feature_flags.size}," \
           "settings:#{@settings}" \
           '}'
@@ -46,13 +47,15 @@ module Kameleoon
       def get_feature_flag(feature_key)
         ff = @feature_flags[feature_key]
         raise Exception::FeatureNotFound, feature_key if ff.nil?
+        ff
+      end
 
-        unless ff.environment_enabled
+      def ensure_environment_enabled(feature_flag)
+        unless feature_flag.environment_enabled
           env = @environment.nil? ? 'default' : "'#{@environment}'"
-          msg = "Feature '#{feature_key}' is disabled for #{env} environment'"
+          msg = "Feature '#{feature_flag.feature_key}' is disabled for #{env} environment'"
           raise Exception::FeatureEnvironmentDisabled, msg
         end
-        ff
       end
 
       def experiment_js_css_variable?(experiment_id)
@@ -63,6 +66,7 @@ module Kameleoon
 
       def init_default
         Logging::KameleoonLogger.debug('CALL: DataFile.init_default')
+        @date_modified = 0
         @settings = Settings.new
         @feature_flags = {}
         @me_groups = {}
@@ -73,6 +77,7 @@ module Kameleoon
 
       def init(configuration)
         Logging::KameleoonLogger.debug('CALL: DataFile.init(configuration: %s)', configuration)
+        @date_modified = configuration['dateModified'] || 0
         @settings = Settings.new(configuration['configuration'])
         @segments, @audience_tracking_segments = parse_segments(configuration)
         @custom_data_info = CustomDataInfo.new(configuration['customData'])

data/lib/kameleoon/configuration/variable.rb

@@ -16,6 +16,18 @@ module Kameleoon
         @type = hash['type']
         @value = hash['value']
       end
+
+      def get_value
+        case @type
+        when 'BOOLEAN', 'STRING', 'NUMBER', 'JS', 'CSS'
+          @value
+        when 'JSON'
+          JSON.parse(@value)
+        else
+          Logging::KameleoonLogger.error("Unknown type '#{@type}' for feature variable")
+          @value
+        end
+      end
     end
   end
 end

data/lib/kameleoon/configuration/variation.rb

@@ -19,7 +19,7 @@ module Kameleoon
       end
 
       def initialize(hash)
-        @key = hash['key']
+        @key = hash['key'] || ''
         @variables = Variable.create_from_array(hash['variables'])
         @name = hash['name'] || ''
       end

data/lib/kameleoon/data/application_version.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'data'
+
+module Kameleoon
+  # ApplicationVersion contains information about the application version on the visitor's device.
+  # It is used for targeting by application version.
+  class ApplicationVersion < Data
+    attr_reader :version
+
+    # @param [String] version Application version (semantic versioning: major, major.minor, or major.minor.patch)
+    def initialize(version)
+      super(DataType::APPLICATION_VERSION)
+      @version = version
+    end
+
+    def to_s
+      "ApplicationVersion{version:#{@version}}"
+    end
+  end
+end

data/lib/kameleoon/data/data.rb

@@ -20,6 +20,7 @@ module Kameleoon
     GEOLOCATION = 'GEOLOCATION'
     VISITOR_VISITS = 'VISITOR_VISITS'
     TARGETED_SEGMENT = 'TARGETED_SEGMENT'
+    APPLICATION_VERSION = 'APPLICATION_VERSION'
   end
 
   module DataState

data/lib/kameleoon/data/manager/visitor.rb

@@ -2,6 +2,7 @@
 
 require 'concurrent'
 require 'time'
+require 'kameleoon/data/application_version'
 require 'kameleoon/data/browser'
 require 'kameleoon/data/cbscores'
 require 'kameleoon/data/conversion'
@@ -103,6 +104,13 @@ module Kameleoon
         operating_system
       end
 
+      def application_version
+        application_version = @data.application_version
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.application_version -> (application_version: %s)',
+                                       application_version)
+        application_version
+      end
+
       def cookie
         cookie = @data.cookie
         Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.cookie -> (cookie: %s)', cookie)
@@ -275,6 +283,8 @@ module Kameleoon
               @data.cookie = data
             when OperatingSystem
               @data.set_operating_system(data, overwrite)
+            when ApplicationVersion
+              @data.set_application_version(data, overwrite)
             when Geolocation
               @data.set_geolocation(data, overwrite)
             when KcsHeat
@@ -305,7 +315,8 @@ module Kameleoon
     end
 
     class VisitorData
-      attr_reader :time_started, :mutex, :device, :browser, :geolocation, :operating_system, :visitor_visits
+      attr_reader :time_started, :mutex, :device, :browser, :geolocation, :operating_system, :visitor_visits,
+                  :application_version
       attr_accessor :last_activity_time, :legal_consent, :user_agent, :cookie, :kcs_heat, :cbscores,
                     :mapping_identifier, :forced_variations, :simulated_variations
 
@@ -462,6 +473,10 @@ module Kameleoon
         @operating_system = operating_system if overwrite || @operating_system.nil?
       end
 
+      def set_application_version(application_version, overwrite)
+        @application_version = application_version if overwrite || @application_version.nil?
+      end
+
       def set_cbscores(cbs, overwrite)
         @cbscores = cbs if overwrite || @cbscores.nil?
       end

data/lib/kameleoon/data/manager/visitor_manager.rb

@@ -64,6 +64,16 @@ module Kameleoon
         visitor
       end
 
+      def peek_visitor(visitor_code)
+        Logging::KameleoonLogger.debug("CALL: VisitorManager.peek_visitor(visitor_code: '%s')", visitor_code)
+
+        visitor = @visitors[visitor_code]
+
+        Logging::KameleoonLogger.debug("RETURN: VisitorManager.peek_visitor(visitor_code: '%s') -> (visitor: %s)",
+                              visitor_code, visitor)
+        visitor
+      end
+
       def enumerate(&blk)
         @visitors.each_pair { |vc, v| blk.call(vc, v) }
       end
@@ -72,10 +82,10 @@ module Kameleoon
         @visitors.size
       end
 
-      def add_data(visitor_code, *args, overwrite: true)
+      def add_data(visitor_code, *args, overwrite: true, track: true)
         Logging::KameleoonLogger.debug(
-          "CALL: VisitorManager.add_data(visitor_code: '%s', args: %s, overwrite: %s)",
-          visitor_code, args, overwrite
+          "CALL: VisitorManager.add_data(visitor_code: '%s', args: %s, overwrite: %s, track: %s)",
+          visitor_code, args, overwrite, track
         )
         visitor = get_or_create_visitor(visitor_code)
         cdi = @data_manager.data_file.custom_data_info
@@ -87,12 +97,13 @@ module Kameleoon
           when Conversion
             data = process_conversion(data, cdi)
           end
+          data.mark_as_sent if !track && data.respond_to?(:mark_as_sent)
           args[i] = data
         end
         visitor.add_data(*args, overwrite: overwrite)
         Logging::KameleoonLogger.debug(
-          "RETURN: VisitorManager.add_data(visitor_code: '%s', args: %s, overwrite: %s) -> (visitor)",
-          visitor_code, args, overwrite
+          "RETURN: VisitorManager.add_data(visitor_code: '%s', args: %s, overwrite: %s, track: %s) -> (visitor)",
+          visitor_code, args, overwrite, track
         )
         visitor
       end

data/lib/kameleoon/kameleoon_client.rb

@@ -162,17 +162,18 @@ module Kameleoon
     #
     # @param [String] visitor_code Visitor code
     # @param [...Data] data Data to associate with the visitor code
+    # @param [Bool] track A boolean indicating whether the data should be tracked (sent to server). Default is true.
     #
     # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars
     #
-    def add_data(visitor_code, *args)
-      Logging::KameleoonLogger.info("CALL: KameleoonClient.add_data(visitor_code: '%s', args: %s)",
-                                    visitor_code, args)
+    def add_data(visitor_code, *args, track: true)
+      Logging::KameleoonLogger.info("CALL: KameleoonClient.add_data(visitor_code: '%s', args: %s, track: %s)",
+                                    visitor_code, args, track)
       Utils::VisitorCode.validate(visitor_code)
-      @visitor_manager.add_data(visitor_code, *args)
+      @visitor_manager.add_data(visitor_code, *args, track: track)
       Logging::KameleoonLogger.info(
-        "RETURN: KameleoonClient.add_data(visitor_code: '%s', args: %s)",
-        visitor_code, args
+        "RETURN: KameleoonClient.add_data(visitor_code: '%s', args: %s, track: %s)",
+        visitor_code, args, track
       )
     end
 
@@ -368,8 +369,6 @@ module Kameleoon
       Utils::VisitorCode.validate(visitor_code)
       variations = {}
       @data_manager.data_file.feature_flags.each_value do |feature_flag|
-        next unless feature_flag.environment_enabled
-
         begin
           variation_key, eval_exp = get_variation_info(visitor_code, feature_flag, track)
         rescue Exception::FeatureEnvironmentDisabled
@@ -467,7 +466,7 @@ module Kameleoon
         raise Exception::FeatureVariableNotFound.new(variable_name),
               "Feature variable #{variable_name} not found"
       end
-      value = _parse_feature_variable(variable)
+      value = variable.get_value
       Logging::KameleoonLogger.info(
         "RETURN: KameleoonClient.get_feature_variable(visitor_code: '%s', feature_key: '%s', variable_name: '%s', " \
           'is_unique_identifier: %s) -> (variable: %s)',
@@ -502,12 +501,13 @@ module Kameleoon
       )
       feature_flag = @data_manager.data_file.get_feature_flag(feature_key)
       variation = feature_flag.get_variation_by_key(variation_key)
+      @data_manager.data_file.ensure_environment_enabled(feature_flag)
       if variation.nil?
         raise Exception::FeatureVariationNotFound.new(variation_key),
               "Variation key #{variation_key} not found"
       end
       variables = {}
-      variation.variables.each { |var| variables[var.key] = _parse_feature_variable(var) }
+      variation.variables.each { |var| variables[var.key] = var.get_value }
       Logging::KameleoonLogger.info(
         "RETURN: KameleoonClient.get_feature_variation_variables(feature_key: '%s', variation_key: '%s') " \
           '-> (variables: %s)', feature_key, variation_key, variables
@@ -606,12 +606,16 @@ module Kameleoon
       )
       warehouse_audience
     end
-
     ##
-    # Returns a list of all feature flag keys
+    # Returns a list of all feature flag keys.
     #
     # @return [Array] array of all feature flag keys
+    #
+    # DEPRECATED. Please use `get_data_file` instead.
     def get_feature_list # rubocop:disable Naming/AccessorMethodName
+      Logging::KameleoonLogger.info(
+        '[DEPRECATION] `get_feature_list` is deprecated. Please use `get_data_file` instead.'
+      )
       Logging::KameleoonLogger.info('CALL: KameleoonClient.get_feature_list')
       features = @data_manager.data_file.feature_flags.keys
       Logging::KameleoonLogger.info('RETURN: KameleoonClient.get_feature_list -> (features: %s)', features)
@@ -637,8 +641,6 @@ module Kameleoon
       visitor = @visitor_manager.get_visitor(visitor_code)
       list_keys = []
       @data_manager.data_file.feature_flags.each do |feature_key, feature_flag|
-        next unless feature_flag.environment_enabled
-
         begin
           eval_exp = evaluate(visitor, visitor_code, feature_flag, false, false)
         rescue Exception::FeatureEnvironmentDisabled
@@ -676,8 +678,6 @@ module Kameleoon
       map_active_features = {}
 
       @data_manager.data_file.feature_flags.each_value do |feature_flag|
-        next unless feature_flag.environment_enabled
-
         begin
           eval_exp = evaluate(visitor, visitor_code, feature_flag, false, false)
         rescue Exception::FeatureEnvironmentDisabled
@@ -802,41 +802,7 @@ module Kameleoon
     # @return [Kameleoon::Types::DataFile] The current DataFile instance.
     def get_data_file
       Logging::KameleoonLogger.info('CALL: KameleoonClient.get_data_file')
-
-      feature_flags_map = @data_manager.data_file.feature_flags.transform_values do |source_feature_flag|
-        # Collect variations
-        variations_map = source_feature_flag.variations.each_with_object({}) do |variation, variations_map|
-          variables_map = variation.variables.each_with_object({}) do |var, variables_map|
-            variables_map[var.key] = Types::Variable.new(var.key, var.type, _parse_feature_variable(var))
-          end
-          variations_map[variation.key] = Types::Variation.new(variation.key, nil, nil, variables_map, variation.name)
-        end
-
-        # Collect rules
-        rules = source_feature_flag.rules.map do |rule|
-          rule_variations = rule.experiment.variations_by_exposition.each_with_object({}) do |var_by_exp, rule_variations|
-            base_variation = variations_map[var_by_exp.variation_key]
-            next unless base_variation
-            rule_variations[base_variation.key] = Types::Variation.new(
-              base_variation.key,
-              var_by_exp.variation_id,
-              rule.experiment.id,
-              base_variation.variables,
-              base_variation.name
-            )
-          end
-          Types::Rule.new(rule_variations)
-        end
-
-        Types::FeatureFlag.new(
-          variations_map,
-          source_feature_flag.environment_enabled,
-          rules,
-          source_feature_flag.default_variation_key
-        )
-      end
-
-      data_file = Types::DataFile.new(feature_flags_map)
+      data_file = @data_manager.external_data_file
       Logging::KameleoonLogger.info('RETURN: KameleoonClient.get_data_file -> (data_file: %s)', data_file)
       data_file
     end
@@ -1014,6 +980,11 @@ module Kameleoon
       )
       eval_exp = nil
       forced_variation = visitor&.get_forced_feature_variation(feature_flag.feature_key)
+
+      unless forced_variation&.simulated
+        @data_manager.data_file.ensure_environment_enabled(feature_flag)
+      end
+
       if forced_variation
         eval_exp = EvaluatedExperiment.from_forced_variation(forced_variation)
       elsif visitor_not_in_holdout?(visitor, visitor_code, track, save, feature_flag.bucketing_custom_data_index) && \
@@ -1275,21 +1246,10 @@ module Kameleoon
       Logging::KameleoonLogger.debug(
         'CALL: KameleoonClient.create_external_variation(variation: %s, eval_exp: %s)', variation, eval_exp
       )
-      ext_variables = {}
-      variation&.variables&.each do |variable|
-        ext_variables[variable.key] = Types::Variable.new(
-          variable.key,
-          variable.type,
-          _parse_feature_variable(variable)
-        )
-      end
-      ext_variables.freeze
-      ext_variation = Types::Variation.new(
-        variation&.key || '',
+      ext_variation = Types::Variation._build_from_internal(
+        variation,
         eval_exp&.var_by_exp&.variation_id,
-        eval_exp&.experiment&.id,
-        ext_variables,
-        variation&.name || ''
+        eval_exp&.experiment&.id
       )
       Logging::KameleoonLogger.debug(
         'RETURN: KameleoonClient.create_external_variation(variation: %s, eval_exp: %s) -> (ext_variation: %s)',
@@ -1300,18 +1260,6 @@ module Kameleoon
 
     ##
     # helper method for fetching values from a Variable
-    def _parse_feature_variable(variable)
-      case variable.type
-      when 'BOOLEAN', 'STRING', 'NUMBER', 'JS', 'CSS'
-        variable.value
-      when 'JSON'
-        JSON.parse(variable.value)
-      else
-        Logging::KameleoonLogger.error("Unknown type '#{variable.type}' for feature variable")
-        variable.value
-      end
-    end
-
     def set_unique_identifier(visitor_code, is_unique_identifier)
       Logging::KameleoonLogger.info(
         "The 'isUniqueIdentifier' parameter is deprecated. Please, add 'UniqueIdentifier' to a visitor instead."

data/lib/kameleoon/kameleoon_client_config.rb

@@ -9,8 +9,8 @@ module Kameleoon
     DEFAULT_SESSION_DURATION_MINUTES = 30
     DEFAULT_TIMEOUT_MILLISECONDS = 10_000
     DEFAULT_TRACKING_INTERVAL_MILLISECONDS = 1000
-    MIN_TRACKING_INTERVAL_MILLISECONDS = 300
-    MAX_TRACKING_INTERVAL_MILLISECONDS = 1000
+    MIN_TRACKING_INTERVAL_MILLISECONDS = 1000
+    MAX_TRACKING_INTERVAL_MILLISECONDS = 5000
 
     attr_reader :client_id, :client_secret, :refresh_interval_second, :session_duration_second,
                 :default_timeout_millisecond, :tracking_interval_second, :environment, :top_level_domain,

data/lib/kameleoon/managers/data/data_manager.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'kameleoon/types/data_file'
+
 module Kameleoon
   module Managers
     module Data
@@ -13,7 +15,11 @@ module Kameleoon
         end
 
         def data_file=(value)
-          @container = Container.new(value)
+          @container = Container.new(value, create_external_data_file(value))
+        end
+
+        def external_data_file
+          @container.external_data_file
         end
 
         def visitor_code_managed?
@@ -22,14 +28,22 @@ module Kameleoon
 
         class Container
           attr_reader :data_file, :visitor_code_managed
+          attr_reader :external_data_file
 
-          def initialize(data_file)
+          def initialize(data_file, external_data_file)
             @data_file = data_file
+            @external_data_file = external_data_file
             # Regarding GDPR policy we should set visitorCode if legal consent isn't required or we have at
             # least one Targeted Delivery rule in datafile
             @visitor_code_managed = data_file.settings.is_consent_required && !data_file.has_any_targeted_delivery_rule
           end
         end
+
+        private
+
+        def create_external_data_file(source_data_file)
+          Types::DataFile._build_from_internal(source_data_file)
+        end
       end
     end
   end

data/lib/kameleoon/managers/tracking/tracking_builder.rb

@@ -32,7 +32,7 @@ module Kameleoon
 
           @visitor_codes.each do |visitor_code|
             if @total_size <= @request_size_limit
-              visitor = @visitor_manager.get_visitor(visitor_code)
+              visitor = @visitor_manager.peek_visitor(visitor_code)
               is_consent_given = consent_given?(visitor)
               data = collect_tracking_data(visitor_code, visitor, is_consent_given)
               if !data.empty?

data/lib/kameleoon/network/access_token_source.rb

@@ -5,6 +5,7 @@ require 'net/http'
 require 'time'
 require 'kameleoon/utils'
 require 'kameleoon/logging/kameleoon_logger'
+require 'base64'
 
 module Kameleoon
   module Network
@@ -13,6 +14,7 @@ module Kameleoon
       TOKEN_OBSOLESCENCE_GAP = 1800 # in seconds
       JWT_ACCESS_TOKEN_FIELD = 'access_token'
       JWT_EXPIRES_IN_FIELD = 'expires_in'
+      BASIC_AUTHORIZATION_PREFIX = 'Basic '
 
       def initialize(network_manager, client_id, client_secret)
         Logging::KameleoonLogger.debug(lambda {
@@ -23,12 +25,18 @@ module Kameleoon
         @client_id = client_id
         @client_secret = client_secret
         @fetching = false
+        @basic_auth_token = AccessTokenSource.construct_basic_token(client_id, client_secret)
         Logging::KameleoonLogger.debug(lambda {
           format("RETURN: AccessTokenSource.new(network_manager, client_id: '%s', client_secret: '%s')",
                  Utils::Strval.secret(client_id), Utils::Strval.secret(client_secret))
         })
       end
 
+      def self.construct_basic_token(client_id, client_secret)
+        basic_token_content = "#{client_id}:#{client_secret}"
+        "#{BASIC_AUTHORIZATION_PREFIX}#{Base64.strict_encode64(basic_token_content)}"
+      end
+
       def get_token(timeout = nil)
         Logging::KameleoonLogger.debug('CALL: AccessTokenSource.getToken(timeout: %s)', timeout)
         now = Time.new.to_i
@@ -70,7 +78,7 @@ module Kameleoon
 
       def fetch_token(timeout = nil)
         Logging::KameleoonLogger.debug('CALL: AccessTokenSource.fetch_token(timeout: %s)', timeout)
-        response_content = @network_manager.fetch_access_jwtoken(@client_id, @client_secret, timeout)
+        response_content = @network_manager.fetch_access_jwtoken(@basic_auth_token, timeout)
         unless response_content
           Logging::KameleoonLogger.error('Failed to fetch access JWT')
           return nil

data/lib/kameleoon/network/net_provider.rb

@@ -17,7 +17,10 @@ module Kameleoon
       def collect_headers(request)
         headers = { 'Content-Type' => request.content_type }
         headers.merge!(request.extra_headers) unless request.extra_headers.nil?
-        headers['Authorization'] = "Bearer #{request.access_token}" unless request.access_token.nil?
+        unless request.access_token.nil? || request.access_token.empty?
+          token_prefix = request.access_token.start_with?('Basic') ? '' : 'Bearer '
+          headers['Authorization'] = "#{token_prefix}#{request.access_token}"
+        end
         headers
       end
 

data/lib/kameleoon/network/network_manager.rb

@@ -70,16 +70,15 @@ module Kameleoon
         unwrap_response(*make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY))
       end
 
-      def fetch_access_jwtoken(client_id, client_secret, timeout = nil)
+      def fetch_access_jwtoken(basic_auth_token, timeout = nil)
         url = @url_provider.make_access_token_url
         timeout = ensure_timeout(timeout)
         data_map = {
           grant_type: ACCESS_TOKEN_GRANT_TYPE,
-          client_id: client_id,
-          client_secret: client_secret
         }
         data = UriHelper.encode_query(data_map).encode('UTF-8')
         request = Request.new(Method::POST, url, ContentType::FORM, timeout, data: data)
+        request.authorize(basic_auth_token)
         unwrap_response(*make_call(request, false))
       end
 

data/lib/kameleoon/network/request.rb

@@ -11,12 +11,15 @@ module Kameleoon
         body = 'null'
         unless @data.nil?
           if @data.is_a?(String)
-            body = @data.start_with?('grant_type=client_credentials') ? '****' : @data
-          else
             body = @data
           end
         end
-        "Request{method:'#{@method}',url:'#{@url}',headers:#{@extra_headers},body:'#{body}'}"
+
+        headers = ''
+        headers += 'Authorization: ***' unless access_token.nil?
+        headers += @extra_headers.to_s unless @extra_headers.nil?
+
+        "Request{method:'#{@method}',url:'#{@url}',headers:#{headers},body:'#{body}'}"
       end
 
       def initialize(method, url, content_type, timeout, extra_headers: nil, data: nil)

data/lib/kameleoon/network/url_provider.rb

@@ -22,7 +22,7 @@ module Kameleoon
       CONFIGURATION_API_URL_FORMAT = 'https://%s/v3/%s'
       DATA_API_URL_FORMAT = 'https://%s%s?%s'
       RT_CONFIGURATION_URL_FORMAT = 'https://%s:8110/sse?%s'
-      ACCESS_TOKEN_URL_FORMAT = 'https://%s/oauth/token'
+      ACCESS_TOKEN_URL_FORMAT = 'https://%s/oauth/token?%s'
 
       TEST_DATA_API_DOMAIN = 'data.kameleoon.net'
       TEST_AUTOMATION_API_DOMAIN = 'api.kameleoon.net'
@@ -39,6 +39,15 @@ module Kameleoon
         @configuration_domain = DEFAULT_CONFIGURATION_DOMAIN
         @access_token_domain = DEFAULT_ACCESS_TOKEN_DOMAIN
         @is_custom_domain = false
+
+        url_params = {
+          sdkName: SDK_NAME,
+          sdkVersion: SDK_VERSION,
+          siteCode: @site_code
+        }
+        @access_token_url_params = UriHelper.encode_query(url_params)
+        url_params[:bodyUa] = true
+        @tracking_url_params = UriHelper.encode_query(url_params)
         update_domains(network_domain)
       end
 
@@ -60,7 +69,7 @@ module Kameleoon
           siteCode: @site_code,
           bodyUa: true
         }
-        format(DATA_API_URL_FORMAT, @data_api_domain, TRACKING_PATH, UriHelper.encode_query(params))
+        format(DATA_API_URL_FORMAT, @data_api_domain, TRACKING_PATH, @tracking_url_params)
       end
 
       def make_visitor_data_get_url(visitor_code, filter, is_unique_identifier = false)
@@ -104,11 +113,20 @@ module Kameleoon
       end
 
       def make_access_token_url
-        format(ACCESS_TOKEN_URL_FORMAT, @access_token_domain)
+        format(ACCESS_TOKEN_URL_FORMAT, @access_token_domain, @access_token_url_params)
       end
 
       private
 
+      def make_post_query_base(site_code)
+        data_map = {
+          "sdkName": Kameleoon::SDK_NAME,
+          "sdkVersion": Kameleoon::SDK_VERSION,
+          "siteCode": site_code
+        }
+        data = UriHelper.encode_query(data_map).encode('UTF-8')
+      end
+
       def update_domains(network_domain)
         return if network_domain.nil? || network_domain.empty?
 

data/lib/kameleoon/sem_version.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'kameleoon/logging/kameleoon_logger'
+
+module Kameleoon
+  # SemVersion is a utility class for semantic version comparison
+  class SemVersion
+    include Comparable
+
+    attr_reader :major, :minor, :patch
+
+    def initialize(major = 0, minor = 0, patch = 0)
+      @major = major
+      @minor = minor
+      @patch = patch
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(SemVersion)
+
+      c = @major <=> other.major
+      return c unless c.zero?
+
+      c = @minor <=> other.minor
+      return c unless c.zero?
+
+      @patch <=> other.patch
+    end
+
+    def to_f
+      "#{@major}.#{@minor}".to_f
+    end
+
+    def self.from_string(version_string)
+      return nil unless version_string.is_a?(String)
+
+      versions = [0, 0, 0]
+      version_parts = version_string.split('.')
+      return nil unless version_parts.length >= 1
+
+      version_parts.each_with_index do |part, i|
+        break if i >= 3
+
+        begin
+          versions[i] = Integer(part)
+        rescue ArgumentError
+          Logging::KameleoonLogger.error("Invalid version component, index: %s, value: '%s'", i, part)
+          return nil
+        end
+      end
+
+      SemVersion.new(versions[0], versions[1], versions[2])
+    end
+  end
+end

data/lib/kameleoon/targeting/condition.rb

@@ -31,6 +31,7 @@ module Kameleoon
       SAME_DAY_VISITS = 'SAME_DAY_VISITS'
       NEW_VISITORS = 'NEW_VISITORS'
       HEAT_SLICE = 'HEAT_SLICE'
+      APPLICATION_VERSION = 'APPLICATION_VERSION'
     end
 
     module Operator

data/lib/kameleoon/targeting/condition_factory.rb

@@ -1,4 +1,5 @@
 require_relative 'conditions/custom_datum'
+require_relative 'conditions/version_condition'
 require_relative 'conditions/target_experiment_condition'
 require_relative 'conditions/target_feature_flag_condition'
 require_relative 'conditions/target_personalization_condition'
@@ -77,6 +78,8 @@ module Kameleoon
           TimeElapsedSinceVisitCondition.new(condition_json)
         when ConditionType::HEAT_SLICE
           KcsHeatRangeCondition.new(condition_json)
+        when ConditionType::APPLICATION_VERSION
+          VersionCondition.new(condition_json)
         else
           Logging::KameleoonLogger.info("Unexpected TargetingConditionType: '%s'", cond_type)
           UnknownCondition.new(condition_json)

data/lib/kameleoon/targeting/conditions/browser_condition.rb

@@ -2,7 +2,7 @@
 
 require 'kameleoon/data/browser'
 require 'kameleoon/logging/kameleoon_logger'
-require 'kameleoon/sdk_version'
+require 'kameleoon/sem_version'
 
 module Kameleoon
   # @api private
@@ -33,7 +33,7 @@ module Kameleoon
 
         return true if @version.nil?
 
-        version_number = SdkVersion.get_float_version(@version)
+        version_number = SemVersion.from_string(@version)&.to_f || Float::NAN
         return false if version_number.nan?
 
         case @version_match_type

data/lib/kameleoon/targeting/conditions/sdk_language_condition.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
-require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/version'
+require_relative 'version_condition'
 
 module Kameleoon
   # @api private
@@ -18,12 +17,10 @@ module Kameleoon
     end
 
     # SdkLanguageCondition is a condition for checking targeting sdk type and version
-    class SdkLanguageCondition < Condition
+    class SdkLanguageCondition < VersionCondition
       def initialize(json_condition)
         super(json_condition)
         @sdk_language = json_condition['sdkLanguage']
-        @version = json_condition['version']
-        @operator = json_condition['versionMatchType']
       end
 
       def check(data)
@@ -33,34 +30,9 @@ module Kameleoon
       private
 
       def check_targeting(sdk_info)
-        return false if @sdk_language != sdk_info.language
-
-        return true if @version.nil?
-
-        version_components_condition = SdkVersion.get_version_components(@version)
-        version_components_sdk_info = SdkVersion.get_version_components(sdk_info.version)
-
-        return false if version_components_condition.nil? || version_components_sdk_info.nil?
-
-        major_condition, minor_condition, patch_condition = version_components_condition
-        major_sdk, minor_sdk, patch_sdk = version_components_sdk_info
-
-        case @operator
-        when Operator::EQUAL
-          major_sdk == major_condition && minor_sdk == minor_condition && patch_sdk == patch_condition
-        when Operator::GREATER
-          major_sdk > major_condition ||
-            (major_sdk == major_condition && minor_sdk > minor_condition) ||
-            (major_sdk == major_condition && minor_sdk == minor_condition && patch_sdk > patch_condition)
-        when Operator::LOWER
-          major_sdk < major_condition ||
-            (major_sdk == major_condition && minor_sdk < minor_condition) ||
-            (major_sdk == major_condition && minor_sdk == minor_condition && patch_sdk < patch_condition)
-        else
-          Logging::KameleoonLogger.error("Unexpected comparing operation for 'SdkLanguage' condition: '#{@operator}'")
-          false
-        end
+        @sdk_language == sdk_info.language &&
+          (@version.nil? || compare_with_version(sdk_info.version))
       end
     end
   end
-end
+end

data/lib/kameleoon/targeting/conditions/unknown_condition.rb

@@ -8,6 +8,7 @@ module Kameleoon
     # UnknownCondition represents not defined condition, always returns that visitor is targeted (true)
     class UnknownCondition < Condition
       def check(_data)
+        Logging::KameleoonLogger.warning('Condition of unknown type \'%s\' evaluated as true', type)
         true
       end
     end

data/lib/kameleoon/targeting/conditions/version_condition.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'kameleoon/logging/kameleoon_logger'
+require 'kameleoon/sem_version'
+require 'kameleoon/targeting/condition'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # VersionCondition is a base class for conditions that compare versions.
+    # Subclasses should implement `check` method and call `compare_with_version` for version comparison.
+    class VersionCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @version = json_condition['version']
+        @version_match_type = json_condition['versionMatchType']
+        @cached_version_condition = nil
+      end
+
+      def check(data)
+        data.is_a?(String) && compare_with_version(data)
+      end
+
+      protected
+
+      def compare_with_version(version)
+        @cached_version_condition ||= SemVersion.from_string(@version)
+        version_compare = SemVersion.from_string(version)
+
+        if @cached_version_condition.nil? || version_compare.nil?
+          Logging::KameleoonLogger.error(
+            "VersionCondition has unexpected values to compare, condition version: '%s', provided version: '%s'",
+            @version, version
+          )
+          return false
+        end
+
+        case @version_match_type
+        when Operator::EQUAL
+          version_compare == @cached_version_condition
+        when Operator::GREATER
+          version_compare > @cached_version_condition
+        when Operator::LOWER
+          version_compare < @cached_version_condition
+        else
+          Logging::KameleoonLogger.error(
+            "Unexpected comparing operation for '%s' condition: '%s'",
+            type, @version_match_type
+          )
+          false
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/targeting/targeting_manager.rb

@@ -92,6 +92,8 @@ module Kameleoon
           condition_data = VisitNumberTodayCondition::TargetingData.new(visitor&.time_started, visitor&.visitor_visits)
         when ConditionType::HEAT_SLICE
           condition_data = visitor&.kcs_heat
+        when ConditionType::APPLICATION_VERSION
+          condition_data = visitor&.application_version&.version
         end
         Logging::KameleoonLogger.debug(
           "RETURN: TargetingManager.get_condition_data(type: %s, visitor, visitor_code: '%s', campaign_id: %s) -> " \

data/lib/kameleoon/types/data_file.rb

@@ -1,18 +1,29 @@
 # frozen_string_literal: true
 
+require 'kameleoon/types/feature_flag'
+
 module Kameleoon
   module Types
     # DataFile
     class DataFile
-      attr_reader :feature_flags
+      attr_reader :feature_flags, :date_modified
 
       # @api private
-      def initialize(feature_flags)
+      def initialize(feature_flags, date_modified)
         @feature_flags = feature_flags
+        @date_modified = date_modified
+      end
+
+      # @api private
+      def self._build_from_internal(source_data_file)
+        feature_flags = (source_data_file.feature_flags || {}).transform_values do |feature_flag|
+          FeatureFlag._build_from_internal(feature_flag)
+        end
+        DataFile.new(feature_flags, source_data_file.date_modified)
       end
 
       def to_s
-        "DataFile{feature_flags:#{@feature_flags}}"
+        "DataFile{feature_flags:#{@feature_flags},date_modified:#{@date_modified}}"
       end
     end
   end

data/lib/kameleoon/types/feature_flag.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'kameleoon/types/rule'
+require 'kameleoon/types/variation'
+
 module Kameleoon
   module Types
     # FeatureFlag
@@ -18,6 +21,25 @@ module Kameleoon
         @variations[@default_variation_key]
       end
 
+      # @api private
+      def self._build_from_internal(source_feature_flag)
+        variations = (source_feature_flag.variations || []).each_with_object({}) do |variation, result|
+          ext_variation = Variation._build_from_internal(variation)
+          result[ext_variation.key] = ext_variation
+        end
+
+        rules = (source_feature_flag.rules || []).map do |rule|
+          Rule._build_from_internal(rule, variations)
+        end
+
+        FeatureFlag.new(
+          variations,
+          source_feature_flag.environment_enabled,
+          rules,
+          source_feature_flag.default_variation_key
+        )
+      end
+
       def to_s
         "FeatureFlag{variations:#{@variations},environment_enabled:#{@environment_enabled},rules:#{@rules},default_variation_key:#{@default_variation_key}}"
       end

data/lib/kameleoon/types/rule.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'kameleoon/types/variation'
+
 module Kameleoon
   module Types
     # Rule
@@ -11,6 +13,25 @@ module Kameleoon
         @variations = variations
       end
 
+      # @api private
+      def self._build_from_internal(internal_rule, variations)
+        rule_variations = {}
+        vars_by_exposition = internal_rule.experiment&.variations_by_exposition || []
+        vars_by_exposition.each do |var_by_exp|
+          base_variation = variations[var_by_exp.variation_key]
+          next if base_variation.nil?
+
+          rule_variations[base_variation.key] = Variation.new(
+            base_variation.key,
+            var_by_exp.variation_id,
+            internal_rule.experiment&.id,
+            base_variation.variables,
+            base_variation.name
+          )
+        end
+        Rule.new(rule_variations)
+      end
+
       def to_s
         "Rule{variations:#{@variations}}"
       end

data/lib/kameleoon/types/variable.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'json'
+require 'kameleoon/logging/kameleoon_logger'
+
 module Kameleoon
   module Types
     # Variable
@@ -16,6 +19,11 @@ module Kameleoon
         @type = type
         @value = value
       end
+
+      # @api private
+      def self._build_from_internal(source_variable)
+        Variable.new(source_variable.key, source_variable.type, source_variable.get_value)
+      end
     end
   end
 end

data/lib/kameleoon/types/variation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'kameleoon/configuration/variation'
+require 'kameleoon/types/variable'
 
 module Kameleoon
   module Types
@@ -21,6 +22,17 @@ module Kameleoon
         @name = name
       end
 
+      # @api private
+      def self._build_from_internal(source_variation, variation_id = nil, experiment_id = nil)
+        variables = (source_variation&.variables || []).each_with_object({}) do |variable, result|
+          ext_variable = Variable._build_from_internal(variable)
+          result[ext_variable.key] = ext_variable
+        end
+        key = source_variation&.key || ''
+        name = source_variation&.name || ''
+        Variation.new(key, variation_id, experiment_id, variables, name)
+      end
+
       def active?
         @key != Configuration::VariationType::VARIATION_OFF
       end

data/lib/kameleoon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Kameleoon
-  SDK_VERSION = '3.17.3'
+  SDK_VERSION = '3.19.0'
   SDK_NAME = 'RUBY'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 3.17.3
+  version: 3.19.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-01-22 00:00:00.000000000 Z
+date: 2026-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -86,6 +86,7 @@ files:
 - lib/kameleoon/configuration/variable.rb
 - lib/kameleoon/configuration/variation.rb
 - lib/kameleoon/configuration/variation_exposition.rb
+- lib/kameleoon/data/application_version.rb
 - lib/kameleoon/data/browser.rb
 - lib/kameleoon/data/cbscores.rb
 - lib/kameleoon/data/conversion.rb
@@ -145,7 +146,7 @@ files:
 - lib/kameleoon/real_time/sse_client.rb
 - lib/kameleoon/real_time/sse_message.rb
 - lib/kameleoon/real_time/sse_request.rb
-- lib/kameleoon/sdk_version.rb
+- lib/kameleoon/sem_version.rb
 - lib/kameleoon/storage/cache.rb
 - lib/kameleoon/storage/cache_factory.rb
 - lib/kameleoon/targeting/condition.rb
@@ -172,6 +173,7 @@ files:
 - lib/kameleoon/targeting/conditions/target_personalization_condition.rb
 - lib/kameleoon/targeting/conditions/time_elapsed_since_visit_condition.rb
 - lib/kameleoon/targeting/conditions/unknown_condition.rb
+- lib/kameleoon/targeting/conditions/version_condition.rb
 - lib/kameleoon/targeting/conditions/visit_number_today_condition.rb
 - lib/kameleoon/targeting/conditions/visit_number_total_condition.rb
 - lib/kameleoon/targeting/conditions/visitor_code_condition.rb

data/lib/kameleoon/sdk_version.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'kameleoon/logging/kameleoon_logger'
-
-module Kameleoon
-  # SdkManager is a helper method for fetching / obtaining version of SDK from string
-  class SdkVersion
-    def self.get_version_components(version_string)
-      versions = [0, 0, 0]
-
-      version_parts = version_string.split('.')
-      version_parts.each_with_index do |part, i|
-        versions[i] = Integer(part)
-      rescue ArgumentError
-        Logging::KameleoonLogger.error('Invalid version component, index: %s, value: %s', i, part)
-        return nil
-      end
-      versions
-    end
-
-    def self.get_float_version(version_string)
-      version_components = get_version_components(version_string)
-
-      return Float::NAN if version_components.nil?
-
-      major = version_components[0]
-      minor = version_components[1]
-      "#{major}.#{minor}".to_f
-    end
-  end
-end