kameleoon-client-ruby 3.3.0 → 3.5.0

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

@@ -5,12 +5,15 @@ require 'kameleoon/data/browser'
 require 'kameleoon/data/conversion'
 require 'kameleoon/data/custom_data'
 require 'kameleoon/data/device'
+require 'kameleoon/data/kcs_heat'
 require 'kameleoon/data/page_view'
+require 'kameleoon/data/unique_identifier'
 require 'kameleoon/data/user_agent'
 require 'kameleoon/data/manager/assigned_variation'
 require 'kameleoon/data/manager/page_view_visit'
 require 'kameleoon/data/manager/data_map_storage'
 require 'kameleoon/data/manager/data_array_storage'
+require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   module DataManager
@@ -18,132 +21,265 @@ module Kameleoon
     # Visitor is a container of all data assigned to a visitor.
     # It is thread-safe
     class Visitor
-      attr_reader :last_activity_time, :user_agent, :device, :browser, :geolocation, :operating_system, :cookie,
-                  :kcs_heat, :visitor_visits
-      attr_accessor :legal_consent, :mapping_identifier
+      attr_reader :data, :is_unique_identifier
 
-      def initialize
-        @mutex = Concurrent::ReadWriteLock.new
-        @legal_consent = false
+      def to_s
+        "Visitor{}"
+      end
+
+      def initialize(source = nil)
+        if source.nil?
+          @data = VisitorData.new
+          @is_unique_identifier = false
+        else
+          @data = source.data
+          @is_unique_identifier = source.is_unique_identifier
+        end
         update_last_activity_time
       end
 
+      def last_activity_time
+        @data.last_activity_time
+      end
+
       def update_last_activity_time
-        @last_activity_time = Time.new.to_i
+        @data.last_activity_time = Time.new.to_i
       end
 
       def enumerate_sendable_data(&blk)
-        blk.call(@device) unless @device.nil?
-        blk.call(@browser) unless @browser.nil?
-        blk.call(@operating_system) unless @operating_system.nil?
-        blk.call(@geolocation) unless @geolocation.nil?
-        @mutex.with_read_lock do
-          @custom_data_map&.each { |_, cd| blk.call(cd) }
-          @page_view_visits&.each { |_, pvv| blk.call(pvv.page_view) }
-          @conversions&.each { |c| blk.call(c) }
-          @variations&.each { |_, av| blk.call(av) }
-        end
+        @data.enumerate_sendable_data(&blk)
       end
 
       def count_sendable_data
-        count = 0
-        @mutex.with_read_lock do
-          count += 1 unless @device.nil?
-          count += 1 unless @browser.nil?
-          count += 1 unless @geolocation.nil?
-          count += 1 unless @operating_system.nil?
-          count += @custom_data_map.size unless @custom_data_map.nil?
-          count += @page_view_visits.size unless @page_view_visits.nil?
-          count += @conversions.size unless @conversions.nil?
-          count += @variations.size unless @variations.nil?
-        end
-        count
+        count_sendable_data = @data.count_sendable_data
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.count_sendable_data -> (count_sendable_data: %s)', count_sendable_data)
+        count_sendable_data
+      end
+
+      def user_agent
+        user_agent = @data.user_agent
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.user_agent -> (user_agent: %s)', user_agent)
+        user_agent
+      end
+
+      def device
+        device = @data.device
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.device -> (device: %s)', device)
+        device
+      end
+
+      def browser
+        browser = @data.browser
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.browser -> (browser: %s)', browser)
+        browser
+      end
+
+      def geolocation
+        geolocation = @data.geolocation
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.geolocation -> (geolocation: %s)', geolocation)
+        geolocation
+      end
+
+      def operating_system
+        operating_system = @data.operating_system
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.operating_system -> (operating_system: %s)', operating_system)
+        operating_system
+      end
+
+      def cookie
+        cookie = @data.cookie
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.cookie -> (cookie: %s)', cookie)
+        cookie
+      end
+
+      def kcs_heat
+        kcs_heat = @data.kcs_heat
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.kcs_heat -> (kcs_heat: %s)', kcs_heat)
+        kcs_heat
+      end
+
+      def visitor_visits
+        visitor_visits = @data.visitor_visits
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.visitor_visits -> (visitor_visits: %s)', visitor_visits)
+        visitor_visits
+      end
+
+      def legal_consent
+        legal_consent = @data.legal_consent
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.legal_consent -> (legal_consent: %s)', legal_consent)
+        legal_consent
+      end
+
+      def legal_consent=(value)
+        @data.legal_consent = value
+      end
+
+      def mapping_identifier
+        mapping_identifier = @data.mapping_identifier
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.mapping_identifier -> (mapping_identifier: %s)',
+                                       mapping_identifier)
+        mapping_identifier
+      end
+
+      def mapping_identifier=(value)
+        @data.mapping_identifier = value
       end
 
       def custom_data
