kameleoon-client-ruby 3.2.0 → 3.4.0

data/lib/kameleoon/network/network_manager.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/network/content_type'
 require 'kameleoon/network/method'
 require 'kameleoon/network/request'
@@ -21,13 +22,12 @@ module Kameleoon
 
       attr_reader :environment, :default_timeout, :access_token_source, :url_provider
 
-      def initialize(environment, default_timeout, access_token_source_factory, url_provider, log_func = nil)
+      def initialize(environment, default_timeout, access_token_source_factory, url_provider)
         @environment = environment
         @default_timeout = default_timeout
         @access_token_source = access_token_source_factory.create(self)
         @url_provider = url_provider
         @sync_net_provider = SyncNetProvider.new
-        @log_func = log_func
       end
 
       def fetch_configuration(timestamp = nil, timeout = nil)
@@ -52,17 +52,13 @@ module Kameleoon
         make_call(request, true)
       end
 
-      def send_tracking_data(visitor_code, lines, user_agent, is_unique_identifier, timeout = nil)
+      def send_tracking_data(lines, timeout = nil)
         return if lines.nil? || lines.empty?
 
-        url = @url_provider.make_tracking_url(visitor_code, is_unique_identifier)
+        url = @url_provider.make_tracking_url
         timeout = ensure_timeout(timeout)
-        data = (lines.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8')
-        request = Request.new(Method::POST, url, ContentType::TEXT, timeout, user_agent: user_agent, data: data)
-        Thread.new do
-          result = make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY)
-          lines.each(&:mark_as_sent) if result != false
-        end
+        request = Request.new(Method::POST, url, ContentType::TEXT, timeout, data: lines)
+        make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY)
       end
 
       def fetch_access_jwtoken(client_id, client_secret, timeout = nil)
@@ -81,6 +77,8 @@ module Kameleoon
       private
 
       def make_call(request, try_access_token_auth, retry_limit = 0, retry_delay = 0)
+        Logging::KameleoonLogger.debug('Running request %s with access token %s, retry limit %s, retry delay %s ms',
+                                       request, try_access_token_auth, retry_limit, retry_delay)
         attempt = 0
         success = false
         while !success && (attempt <= retry_limit)
@@ -90,33 +88,30 @@ module Kameleoon
           if response.success?
             success = true
           elsif !response.error.nil?
-            log_failure(request, "Error occurred during request: #{response.error}")
+            Logging::KameleoonLogger.warning("%s call '%s' failed: Error occurred during request: %s",
+                                             request.method, request.url, response.error)
           else
-            log_failure(request, "Received unexpected status code '#{response.code}'")
+            Logging::KameleoonLogger.warning("%s call '%s' failed: Received unexpected status code '%s'",
+                                             request.method, request.url, response.code)
             if response.code == 401 && request.access_token
-              @log_func&.call("Unexpected rejection of access token '#{request.access_token}'")
+              Logging::KameleoonLogger.warning("Unexpected rejection of access token '#{request.access_token}'")
               @access_token_source.discard_token(request.access_token)
               if attempt == retry_limit
                 try_access_token_auth = false
                 retry_delay = 0
                 request.authorize(nil)
                 attempt -= 1
+                Logging::KameleoonLogger.error("Wrong Kameleoon API access token slows down the SDK's requests")
               end
             end
           end
           attempt += 1
         end
+        Logging::KameleoonLogger.debug('Fetched response %s for request %s', response, request)
+        Logging::KameleoonLogger.error("Failed %s request '%s'", request.method, request.url) unless success
         success ? response.body : false
       end
 
-      def log_failure(request, message)
-        return if @log_func.nil?
-
-        premsg = "#{request.method} call '#{request.url}' "
-        premsg += request.data.nil? ? 'failed' : "(data '#{request.data}') failed"
-        @log_func.call("#{premsg}: #{message}")
-      end
-
       def delay(period)
         sleep(period)
       end

