kameleoon-client-ruby 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba4f943be2e686ba2cca810ef8f456622e25733eda03808c7b3d81e2d72b1ee3
-  data.tar.gz: cef2edf8ef8e449f3150f73c5df9d76477342a52e49fbf90885b458fd6aa1b57
+  metadata.gz: 1aef3f7b97d4a32024bec989ed4356cc1d10425c16b419b55f524cf1abfd4f52
+  data.tar.gz: 5705b067a3effc12b7f38ccef23e01ee28e370b99a212fd371ce0c863184c3ec
 SHA512:
-  metadata.gz: 5b4e8f09c36222e08e9b426e90db6fb05476aa0e9bcd53036de31a8d7819db7b95ea5960adc6cc059494eb5355d9d912dd73a507923904723cf9ca63887adb4a
-  data.tar.gz: 7f7f9d409053f873d9f7daa9b281b7c926d3b314fe5a2e7bd0814d3a7b5fdf4f8c5f61c6eed9f65a5fd4c3d11665a0efc5464164636e9affd0bac96f95d3798f
+  metadata.gz: 99cc273ca6010c9ce2c451e7a7cb3795e4b264b670fb8009436e5b9ddbaacf388e894f0922926bf92113ebf9f211636f4b4fc2a34fc01babcf848327bba798f8
+  data.tar.gz: 3686a34890b5438e5d0ca878cbb0bfb89386f2150267c73ef27754d207c6f918aad3355a312045251d3dea15fc2faa6558433f172b907ae4e913c7b60cc204f4

data/lib/kameleoon/client.rb

@@ -4,9 +4,13 @@ require 'kameleoon/targeting/models'
 require 'kameleoon/request'
 require 'kameleoon/exceptions'
 require 'kameleoon/cookie'
+require 'kameleoon/data/user_agent'
 require 'kameleoon/configuration/feature_flag'
 require 'kameleoon/configuration/variation'
 require 'kameleoon/configuration/settings'
+require 'kameleoon/network/activity_event'
+require 'kameleoon/network/experiment_event'
+require 'kameleoon/network/url_provider'
 require 'kameleoon/real_time/real_time_configuration_service'
 require 'kameleoon/storage/variation_storage'
 require 'kameleoon/hybrid/manager'
@@ -39,9 +43,8 @@ module Kameleoon
       @default_timeout = config['default_timeout'] || default_timeout # in ms
       refresh_interval = config['actions_configuration_refresh_interval']
       @interval = refresh_interval.nil? ? interval : "#{refresh_interval}m"
-      @tracking_url = config['tracking_url'] || API_SSX_URL
-      @api_data_url = 'https://api-data.kameleoon.com'
-      @events_url = 'https://events.kameleoon.com:8110/'
+      data_api_url = config['tracking_url'] || Network::UrlProvider::DEFAULT_DATA_API_URL
+      @url_provider = Network::UrlProvider.new(@site_code, data_api_url)
       @real_time_configuration_service = nil
       @update_configuration_handler = nil
       @fetch_configuration_update_job = nil
@@ -129,22 +132,22 @@ module Kameleoon
               "Experiment #{experiment_id} is not found"
       end
       check_site_code_enable(experiment)
-      if check_targeting(visitor_code, experiment_id, experiment)
+      targeted = check_targeting(visitor_code, experiment_id, experiment)
+      if targeted
         # saved_variation = get_valid_saved_variation(visitor_code, experiment)
         variation_id = calculate_variation_for_experiment(visitor_code, experiment)
-        if !variation_id.nil?
-          track_experiment(visitor_code, experiment_id, variation_id)
-          save_variation(visitor_code, experiment_id, variation_id)
-          variation_id
-        else
-          track_experiment(visitor_code, experiment_id, REFERENCE, true)
-          raise Exception::NotAllocated.new(visitor_code),
-                "Experiment #{experiment_id} is not active for visitor #{visitor_code}"
-        end
-      else
+        save_variation(visitor_code, experiment_id, variation_id)
+      end
+      _send_tracking_request(visitor_code, experiment_id, variation_id)
+      unless targeted
         raise Exception::NotTargeted.new(visitor_code),
               "Experiment #{experiment_id} is not targeted for visitor #{visitor_code}"
       end