-        DataMapStorage.new(@mutex, @custom_data_map)
+        custom_data = @data.custom_data
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.custom_data -> (custom_data: %s)', custom_data)
+        custom_data
       end
 
       def page_view_visits
-        DataMapStorage.new(@mutex, @page_view_visits)
+        page_view_visits = @data.page_view_visits
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.page_view_visits -> (page_view_visits: %s)',
+                                       page_view_visits)
+        page_view_visits
       end
 
       def conversions
-        DataArrayStorage.new(@mutex, @conversions)
+        conversions = @data.conversions
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.conversions -> (conversions: %s)', conversions)
+        conversions
       end
 
       def variations
-        DataMapStorage.new(@mutex, @variations)
+        variations = @data.variations
+        Logging::KameleoonLogger.debug('CALL/RETURN: Visitor.variations -> (variations: %s)', variations)
+        variations
       end
 
-      def add_data(log_func, *args, overwrite: true)
-        @mutex.with_write_lock do
+      def add_data(*args, overwrite: true)
+        Logging::KameleoonLogger.debug('CALL: Visitor.add_data(args: %s, overwrite: %s)', args, overwrite)
+        @data.mutex.with_write_lock do
           args.each do |data|
             case data
             when Kameleoon::UserAgent
-              set_user_agent(data)
+              @data.user_agent = data.value
             when Kameleoon::DataManager::AssignedVariation
-              add_variation(data, overwrite)
+              @data.add_variation(data, overwrite)
             when Kameleoon::Device
-              set_device(data, overwrite)
+              @data.set_device(data, overwrite)
             when Kameleoon::Browser
-              set_browser(data, overwrite)
+              @data.set_browser(data, overwrite)
             when Kameleoon::CustomData
-              add_custom_data(data, overwrite)
+              @data.add_custom_data(data, overwrite)
             when Kameleoon::PageView
-              add_page_view(data)
+              @data.add_page_view(data)
             when Kameleoon::DataManager::PageViewVisit
-              add_page_view_visit(data)
+              @data.add_page_view_visit(data)
             when Kameleoon::Conversion
-              add_conversion(data)
+              @data.add_conversion(data)
             when Kameleoon::Cookie
-              set_cookie(data)
+              @data.cookie = data
             when Kameleoon::OperatingSystem
-              set_operating_system(data, overwrite)
+              @data.set_operating_system(data, overwrite)
             when Kameleoon::Geolocation
-              set_geolocation(data, overwrite)
+              @data.set_geolocation(data, overwrite)
             when Kameleoon::KcsHeat
-              set_kcs_heat(data)
+              @data.kcs_heat = data
             when Kameleoon::VisitorVisits
-              set_visitor_visits(data)
+              @data.visitor_visits = data
+            when Kameleoon::UniqueIdentifier
+              @is_unique_identifier = data.value
             else
-              log_func&.call("Data has unsupported type '#{data.class}'")
+              Logging::KameleoonLogger.warning("Data has unsupported type '%s'", data.class)
             end
           end
         end
+        Logging::KameleoonLogger.debug('RETURN: Visitor.add_data(args: %s, overwrite: %s)', args, overwrite)
       end
 
       def assign_variation(variation)