data/lib/kameleoon/network/request.rb

@@ -5,14 +5,25 @@ module Kameleoon
     ##
     # Request represents HTTP request.
     class Request
-      attr_reader :method, :url, :content_type, :timeout, :user_agent, :extra_headers, :data, :access_token
+      attr_reader :method, :url, :content_type, :timeout, :extra_headers, :data, :access_token
 
-      def initialize(method, url, content_type, timeout, user_agent: nil, extra_headers: nil, data: nil)
+      def to_s
+        body = 'null'
+        unless @data.nil?
+          if @data.is_a?(String)
+            body = @data.start_with?('grant_type=client_credentials') ? '****' : @data
+          else
+            body = @data
+          end
+        end
+        "HttpRequest{Method:'#{@method}',Url:'#{@url}',Headers:#{@extra_headers},Body:'#{body}'}"
+      end
+
+      def initialize(method, url, content_type, timeout, extra_headers: nil, data: nil)
         @method = method
         @url = url
         @content_type = content_type
         @timeout = timeout
-        @user_agent = user_agent
         @extra_headers = extra_headers
         @data = !data.nil? && data.is_a?(String) ? data.encode('UTF-8') : data
       end

data/lib/kameleoon/network/response.rb

@@ -7,6 +7,10 @@ module Kameleoon
     class Response
       attr_reader :error, :code, :body, :request
 
+      def to_s
+        "HttpResponse{Code:'#{@code}',Reason:'#{@error}',Body:#{@body}}"
+      end
+
       def initialize(error, code, body, request)
         @error = error
         @code = code

data/lib/kameleoon/network/url_provider.rb

@@ -19,7 +19,7 @@ module Kameleoon
       DEFAULT_DATA_API_DOMAIN = 'data.kameleoon.io'
       TEST_DATA_API_DOMAIN = 'data.kameleoon.net'
       DEFAULT_AUTOMATION_API_DOMAIN = 'api.kameleoon.com'
-      TEST_AUTOMATION_API_DOMAIN = 'api.kameleoon.net'
+      TEST_AUTOMATION_API_DOMAIN = 'api.master.preview.kameleoon.net'
 
       attr_reader :site_code, :data_api_domain, :automation_api_domain
 
@@ -37,13 +37,13 @@ module Kameleoon
         @data_api_domain = domain if domain.is_a?(String)
       end
 
-      def make_tracking_url(visitor_code, is_unique_identifier = false)
+      def make_tracking_url
         params = {
           sdkName: SDK_NAME,
           sdkVersion: SDK_VERSION,
-          siteCode: @site_code
+          siteCode: @site_code,
+          bodyUa: true
         }
-        params[is_unique_identifier ? :mappingValue : :visitorCode] = visitor_code
         "https://#{@data_api_domain}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
       end
 
@@ -52,12 +52,13 @@ module Kameleoon
         params[is_unique_identifier ? :mappingValue : :visitorCode] = visitor_code
         params[:maxNumberPreviousVisits] = filter.previous_visit_amount
         params[:version] = 0
-        params[:currentVisit] = filter.current_visit if filter.current_visit
-        params[:customData] = filter.custom_data if filter.custom_data
-        params[:conversion] = filter.conversions if filter.conversions
-        params[:geolocation] = filter.geolocation if filter.geolocation
-        params[:experiment] = filter.experiments if filter.experiments
-        params[:page] = filter.page_views if filter.page_views
+        params[:kcs] = true if filter.kcs
+        params[:currentVisit] = true if filter.current_visit
+        params[:customData] = true if filter.custom_data
+        params[:conversion] = true if filter.conversions
+        params[:geolocation] = true if filter.geolocation
+        params[:experiment] = true if filter.experiments
+        params[:page] = true if filter.page_views
         params[:staticData] = true if filter.device || filter.browser || filter.operating_system
         "https://#{@data_api_domain}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
       end

data/lib/kameleoon/real_time/real_time_configuration_service.rb