+      if variation_id.nil?
+        raise Exception::NotAllocated.new(visitor_code),
+              "Experiment #{experiment_id} is not active for visitor #{visitor_code}"
+      end
+      variation_id
     end
 
     ##
@@ -208,7 +211,7 @@ module Kameleoon
     def flush(visitor_code = nil)
       check_visitor_code(visitor_code) unless visitor_code.nil?
       if !visitor_code.nil?
-        track_data(visitor_code)
+        _send_tracking_request(visitor_code)
       else
         @data.select { |_, values| values.any? { |data| !data.sent } }.each_key { |key| flush(key) }
       end
@@ -384,7 +387,7 @@ module Kameleoon
     end
 
     ##
-    # The get_remote_date method allows you to retrieve data (according to a key passed as argument)
+    # The get_remote_data method allows you to retrieve data (according to a key passed as argument)
     # stored on a remote Kameleoon server. Usually data will be stored on our remote
     # servers via the use of our Data API.
     # This method, along with the availability of our highly scalable servers for this purpose, provides a convenient
@@ -395,11 +398,11 @@ module Kameleoon
     # This field is optional.
     #
     # @return [Hash] Hash object of the json object.
-    def get_remote_date(key, timeout = @default_timeout)
+    def get_remote_data(key, timeout = @default_timeout)
       connexion_options = { connect_timeout: (timeout.to_f / 1000.0) }
-      path = get_api_data_request_url(key)
+      url = @url_provider.make_api_data_get_request_url(key)
       log "Retrieve API Data connexion: #{connexion_options.inspect}"
-      response = get_sync(@api_data_url + path, connexion_options)
+      response = get_sync(url, connexion_options)
       return nil unless successful_sync?(response)
 
       JSON.parse(response.body) unless response.nil?
@@ -409,7 +412,7 @@ module Kameleoon
     # DEPRECATED. Please use `get_feature_variable` instead.
     def retrieve_data_from_remote_source(key, timeout = @default_timeout)
       warn '[DEPRECATION] `retrieve_data_from_remote_source` is deprecated.  Please use `get_remote_date` instead.'
-      get_remote_date(key, timeout)
+      get_remote_data(key, timeout)
     end
 
     ##
@@ -490,7 +493,6 @@ module Kameleoon
 
     private
 
-    API_SSX_URL = 'https://api-ssx.kameleoon.com'
     REFERENCE = 0
     DEFAULT_ENVIRONMENT = 'production'
     CACHE_EXPIRATION_TIMEOUT = 5
@@ -507,7 +509,7 @@ module Kameleoon
     def fetch_configuration_job(time_stamp = nil)
       EM.synchrony do
         begin
-          ok = obtain_configuration(@site_code, @environment, time_stamp)
+          ok = obtain_configuration(@environment, time_stamp)
           if !ok && @settings.real_time_update
             @settings.real_time_update = false
             log('Switching to polling mode due to failed fetch')
@@ -540,10 +542,10 @@ module Kameleoon
     def start_real_time_configuration_service_if_needed
       return unless @real_time_configuration_service.nil?
 
-      events_url = "#{@events_url}sse?siteCode=#{@site_code}"
+      url = @url_provider.make_real_time_url
       fetch_func = proc { |real_time_event| fetch_configuration_job(real_time_event.time_stamp) }
       @real_time_configuration_service =
-        Kameleoon::RealTime::RealTimeConfigurationService.new(events_url, fetch_func, method(:log))
+        Kameleoon::RealTime::RealTimeConfigurationService.new(url, fetch_func, method(:log))
     end
 
     def stop_real_time_configuration_service_if_needed
@@ -577,12 +579,10 @@ module Kameleoon
     #   { 'field' => field, 'operator' => operator, 'parameters' => parameters }
     # end
 
-    def obtain_configuration(site_code, environment = @environment, time_stamp = nil)
+    def obtain_configuration(environment = @environment, time_stamp = nil)
       log 'Fetching configuration from Client-Config service'
-      request_path = "mobile?siteCode=#{site_code}"
-      request_path += "&environment=#{environment}" unless environment.nil?
-      request_path += "&ts=#{time_stamp}" unless time_stamp.nil?
-      request = request_configuration(request_path)
+      url = @url_provider.make_configuration_url(environment, time_stamp)
+      request = request_configuration(url)
       return false unless request
 
       configuration = JSON.parse(request.response)