-        @mutex.with_write_lock do
-          @variations = {} if @variations.nil?
-          @variations[variation.experiment_id] = variation
+        @data.mutex.with_write_lock do
+          @data.add_variation(variation, true)
+        end
+      end
+
+      def clone
+        Visitor.new(self)
+      end
+    end
+
+    class VisitorData
+      attr_reader :mutex, :device, :browser, :geolocation, :operating_system
+      attr_accessor :last_activity_time, :legal_consent, :user_agent, :cookie, :kcs_heat, :visitor_visits,
+                    :mapping_identifier
+
+      def initialize
+        Logging::KameleoonLogger.debug('CALL: VisitorData.new')
+        @mutex = Concurrent::ReadWriteLock.new
+        @legal_consent = false
+        Logging::KameleoonLogger.debug('RETURN: VisitorData.new')
+      end
+
+      def enumerate_sendable_data(&blk)
+        blk.call(@device) unless @device.nil?
+        blk.call(@browser) unless @browser.nil?
+        blk.call(@operating_system) unless @operating_system.nil?
+        blk.call(@geolocation) unless @geolocation.nil?
+        @mutex.with_read_lock do
+          @custom_data_map&.each { |_, cd| blk.call(cd) }
+          @page_view_visits&.each { |_, pvv| blk.call(pvv.page_view) }
+          @conversions&.each { |c| blk.call(c) }
+          @variations&.each { |_, av| blk.call(av) }
+        end
+      end
+
+      def count_sendable_data
+        Logging::KameleoonLogger.debug('CALL: Visitor.count_sendable_data')
+        count = 0
+        @mutex.with_read_lock do
+          count += 1 unless @device.nil?
+          count += 1 unless @browser.nil?
+          count += 1 unless @geolocation.nil?
+          count += 1 unless @operating_system.nil?
+          count += @custom_data_map.size unless @custom_data_map.nil?
+          count += @page_view_visits.size unless @page_view_visits.nil?
+          count += @conversions.size unless @conversions.nil?
+          count += @variations.size unless @variations.nil?
         end
+        Logging::KameleoonLogger.debug('RETURN: VisitorData.count_sendable_data -> (count: %s)', count)
+        count
       end
 
-      private
+      def custom_data
+        DataMapStorage.new(@mutex, @custom_data_map)
+      end
 
-      def set_user_agent(user_agent)
-        @user_agent = user_agent.value
+      def page_view_visits
+        DataMapStorage.new(@mutex, @page_view_visits)
+      end
+
+      def conversions
+        DataArrayStorage.new(@mutex, @conversions)
+      end
+
+      def variations
+        DataMapStorage.new(@mutex, @variations)
       end
 
       def set_device(device, overwrite)
-        @device = device if overwrite || @device == nil
+        @device = device if overwrite || @device.nil?
       end
 
       def add_variation(variation, overwrite)
-        @variations = {} if @variations == nil
+        @variations = {} if @variations.nil?
         if overwrite || !@variations.include?(variation.experiment_id)
           @variations[variation.experiment_id] = variation
         end
       end
 
       def set_browser(browser, overwrite)
-        @browser = browser if overwrite || @browser == nil
+        @browser = browser if overwrite || @browser.nil?
       end
 
       def add_custom_data(custom_data, overwrite)
         @custom_data_map = {} if @custom_data_map.nil?
-        @custom_data_map[custom_data.id] = custom_data if overwrite || !@custom_data_map.include?(custom_data.id)
+        if overwrite || !@custom_data_map.include?(custom_data.id)
+          @custom_data_map[custom_data.id] = custom_data
+        end
       end
 
       def add_page_view(page_view)
@@ -176,23 +312,11 @@ module Kameleoon
       end
 
       def set_geolocation(geolocation, overwrite)
-        @geolocation = geolocation if overwrite || @geolocation == nil
-      end
-
-      def set_cookie(cookie)
-        @cookie = cookie
+        @geolocation = geolocation if overwrite || @geolocation.nil?
       end
 
       def set_operating_system(operating_system, overwrite)