@@ -3,6 +3,7 @@
 # Kameleoon Real Time Configuration Service
 
 require 'json'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/real_time/real_time_event'
 require 'kameleoon/real_time/sse_request'
 require 'kameleoon/real_time/sse_client'
@@ -21,8 +22,7 @@ module Kameleoon
       # @param url [String]
       # @param update_handler [Callable[Kameleoon::RealTime::RealTimeEvent] | NilClass] Handler which
       # is synchronously called for gotten RealTimeEvent objects.
-      # @param log_func [Callable[String] | NilClass] Callable object which synchronously called to log.
-      def initialize(url, update_handler, log_func, sse_request_source = nil)
+      def initialize(url, update_handler, sse_request_source = nil)
         @url = url
         @update_handler = update_handler
         @need_close = false
@@ -31,7 +31,6 @@ module Kameleoon
           'Cache-Control': 'no-cache',
           'Connection': 'Keep-Alive'
         }
-        @log_func = log_func
         @sse_request_source = sse_request_source
         @sse_thread = nil
         @sse_client = nil
@@ -43,13 +42,13 @@ module Kameleoon
       def close
         return if @need_close
 
-        @log_func&.call('Real-time configuration service is shutting down')
+        Logging::KameleoonLogger.info('Real-time configuration service is shutting down')
         @need_close = true
         return if @sse_thread.nil?
 
         @sse_thread.kill
         @sse_thread = nil
-        @sse_client.call_close_handler
+        @sse_client&.call_close_handler
       end
 
       private
@@ -60,7 +59,7 @@ module Kameleoon
 
       def init_sse_client
         message_handler = proc do |message|
-          @log_func&.call("Got SSE event: #{message.event}")
+          Logging::KameleoonLogger.debug("Got SSE event: #{message.event}")
           if message.event == CONFIGURATION_UPDATE_EVENT
             event_dict = JSON.parse(message.data)
             @update_handler&.call(RealTimeEvent.new(event_dict))
@@ -68,14 +67,14 @@ module Kameleoon
         end
         sse_request = make_sse_request
         @sse_client = SseClient.new(sse_request, message_handler)
-        @log_func&.call('Created SSE client')
+        Logging::KameleoonLogger.info('Created SSE client')
       end
 
       def make_sse_request
-        open_handler = proc { @log_func&.call('SSE connection open') }
-        close_handler = proc { @log_func&.call('SSE connection closed') }
+        open_handler = proc { Logging::KameleoonLogger.info('SSE connection open') }
+        close_handler = proc { Logging::KameleoonLogger.info('SSE connection closed') }
         unexpected_status_code_handler =
-          proc { |resp| @log_func&.call("Unexpected status code of SSE response: #{resp.code}") }
+          proc { |resp| Logging::KameleoonLogger.error("Unexpected status code of SSE response: #{resp.code}") }
         if @sse_request_source.nil?
           return SseRequest.new(@url, @headers, open_handler, close_handler, unexpected_status_code_handler)
         end
@@ -89,7 +88,7 @@ module Kameleoon
           begin
             @sse_client.start
           rescue StandardError => e
-            @log_func&.call("Error occurred within SSE client: #{e}")
+            Logging::KameleoonLogger.error("Error occurred within SSE client: #{e}")
           end
         end
       end

data/lib/kameleoon/sdk_version.rb

@@ -0,0 +1,31 @@
+# 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

data/lib/kameleoon/targeting/condition.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
+
 require 'kameleoon/exceptions'
+require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   # @api private
@@ -26,6 +28,7 @@ module Kameleoon
       VISITS = 'VISITS'
       SAME_DAY_VISITS = 'SAME_DAY_VISITS'
       NEW_VISITORS = 'NEW_VISITORS'
+      HEAT_SLICE = 'HEAT_SLICE'
     end
 
     module Operator
@@ -45,12 +48,13 @@ module Kameleoon
 
     # Base class for all targeting conditions
     class Condition