@@ -616,8 +616,8 @@ module Kameleoon
       nil
     end
 
-    def request_configuration(path)
-      request = EM::Synchrony.sync get({ path: path }, CLIENT_CONFIG_URL)
+    def request_configuration(url)
+      request = EM::Synchrony.sync get({}, url)
       unless successful?(request)
         log "Failed to fetch #{request.inspect}"
         return false
@@ -625,37 +625,6 @@ module Kameleoon
       request
     end
 
-    def get_common_ssx_parameters(visitor_code)
-      {
-        nonce: Kameleoon::Utils.generate_random_string(16),
-        siteCode: @site_code,
-        visitorCode: visitor_code
-      }
-    end
-
-    def get_experiment_register_url(visitor_code, experiment_id, variation_id = nil, none_variation = false)
-      url = "/experimentTracking?#{URI.encode_www_form(get_common_ssx_parameters(visitor_code))}"
-      url += "&experimentId=#{experiment_id}"
-      return url if variation_id.nil?
-
-      url += "&variationId=#{variation_id}"
-      url += '&noneVariation=true' if none_variation
-
-      url
-    end
-
-    def get_data_register_url(visitor_code)
-      "/dataTracking?#{URI.encode_www_form(get_common_ssx_parameters(visitor_code))}"
-    end
-
-    def get_api_data_request_url(key)
-      mapKey = {
-        siteCode: site_code,
-        key: key
-      }
-      "/data?#{URI.encode_www_form(mapKey)}"
-    end
-
     def find_feature_flag(feature_key)
       if feature_key.is_a?(String)
         feature_flag = @feature_flags.select { |ff| ff.feature_key == feature_key }.first
@@ -669,67 +638,6 @@ module Kameleoon
       feature_flag
     end
 