-        @operating_system = operating_system if overwrite || @operating_system == nil
-      end
-
-      def set_kcs_heat(kcs_heat)
-        @kcs_heat = kcs_heat
-      end
-
-      def set_visitor_visits(visitor_visits)
-        @visitor_visits = visitor_visits
+        @operating_system = operating_system if overwrite || @operating_system.nil?
       end
     end
   end

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

@@ -2,7 +2,10 @@
 
 require 'concurrent'
 require 'rufus/scheduler'
+require 'kameleoon/configuration/custom_data_info'
+require 'kameleoon/data/mapping_identifier'
 require 'kameleoon/data/manager/visitor'
+require 'kameleoon/logging/kameleoon_logger'
 
 module Kameleoon
   module DataManager
@@ -11,36 +14,52 @@ module Kameleoon
     # It is thread-safe except `stop` method
     class VisitorManager
       attr_reader :expiration_period
-      attr_accessor :custom_data_info
 
-      def initialize(expiration_period, log_func = nil)
+      def initialize(data_manager, expiration_period, scheduler)
+        Logging::KameleoonLogger.debug(
+          'CALL: VisitorManager.new(data_manager, expiration_period: %s, scheduler)', expiration_period
+        )
+        @data_manager = data_manager
         @expiration_period = expiration_period
+        @scheduler = scheduler
         @visitors = Concurrent::Map.new
-        @log_func = log_func
         start
+        Logging::KameleoonLogger.debug(
+          'RETURN: VisitorManager.new(data_manager, expiration_period: %s, scheduler)', expiration_period
+        )
       end
 
       def stop
-        return if @purge_job.nil?
-
-        @purge_job.unschedule
+        Logging::KameleoonLogger.debug('CALL: VisitorManager.stop')
+        @purge_job&.unschedule
         @purge_job = nil
+        Logging::KameleoonLogger.debug('RETURN: VisitorManager.stop')
       end
 
       def get_visitor(visitor_code)
-        @visitors.compute_if_present(visitor_code) do |visitor|
+        Logging::KameleoonLogger.debug("CALL: VisitorManager.get_visitor(visitor_code: '%s')", visitor_code)
+        visitor = @visitors.compute_if_present(visitor_code) do |visitor|
           visitor.update_last_activity_time
           visitor
         end
+        Logging::KameleoonLogger.debug("RETURN: VisitorManager.get_visitor(visitor_code: '%s') -> (visitor: %s)",
+                              visitor_code, visitor)
+        visitor
       end
 
       def get_or_create_visitor(visitor_code)
-        @visitors.compute(visitor_code) do |former_v|
+        Logging::KameleoonLogger.debug("CALL: VisitorManager.get_or_create_visitor(visitor_code: '%s')",
+                                       visitor_code)
+        visitor = @visitors.compute(visitor_code) do |former_v|
           next DataManager::Visitor.new if former_v.nil?
 
           former_v.update_last_activity_time
           former_v
         end
+        Logging::KameleoonLogger.debug(
+          "RETURN: VisitorManager.get_or_create_visitor(visitor_code: '%s') -> (visitor)", visitor_code
+        )
+        visitor
       end
 
       def enumerate(&blk)
@@ -51,42 +70,60 @@ module Kameleoon
         @visitors.size
       end
 
-      def add_data(visitor_code, *args)
+      def add_data(visitor_code, *args, overwrite: true)
+        Logging::KameleoonLogger.debug("CALL: VisitorManager.add_data(visitor_code: '%s', args: %s, overwrite: %s)",
+                                       visitor_code, args, overwrite)
         visitor = get_or_create_visitor(visitor_code)
-        for custom_data in args
+        cdi = @data_manager.data_file.custom_data_info
+        args.size.times do |i|
+          custom_data = args[i]
           next unless custom_data.is_a?(Kameleoon::CustomData)
+
           # We shouldn't send custom data with local only type