-      attr_reader :type, :include
+      attr_reader :type, :include, :id
 
       def initialize(json_condition)
         raise Exception::NotFound.new('targetingType'), 'targetingType missed' if json_condition['targetingType'].nil?
 
         @type = json_condition['targetingType']
+        @id = json_condition['id']
         @include = json_condition['isInclude'].nil? ? true : json_condition['isInclude']
       end
 
@@ -68,7 +72,7 @@ module Kameleoon
         begin
           return pattern.match? value
         rescue StandardError => e
-          log "Failed to match with regex (targeting): #{e}"
+          Logging::KameleoonLogger.error("Failed to match with regex (targeting): #{e}")
         end
         false
       end

data/lib/kameleoon/targeting/condition_factory.rb

@@ -11,6 +11,7 @@ require_relative 'conditions/conversion_condition'
 require_relative 'conditions/browser_condition'
 require_relative 'conditions/sdk_language_condition'
 require_relative 'conditions/geolocation_condition'
+require_relative 'conditions/kcs_heat_range_condition'
 require_relative 'conditions/operating_system_condition'
 require_relative 'conditions/cookie_condition'
 require_relative 'conditions/segment_condition'
@@ -67,6 +68,8 @@ module Kameleoon
           VisitorNewReturnCondition.new(condition_json)
         when ConditionType::FIRST_VISIT, ConditionType::LAST_VISIT
           TimeElapsedSinceVisitCondition.new(condition_json)
+        when ConditionType::HEAT_SLICE
+          KcsHeatRangeCondition.new(condition_json)
         else
           UnknownCondition.new(condition_json)
         end

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/browser'
-require 'kameleoon/version'
+require 'kameleoon/logging/kameleoon_logger'
+require 'kameleoon/sdk_version'
 
 module Kameleoon
   # @api private
   module Targeting
-
     CHROME = 'CHROME'
     INTERNET_EXPLORER = 'IE'
     FIREFOX = 'FIREFOX'
@@ -44,7 +44,7 @@ module Kameleoon
         when Operator::LOWER
           browser.version < version_number
         else
-          puts "Unexpected comparing operation for Browser condition: #{@version_match_type}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for 'Browser' condition: '#{@version_match_type}'")
           false
         end
       end

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/cookie'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/version'
 
 module Kameleoon
   # @api private
   module Targeting
-
     class CookieCondition < Condition
       def initialize(json_condition)
         super(json_condition)
@@ -26,13 +26,13 @@ module Kameleoon
         case @name_match_type
         when Kameleoon::Targeting::Operator::EXACT
           value = cookie.cookies[@condition_name]
-          return value != nil ? [value] : []
+          return !value.nil? ? [value] : []
         when Kameleoon::Targeting::Operator::CONTAINS
-          return cookie.cookies.select{|key| key.include? @condition_name}.values()
+          return cookie.cookies.select { |key| key.include? @condition_name }.values
         when Kameleoon::Targeting::Operator::REGULAR_EXPRESSION
-          return cookie.cookies.select{|key| is_regex_match(@condition_name, key)}.values()
+          return cookie.cookies.select { |key| is_regex_match(@condition_name, key) }.values
         else
-          log "Unexpected comparing operation for Cookie condition (name): #{@name_match_type}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for 'Cookie' condition (name): '#{@name_match_type}'")
         end
         []
       end
@@ -40,14 +40,14 @@ module Kameleoon
       def check_values(values)
         case @value_match_type
         when Kameleoon::Targeting::Operator::EXACT
-          return values.any? {|value| value == @condition_value}
+          values.any? { |value| value == @condition_value }
         when Kameleoon::Targeting::Operator::CONTAINS
-          return values.any? {|value| value.include? @condition_value}
+          values.any? { |value| value.include? @condition_value }
         when Kameleoon::Targeting::Operator::REGULAR_EXPRESSION