-    def track_experiment(visitor_code, experiment_id, variation_id = nil, none_variation: false)
-      data_not_sent = data_not_sent(visitor_code)
-      options = {
-        path: get_experiment_register_url(visitor_code, experiment_id, variation_id, none_variation),
-        body: (data_not_sent.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8'),
-        head: { 'Content-Type': 'text/plain' }
-      }
-      set_user_agent_to_headers(visitor_code, options[:head])
-      trial = 0
-      success = false
-      log "Start post tracking experiment: #{data_not_sent.inspect}"
-      Thread.new do
-        while trial < 10
-          log "Send Experiment Tracking #{options.inspect}"
-          response = post_sync(options, @tracking_url)
-          log "Response #{response.inspect}"
-          if successful_sync?(response)
-            data_not_sent.each { |it| it.sent = true }
-            success = true
-            break
-          end
-          trial += 1
-        end
-        if success
-          log "Post to experiment tracking is done after #{trial + 1} trials"
-        else
-          log "Post to experiment tracking is failed after #{trial} trials"
-        end
-      end
-    end
-
-    def track_data(visitor_code)
-      Thread.new do
-        trials = 0
-        data_not_sent = data_not_sent(visitor_code)
-        log "Start post tracking data: #{data_not_sent.inspect}"
-        while trials < 10 && !data_not_sent.empty?
-          options = {
-            path: get_data_register_url(visitor_code),
-            body: (data_not_sent.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8'),
-            head: { 'Content-Type': 'text/plain' }
-          }
-          set_user_agent_to_headers(visitor_code, options[:head])
-          log "Post tracking data for visitor_code: #{visitor_code} with options: #{options.inspect}"
-          response = post_sync(options, @tracking_url)
-          log "Response #{response.inspect}"
-          if successful_sync?(response)
-            data_not_sent.each { |it| it.sent = true }
-            success = true
-            break
-          end
-          trials += 1
-        end
-        if success
-          log "Post to data tracking is done after #{trials + 1} trials"
-        else
-          log "Post to data tracking is failed after #{trials} trials"
-        end
-      end
-    end
-
     def check_site_code_enable(campaign)
       raise Exception::SiteCodeDisabled.new(site_code), site_code unless campaign.site_enabled
     end
@@ -770,8 +678,17 @@ module Kameleoon
     def get_condition_data(type, visitor_code, campaign_id)
       condition_data = nil
       case type
-      when Kameleoon::Targeting::ConditionType::CUSTOM_DATUM
+      when Kameleoon::Targeting::ConditionType::CUSTOM_DATUM,
+           Kameleoon::Targeting::ConditionType::PAGE_TITLE,
+           Kameleoon::Targeting::ConditionType::PAGE_URL,
+           Kameleoon::Targeting::ConditionType::DEVICE_TYPE,
+           Kameleoon::Targeting::ConditionType::BROWSER,
+           Kameleoon::Targeting::ConditionType::CONVERSIONS
         condition_data = (@data[visitor_code] || []).flatten
+      when Kameleoon::Targeting::ConditionType::SDK_LANGUAGE
+        condition_data = Kameleoon::Targeting::SdkInfo.new(Kameleoon::SDK_NAME, Kameleoon::SDK_VERSION)
+      when Kameleoon::Targeting::ConditionType::VISITOR_CODE
+        condition_data = visitor_code
       when Kameleoon::Targeting::ConditionType::TARGET_EXPERIMENT
         condition_data = @variation_storage.get_hash_saved_variation_id(visitor_code)
       when Kameleoon::Targeting::ConditionType::EXCLUSIVE_EXPERIMENT
@@ -790,10 +707,11 @@ module Kameleoon
       variation, rule = _calculate_variation_key_for_feature(visitor_code, feature_flag)
       variation_key = _get_variation_key(variation, rule, feature_flag)
       unless rule.nil?
-        save_variation(visitor_code, rule.experiment_id, variation.variation_id) unless variation.nil?
+        experiment_id = rule.experiment_id
         variation_id = variation.variation_id unless variation.nil?
-        _send_tracking_request(visitor_code, rule.experiment_id, variation_id)
+        save_variation(visitor_code, experiment_id, variation_id)
       end
+      _send_tracking_request(visitor_code, experiment_id, variation_id)
       [feature_flag, variation_key]
     end
 
@@ -809,11 +727,12 @@ module Kameleoon
         hash_rule = obtain_hash_double_rule(visitor_code, rule.id, rule.respool_time)
         # check main expostion for rule with hashRule
         if hash_rule <= rule.exposition
+          return [rule.variation_by_exposition[0], rule] if rule.targeted_delivery_type?
+
           # uses for variation's expositions
           hash_variation = obtain_hash_double_rule(visitor_code, rule.experiment_id, rule.respool_time)
           # get variation key with new hashVariation
           variation = rule.get_variation(hash_variation)
-          # variation_key can be nil for experiment rules only, for targeted rule will be always exist
           return [variation, rule] unless variation.nil?
         # if visitor is targeted for targeted rule then break cycle -> return default
         elsif rule.targeted_delivery_type?
@@ -833,19 +752,46 @@ module Kameleoon
     def _get_variation_key(var_by_exp, rule, feature_flag)
       return var_by_exp.variation_key unless var_by_exp.nil?
 
-      return Kameleoon::Configuration::VariationType::VARIATION_OFF if !rule.nil? && rule.experiment_type?
+      return Kameleoon::Configuration::VariationType::VARIATION_OFF if !rule.nil? && rule.experimentation_type?
 
       feature_flag.default_variation_key
     end
 
     ##
     # helper method for sending tracking requests for new FF
-    def _send_tracking_request(visitor_code, experiment_id, variation_id)
-      if !experiment_id.nil?
-        variation_reference_id = variation_id || 0
-        track_experiment(visitor_code, experiment_id, variation_reference_id)
+    def _send_tracking_request(visitor_code, experiment_id = nil, variation_id = nil)
+      data_not_sent = data_not_sent(visitor_code)
+      if experiment_id.nil? || variation_id.nil?
+        data_not_sent.append(Network::ActivityEvent.new) if data_not_sent.empty?
       else
-        log 'An attempt to send a request with null experimentId was blocked'
+        data_not_sent.append(Network::ExperimentEvent.new(experiment_id, variation_id))
+      end
+      options = {
+        body: (data_not_sent.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8'),
+        head: { 'Content-Type': 'text/plain' }
+      }
+      set_user_agent_to_headers(visitor_code, options[:head])
+      url = @url_provider.make_tracking_url(visitor_code)
+      trial = 0
+      success = false
+      log "Start post tracking: #{data_not_sent.inspect}"
+      Thread.new do
+        while trial < 10
+          log "Send tracking #{options.inspect}"
+          response = post_sync(options, url)
+          log "Response #{response.inspect}"
+          if successful_sync?(response)
+            data_not_sent.each { |it| it.sent = true }
+            success = true
+            break
+          end
+          trial += 1
+        end
+        if success
+          log "Post to tracking is done after #{trial + 1} trials"
+        else
+          log "Post to tracking is failed after #{trial} trials"
+        end
       end
     end
 

data/lib/kameleoon/configuration/rule.rb

@@ -45,7 +45,7 @@ module Kameleoon
         variation_by_exposition.select { |v| v.variation_key == key }.first&.variation_id
       end
 
-      def experiment_type?
+      def experimentation_type?
         @type == RuleType::EXPERIMENTATION
       end
 

data/lib/kameleoon/data/browser.rb

@@ -0,0 +1,33 @@
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  module BrowserType
+    CHROME = 0
+    INTERNET_EXPLORER = 1
+    FIREFOX = 2
+    SAFARI = 3
+    OPERA = 4
+    OTHER = 5
+  end
+
+  # Represents browser data for tracking calls
+  class Browser < Data
+    attr_reader :type, :version
+
+    # @param [BrowserType] browser_type Browser type, can be: CHROME, INTERNET_EXPLORER, FIREFOX, SAFARI, OPERA, OTHER
+    # @param [float] version Version of browser
+    def initialize(browser_type, version = Float::NAN)
+      super(DataType::BROWSER)
+      @type = browser_type
+      @version = version
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      url = "eventType=staticData&browserIndex=#{@type}&nonce=#{nonce}"
+      url.concat("&browserVersion=#{@version}") if @version.is_a?(Integer) || (@version.is_a?(Float) && !@version.nan?)
+      url
+    end
+  end
+end

data/lib/kameleoon/data/conversion.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  # Conversion class uses for tracking conversion
+  class Conversion < Data
+    attr_reader :goal_id, :revenue, :negative
+
+    # @param [Integer] goal_id Id of the goal associated to the conversion
+    # @param [Float] revenue Optional field - Revenue associated to the conversion.
+    # @param [Boolean] negative Optional field - If the revenue is negative. By default it's positive.
+    def initialize(goal_id, revenue = 0.0, negative = false)
+      super(DataType::CONVERSION)
+      @goal_id = goal_id
+      @revenue = revenue || 0.0
+      @negative = negative || false
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=conversion&goalId=#{@goal_id}&revenue=#{@revenue}&negative=#{@negative}&nonce=#{nonce}"
+    end
+  end
+end

data/lib/kameleoon/data/custom_data.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  # Represents any custom data for targeting conditions
+  class CustomData < Data
+    attr_reader :id, :values
+
+    # @param [Integer] id Id of the custom data
+    # @param [String] value Value of the custom data
+    # @param [Array] values Array of values of the custom data
+    #
+    # @overload
+    # @param [Hash] hash Json value encoded in a hash.
+    # rubocop:disable Metrics/MethodLength
+    def initialize(arg0, *args)
+      super(DataType::CUSTOM)
+      if arg0.is_a?(Hash)
+        hash = arg0
+        id = hash['id']
+        raise Kameleoon::Exception::NotFound.new('id'), '"id" is mandatory' if id.nil?
+
+        @id = id.to_s
+        value = hash['value']
+        values = hash['values']
+        if values.nil? && value.nil?
+          raise Kameleoon::Exception::NotFound.new('value or values'), '"value" or "values" is mandatory'
+        end
+
+        if values.nil?
+          @values = [value]
+        else
+          @values = values.is_a?(Array) ? values.dup : [values]
+          @values.append(value) unless value.nil?
+        end
+      else
+        @id = arg0.to_s
+        @values = args
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def obtain_full_post_text_line
+      return '' if @values.empty?
+
+      str_values = JSON.generate(Hash[@values.collect { |k| [k, 1] }])
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=customData&index=#{@id}&valuesCountMap=#{self.class.encode(str_values)}&overwrite=true&nonce=#{nonce}"
+    end
+  end
+end

data/lib/kameleoon/data/data.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'kameleoon/exceptions'
+
+module Kameleoon
+  NONCE_LENGTH = 16
+
+  module DataType
+    CUSTOM = 'CUSTOM'
+    BROWSER = 'BROWSER'
+    CONVERSION = 'CONVERSION'
+    DEVICE = 'DEVICE'
+    PAGE_VIEW = 'PAGE_VIEW'
+  end
+
+  # Represents base class for any Kameleoon data
+  class Data
+    attr_reader :instance
+    attr_accessor :sent
+
+    def initialize(data_type)
+      @instance = data_type
+      @sent = false
+    end
+
+    def obtain_full_post_text_line
+      raise KameleoonError.new('ToDo: implement this method.'), 'ToDo: implement this method.'
+    end
+
+    def self.encode(url)
+      Network::UriHelper.encode_uri(url)
+    end
+  end
+end

data/lib/kameleoon/data/device.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  module DeviceType
+    PHONE = 'PHONE'
+    TABLET = 'TABLET'
+    DESKTOP = 'DESKTOP'
+  end
+
+  # Device uses for sending deviceType parameter for tracking calls
+  class Device < Data
+    attr_reader :device_type
+    def initialize(device_type)
+      super(DataType::DEVICE)
+      @device_type = device_type
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      "eventType=staticData&deviceType=#{@device_type}&nonce=#{nonce}"
+    end
+  end
+end

data/lib/kameleoon/data/page_view.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'data'
+
+module Kameleoon
+  # Represents page view data for tracking calls
+  class PageView < Data
+    attr_reader :url, :title, :referrer
+
+    # @param [String] url Url of the page
+    # @param [String] title Title of the page
+    # @param [Array] referrers Optional field - Referrer ids
+    def initialize(url, title, referrers = nil)
+      super(DataType::PAGE_VIEW)
+      @url = url || ''
+      @title = title || ''
+      @referrers = referrers.instance_of?(Integer) ? [referrers] : referrers
+    end
+
+    def obtain_full_post_text_line
+      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+      referrer_text = if !@referrers.nil? && !@referrers.empty?
+                        "&referrersIndices=%5B#{@referrers.each(&:to_s).join('%2C')}%5D"
+                      else
+                        ''
+                      end
+      "eventType=page&href=#{self.class.encode(@url)}&title=#{self.class.encode(@title)}#{referrer_text}&nonce=#{nonce}"
+    end
+  end
+end

data/lib/kameleoon/data/user_agent.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kameleoon
+  # UserAgent uses for changing User-Agent header for tracking calls
+  class UserAgent
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+  end
+end

data/lib/kameleoon/network/activity_event.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'kameleoon/data/data'
+require 'kameleoon/utils'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  module Network
+    ##
+    # ActivityEvent represents an activity tracking event.
+    class ActivityEvent
+      EVENT_TYPE = 'activity'
+
+      attr_accessor :sent
+
+      def initialize
+        @sent = false
+        @nonce = Kameleoon::Utils.generate_random_string(Kameleoon::NONCE_LENGTH)
+      end
+
+      def obtain_full_post_text_line
+        params = {
+          eventType: EVENT_TYPE,
+          nonce: @nonce
+        }
+        UriHelper.encode_query(params)
+      end
+    end
+  end
+end

data/lib/kameleoon/network/experiment_event.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'kameleoon/data/data'
+require 'kameleoon/utils'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  module Network
+    ##
+    # ExperimentEvent represents an experiment tracking event.
+    class ExperimentEvent
+      EVENT_TYPE = 'experiment'
+
+      attr_accessor :sent
+
+      def initialize(experiment_id, variation_id)
+        @sent = false
+        @experiment_id = experiment_id
+        @variation_id = variation_id
+        @nonce = Kameleoon::Utils.generate_random_string(Kameleoon::NONCE_LENGTH)
+      end
+
+      def obtain_full_post_text_line
+        params = {
+          eventType: EVENT_TYPE,
+          id: @experiment_id,
+          variationId: @variation_id,
+          nonce: @nonce
+        }
+        UriHelper.encode_query(params)
+      end
+    end
+  end
+end