-          custom_data.mark_as_sent if @custom_data_info.local_only?(custom_data.id)
+          custom_data.mark_as_sent if cdi.local_only?(custom_data.id)
           # If mappingIdentifier is passed, we should link anonymous visitor with real unique userId.
           # After authorization, customer must be able to continue work with userId, but hash for variation
           # should be calculated based on anonymous visitor code, that's why set MappingIdentifier to visitor.
-          if @custom_data_info.mapping_identifier?(custom_data.id) && custom_data.values.size > 0 && custom_data.values[0].size > 0
-            custom_data.is_mapping_identifier = true
+          if Configuration::CustomDataInfo.mapping_identifier?(cdi, custom_data)
             visitor.mapping_identifier = visitor_code
-            target_visitor_code = custom_data.values[0]
-            @visitors[target_visitor_code] = visitor if visitor_code != target_visitor_code
+            user_id = custom_data.values[0]
+            args[i] = MappingIdentifier.new(custom_data)
+            if visitor_code != user_id
+              @visitors[user_id] = visitor.clone
+              Logging::KameleoonLogger.info(-> { "Linked anonymous visitor '#{visitor_code}' with user '#{user_id}'" })
+            end
           end
         end
-        visitor.add_data(@log_func, *args)
+        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
+        )
         visitor
       end
 
       private
 
       def purge
+        Logging::KameleoonLogger.debug('CALL: VisitorManager.purge')
         expired_time = Time.new.to_i - @expiration_period
         @visitors.each_pair do |vc, v|
           next if v.last_activity_time >= expired_time
 
           @visitors.compute_if_present(vc) { |visitor| v.last_activity_time < expired_time ? nil : visitor }
         end
+        Logging::KameleoonLogger.debug('RETURN: VisitorManager.purge')
+        @visitors
       end
 
       def start
+        Logging::KameleoonLogger.debug('CALL: VisitorManager.start')
         stop unless @purge_job.nil?
-        @purge_job = Rufus::Scheduler.singleton.schedule_every @expiration_period do
+        @purge_job = @scheduler.schedule_every @expiration_period do
           purge
         end
+        Logging::KameleoonLogger.debug('RETURN: VisitorManager.start')
+        @purge_job
       end
     end
   end

data/lib/kameleoon/data/mapping_identifier.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/custom_data'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  class MappingIdentifier < CustomData
+    def initialize(custom_data)
+      super(custom_data.id, *custom_data.values)
+    end
+
+    def unsent
+      true
+    end
+
+    def transmitting
+      false
+    end
+
+    def sent
+      false
+    end
+
+    def obtain_full_post_text_line
+      mip = Kameleoon::Network::UriHelper.encode_query({ mappingIdentifier: true })
+      "#{super}&#{mip}"
+    end
+
+    def to_s
+      "MappingIdentifier{id:#{@id},values:#{@values}}"
+    end
+  end
+end

data/lib/kameleoon/data/operating_system.rb

@@ -52,6 +52,10 @@ module Kameleoon
   class OperatingSystem < DuplicationUnsafeData
     attr_reader :os_type
 
+    def to_s
+      "OperatingSystem{os_type:#{@os_type}}"
+    end
+
     # @param [OperatingSystemType] os_type Operating system type, can be: WINDOWS, MAC, IOS, LINUX, ANDROID, WINDOWS_PHONE
     def initialize(os_type)
       super(DataType::OPERATING_SYSTEM)

data/lib/kameleoon/data/page_view.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'kameleoon/logging/kameleoon_logger'
 require 'kameleoon/network/uri_helper'
 require_relative 'data'
 
@@ -9,13 +10,17 @@ module Kameleoon
   class PageView < DuplicationSafeData
     attr_reader :url, :title, :referrer
 
+    def to_s
+      "PageView{url:'#{@url}',title:'#{@title}',referrers:#{@referrers}}"
+    end
+
     # @param [String] url Url of the page
     # @param [String] title Optional field - title of the page
     # @param [Array] referrers Optional field - Referrer ids
     def initialize(url, title = nil, referrers = nil)
       super(DataType::PAGE_VIEW)
       @url = url || ''