-          return values.any? {|value| is_regex_match(@condition_value, value)}
+          values.any? { |value| is_regex_match(@condition_value, value) }
         else
-          log "Unexpected comparing operation for Cookie condition (name): #{@name_match_type}"
-          return false
+          Logging::KameleoonLogger.error("Unexpected comparing operation for 'Cookie' condition (name): '#{@name_match_type}'")
+          false
         end
       end
     end

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

@@ -6,7 +6,6 @@ require 'kameleoon/version'
 module Kameleoon
   # @api private
   module Targeting
-
     class GeolocationCondition < Condition
       def initialize(json_condition)
         super(json_condition)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/device'
+
+module Kameleoon
+  # @api private
+  module Targeting
+    # KcsHeatRangeCondition is a condition for checking KCS heat
+    class KcsHeatRangeCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @goal_id = json_condition['goalId'] || -1
+        @key_moment_id = json_condition['keyMomentId'] || -1
+        @lower_bound = json_condition['lowerBound'] || Float::MAX
+        @upper_bound = json_condition['upperBound'] || Float::MIN
+      end
+
+      def check(kcs_heat)
+        kcs_heat.is_a?(Kameleoon::KcsHeat) && check_targeting(kcs_heat)
+      end
+
+      private
+
+      def check_targeting(kcs_heat)
+        return false unless kcs_heat.values.is_a?(Hash)
+
+        goal_scores = kcs_heat.values[@key_moment_id]
+        return false unless goal_scores.is_a?(Hash)
+
+        score = goal_scores[@goal_id]
+        return false unless score.is_a?(Float) || score.is_a?(Integer)
+
+        (score >= @lower_bound) && (score <= @upper_bound)
+      end
+    end
+  end
+end

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/cookie'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/version'
 
 module Kameleoon
   # @api private
   module Targeting
-
     class NumberCondition < Condition
       def initialize(json_condition, value)
         super(json_condition)
@@ -25,11 +25,11 @@ module Kameleoon
         when Kameleoon::Targeting::Operator::EQUAL
           return value == @condition_value
         when Kameleoon::Targeting::Operator::GREATER
-          return @condition_value != nil && value > @condition_value
+          return !@condition_value.nil? && value > @condition_value
         when Kameleoon::Targeting::Operator::LOWER
-          return @condition_value != nil && value < @condition_value
+          return !@condition_value.nil? && value < @condition_value
         else
-          log "Unexpected comparing operation for #{type} condition: #{@match_type}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for '#{@type}' condition: '#{@match_type}'")
         end
         false
       end

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

@@ -6,7 +6,6 @@ require 'kameleoon/version'
 module Kameleoon
   # @api private
   module Targeting
-
     class OperatingSystemCondition < Condition
       def initialize(json_condition)
         super(json_condition)
@@ -20,7 +19,7 @@ module Kameleoon
       private
 
       def check_targeting(operating_system)
-        @os_type != nil && operating_system.os_type == @os_type
+        !@os_type.nil? && operating_system.os_type == @os_type
       end
     end
   end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'kameleoon/data/data'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/version'
 
 module Kameleoon
@@ -56,7 +57,7 @@ module Kameleoon
             (major_sdk == major_condition && minor_sdk < minor_condition) ||
             (major_sdk == major_condition && minor_sdk == minor_condition && patch_sdk < patch_condition)
         else
-          puts "Unexpected comparing operation for SdkLanguage condition: #{@operator}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for 'SdkLanguage' condition: '#{@operator}'")
           false
         end
       end

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

@@ -6,11 +6,10 @@ require 'kameleoon/version'
 module Kameleoon
   # @api private
   module Targeting
-
     class SegmentCondition < Condition
       def initialize(json_condition)
         super(json_condition)
-        @segment_id = json_condition["segmentId"]
+        @segment_id = json_condition['segmentId']
       end
 
       def check(data)