-      print('Kameleoon SDK: Url for PageView is required parameter, the data will be ignored.') if url == ''
+      Logging::KameleoonLogger.error('Url for PageView is required parameter, the data will be ignored.') if @url == ''
       @title = title || ''
       @referrers = referrers.instance_of?(Integer) ? [referrers] : referrers
     end

data/lib/kameleoon/data/unique_identifier.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  class UniqueIdentifier
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+  end
+end

data/lib/kameleoon/data/user_agent.rb

@@ -7,6 +7,10 @@ module Kameleoon
   class UserAgent
     attr_reader :value
 
+    def to_s
+      "UserAgent{value:#{@value}}"
+    end
+
     def initialize(value)
       @value = value
     end

data/lib/kameleoon/data/visitor_visits.rb

@@ -4,6 +4,10 @@ module Kameleoon
   class VisitorVisits
     attr_reader :previous_visit_timestamps
 
+    def to_s
+      "VisitorVisits{previous_visit_timestamps:#{@previous_visit_timestamps}}"
+    end
+
     def initialize(previous_visit_timestamps = [])
       @previous_visit_timestamps = previous_visit_timestamps
       @previous_visit_timestamps.freeze

data/lib/kameleoon/hybrid/manager.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
+require 'kameleoon/logging/kameleoon_logger'
+
 module Kameleoon
   module Hybrid
     TC_INIT = 'window.kameleoonQueue=window.kameleoonQueue||[];'
-    TC_ASSIGN_VARIATION_FORMAT = "window.kameleoonQueue.push(['Experiments.assignVariation',%d,%d]);"
-    TC_TRIGGER_FORMAT = "window.kameleoonQueue.push(['Experiments.trigger',%d,true]);"
+    TC_ASSIGN_VARIATION_FORMAT = "window.kameleoonQueue.push(['Experiments.assignVariation',%d,%d,true]);"
+    TC_TRIGGER_FORMAT = "window.kameleoonQueue.push(['Experiments.trigger',%d,%s]);"
     TC_ASSIGN_VARIATION_TRIGGER_FORMAT = TC_ASSIGN_VARIATION_FORMAT + TC_TRIGGER_FORMAT
 
     # Will be useful for Ruby 3.0
@@ -17,25 +19,35 @@ module Kameleoon
 
     # Implementation of Cache with auto cleaning feature
     class ManagerImpl < Manager
-      def initialize(expiration_time, log_func)
+      def initialize(expiration_time, data_manager)
         super()
+        Logging::KameleoonLogger.debug('CALL: HybridManager.new(expiration_time: %s)', expiration_time)
         @expiration_time = expiration_time
-        @log = log_func
-        @log.call('Hybrid Manager was successfully initialized')
+        @data_manager = data_manager
+        Logging::KameleoonLogger.debug('RETURN: HybridManager.new(expiration_time: %s)', expiration_time)
       end
 
       def get_engine_tracking_code(visitor_variations)
+        Logging::KameleoonLogger.debug('CALL: HybridManager.get_engine_tracking_code(visitor_variations: %s)',
+                                       visitor_variations)
         tracking_code = [TC_INIT]
         unless visitor_variations.nil?
           expired_time = (Time.now - @expiration_time).to_i
           visitor_variations.enumerate do |v|
             if v.assignment_time > expired_time
-              v_code = format(TC_ASSIGN_VARIATION_TRIGGER_FORMAT, v.experiment_id, v.variation_id, v.experiment_id)
+              tracking_only = !@data_manager.data_file.experiment_js_css_variable?(v.experiment_id)
+              v_code = format(TC_ASSIGN_VARIATION_TRIGGER_FORMAT, v.experiment_id, v.variation_id, v.experiment_id,
+                              tracking_only)
               tracking_code.push(v_code)
             end
           end
         end
-        tracking_code.join
+        tracking_code = tracking_code.join
+        Logging::KameleoonLogger.debug(
+          "RETURN: HybridManager.get_engine_tracking_code(visitor_variations: %s) -> (tracking_code: '%s')",
+          visitor_variations, tracking_code
+        )
+        tracking_code
       end
     end
   end