@@ -22,7 +21,8 @@ module Kameleoon
       def check_targeting(segment_info)
         rule = segment_info.data_file.rule_by_segment_id[@segment_id]
         return false unless rule.is_a?(Kameleoon::Configuration::Rule)
-        rule.targeting_segment.check_tree(->(type) {segment_info.condition_data(type)})
+
+        rule.targeting_segment.check_tree(->(type) { segment_info.condition_data(type) })
       end
     end
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/targeting/condition'
 
 module Kameleoon
@@ -33,7 +34,7 @@ module Kameleoon
           pattern = Regexp.new(@condition_value)
           pattern.match?(value)
         else
-          puts "Unexpected comparing operation for #{@type} condition: #{@operator}"
+          Logging::KameleoonLogger.error("Unexpected comparing operation for '#{@type}' condition: '#{@operator}'")
           false
         end
       end

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

@@ -20,20 +20,19 @@ module Kameleoon
 
       def check(data)
         return false unless data.is_a?(Kameleoon::Targeting::TargetFeatureFlagInfo) && data.variations_storage.size != 0
-        get_rules(data).any? {|rule| check_rule(data, rule)}
+
+        get_rules(data).any? { |rule| check_rule(data, rule) }
       end
 
       private def check_rule(data, rule)
-        return false if !rule.is_a?(Kameleoon::Configuration::Rule) || rule.experiment_id == nil
+        return false if !rule.is_a?(Kameleoon::Configuration::Rule) || rule.experiment_id.nil?
 
-        if @condition_rule_id != nil
-          return false if @condition_rule_id != rule.id
-        end
+        return false if !@condition_rule_id.nil? && (@condition_rule_id != rule.id)
 
         variation = data.variations_storage.get(rule.experiment_id)
-        return false if variation == nil
+        return false if variation.nil?
 
-        return true if @condition_variation_key == nil
+        return true if @condition_variation_key.nil?
 
         variation = data.data_file.variation_by_id[variation.variation_id]
 
@@ -44,10 +43,7 @@ module Kameleoon
 
       def get_rules(data)
         feature_flag = data.data_file.feature_flag_by_id[@feature_flag_id]
-        if feature_flag != nil
-          return feature_flag.rules
-        end
-        []
+        feature_flag&.rules || []
       end
     end
 

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

@@ -6,7 +6,6 @@ require 'kameleoon/data/visitor_visits'
 module Kameleoon
   # @api private
   module Targeting
-
     class TimeElapsedSinceVisitCondition < NumberCondition
       def initialize(json_condition)
         count_in_millis = json_condition['countInMillis']
@@ -15,7 +14,7 @@ module Kameleoon
       end
 
       def check(data)
-        return false unless data.is_a?(Kameleoon::VisitorVisits) && @condition_value != nil
+        return false unless data.is_a?(Kameleoon::VisitorVisits) && !@condition_value.nil?
 
         previous_visits_count = data.previous_visit_timestamps.count
         if previous_visits_count >= 1

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

@@ -6,7 +6,6 @@ require 'time'
 module Kameleoon
   # @api private
   module Targeting
-
     class VisitNumberTodayCondition < NumberCondition
       def initialize(json_condition)
         visit_count = json_condition['visitCount']
@@ -14,10 +13,11 @@ module Kameleoon
       end
 
       def check(data)
-        return false unless data.is_a?(Kameleoon::VisitorVisits) && @condition_value != nil
+        return false unless VisitorVisits.visitor_visits?(data) && !@condition_value.nil?
+
         number_of_visits_today = 0
-        start_of_day = (Time.new.to_date.to_time.to_f * 1000).to_i # ... * 1000 for convert seconds to milliseconds
-        for timestamp in data.previous_visit_timestamps
+        start_of_day = (Time.new.to_date.to_time.to_f * 1000).to_i # ... * 1000 to convert seconds to milliseconds
+        for timestamp in VisitorVisits.get_previous_visit_timestamps(data)
           break if timestamp < start_of_day
           number_of_visits_today += 1
         end