kameleoon-client-ruby 2.3.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d51a71ea79cd23f422a5235fce6f2e3fb94cae538b01222dd4c23b770985e59
-  data.tar.gz: 29f2501a20ffedf1637ee6d441b637358982761955d6235317f49b5284f17b70
+  metadata.gz: 4f1490fd854e391fea3b908cad394e328a3540b6368942b72c1a9979c9002b87
+  data.tar.gz: 3abf894648cd3662a1a3a3453254014fa20c5405af28f6e01c8e336c810c6031
 SHA512:
-  metadata.gz: 7f4855238a2e8731458757336bc964a36d537e77e7e1b30eb73b5c7e270ee59ee021813b620c0997b9781a8e062b10f3a4797eaceffcd9ca731e5e86f11f1e12
-  data.tar.gz: e7d3659d4de54bc0be3aadf6ed96d213bf148ce481306ad8668b589dd892a26a74e78206c6d78dd9577c915e96bab1351c19f08c95ce8b4ae85aaef237b6bd6f
+  metadata.gz: 76f8eb07daaf102c292c9ed04a6d788dfcef4a7cf757875603a68d2a1272b8e543dbfabd89226a6f775cd71d243998b8b897e6339c616d0a87b03624054720e3
+  data.tar.gz: d8f94272a6afa522a6ea5c48e3c0f9b91fec6bd1b2382e0ff2a9a94cfbdfb3c23d9f278a5bf143d4161a05cff385ad335d278a5634e8f3a23f4f63373c6da281

data/lib/kameleoon/client_readiness.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module Kameleoon
+  class ClientReadiness
+    attr_reader :is_initializing, :success
+
+    def initialize
+      @is_initializing = false
+      @success = false
+      @condition = Concurrent::ReadWriteLock.new
+      reset
+    end
+
+    def reset
+      @success = false
+      unless @is_initializing
+        @is_initializing = true
+        @condition.acquire_write_lock
+      end
+    end
+
+    def set(success)
+      @success = success
+      if @is_initializing
+        @condition.release_write_lock
+        @is_initializing = false
+      end
+    end
+
+    def wait
+      if @is_initializing
+        @condition.acquire_read_lock
+        @condition.release_read_lock
+      end
+      @success
+    end
+  end
+end

data/lib/kameleoon/configuration/data_file.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'kameleoon/configuration/settings'
+
+module Kameleoon
+  module Configuration
+    class DataFile
+      attr_reader :settings, :feature_flags, :has_any_targeted_delivery_rule
+
+      def initialize(environment)
+        @settings = Settings.new
+        @feature_flags = {}
+        @environment = environment
+      end
+
+      def init(configuration)
+        @settings.update(configuration['configuration'])
+        configuration['featureFlags'].each do |raw|
+          ff = FeatureFlag.new(raw)
+          @feature_flags[ff.feature_key] = ff
+        end
+        @has_any_targeted_delivery_rule = any_targeted_delivery_rule?
+        self
+      end
+
+      def get_feature_flag(feature_key)
+        ff = @feature_flags[feature_key]
+        raise Exception::FeatureNotFound, feature_key if ff.nil?
+        raise Exception::FeatureEnvironmentDisabled.new(feature_key, @environment) unless ff.environment_enabled
+
+        ff
+      end
+
+      private
+
+      def any_targeted_delivery_rule?
+        @feature_flags.any? { |_, ff| ff.environment_enabled && ff.rules.any?(&:targeted_delivery_type?) }
+      end
+    end
+  end
+end

data/lib/kameleoon/configuration/feature_flag.rb

@@ -8,7 +8,7 @@ module Kameleoon
   module Configuration
     # Class for manage all feature flags with rules
     class FeatureFlag
-      attr_accessor :id, :feature_key, :variations, :default_variation_key, :rules
+      attr_accessor :id, :feature_key, :variations, :default_variation_key, :environment_enabled, :rules
 
       def self.create_from_array(array)
         array&.map { |it| FeatureFlag.new(it) }
@@ -17,8 +17,9 @@ module Kameleoon
       def initialize(hash)
         @id = hash['id']
         @feature_key = hash['featureKey']
-        @default_variation_key = hash['defaultVariationKey']
         @variations = Variation.create_from_array(hash['variations'])
+        @default_variation_key = hash['defaultVariationKey']
+        @environment_enabled = hash['environmentEnabled']
         @rules = Rule.create_from_array(hash['rules'])
       end
 

data/lib/kameleoon/configuration/rule.rb

@@ -8,8 +8,23 @@ module Kameleoon
   module Configuration
     # RuleType has a possible rule types
     module RuleType
-      EXPERIMENTATION = 'EXPERIMENTATION'
-      TARGETED_DELIVERY = 'TARGETED_DELIVERY'
+      UNKNOWN = 0
+      EXPERIMENTATION = 1
+      TARGETED_DELIVERY = 2
+
+      EXPERIMENTATION_LITERAL = 'EXPERIMENTATION'
+      TARGETED_DELIVERY_LITERAL = 'TARGETED_DELIVERY'
+
+      def self.from_literal(literal)
+        case literal
+        when EXPERIMENTATION_LITERAL
+          EXPERIMENTATION
+        when TARGETED_DELIVERY_LITERAL
+          TARGETED_DELIVERY
+        else
+          UNKNOWN
+        end
+      end
     end
 
     # Rule is a class for new rules of feature flags
@@ -24,7 +39,7 @@ module Kameleoon
       def initialize(hash)
         @id = hash['id']
         @order = hash['order']
-        @type = hash['type']
+        @type = RuleType.from_literal(hash['type'])
         @exposition = hash['exposition']
         @experiment_id = hash['experimentId']
         @respool_time = hash['respoolTime']

data/lib/kameleoon/configuration/settings.rb

@@ -7,13 +7,18 @@ module Kameleoon
     # state of real time update for site code and etc
     class Settings
       attr_accessor :real_time_update
+      attr_reader :is_consent_required, :data_api_domain
 
       def initialize
         @real_time_update = false
+        @is_consent_required = false
+        @data_api_domain = nil
       end
 
       def update(configuration)
         @real_time_update = configuration['realTimeUpdate'] || false
+        @is_consent_required = configuration['consentType'] == 'REQUIRED'
+        @data_api_domain = configuration['dataApiDomain']
       end
     end
   end

data/lib/kameleoon/configuration/variable.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'experiment'
-
 module Kameleoon
   # Module which contains all internal data of SDK
   module Configuration

data/lib/kameleoon/configuration/variation_exposition.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'experiment'
-
 module Kameleoon
   # Module which contains all internal data of SDK
   module Configuration

data/lib/kameleoon/data/browser.rb

@@ -15,7 +15,7 @@ module Kameleoon
   end
 
   # Represents browser data for tracking calls
-  class Browser < Data
+  class Browser < DuplicationUnsafeData
     attr_reader :type, :version
 
     # @param [BrowserType] browser_type Browser type, can be: CHROME, INTERNET_EXPLORER, FIREFOX, SAFARI, OPERA, OTHER

data/lib/kameleoon/data/conversion.rb

@@ -6,7 +6,7 @@ require_relative 'data'
 
 module Kameleoon
   # Conversion class uses for tracking conversion
-  class Conversion < Data
+  class Conversion < DuplicationSafeData
     attr_reader :goal_id, :revenue, :negative
 
     # @param [Integer] goal_id Id of the goal associated to the conversion

data/lib/kameleoon/data/custom_data.rb

@@ -6,7 +6,7 @@ require_relative 'data'
 
 module Kameleoon
   # Represents any custom data for targeting conditions
-  class CustomData < Data
+  class CustomData < DuplicationUnsafeData
     attr_reader :id, :values
 
     # @param [Integer] id Id of the custom data
@@ -23,23 +23,19 @@ module Kameleoon
         id = hash['id']
         raise Kameleoon::Exception::NotFound.new('id'), '"id" is mandatory' if id.nil?
 
-        @id = id.to_s
-        value = hash['value']
+        @id = id
         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
+        raise Kameleoon::Exception::NotFound.new('values'), '"values" is mandatory' if values.nil?
+
+        @values = values.is_a?(Array) ? values.dup : [values]
       else
-        @id = arg0.to_s
+        @id = arg0
         @values = args
       end
+      return if @id.is_a?(Integer)
+
+      warn "CustomData field 'id' must be of 'Integer' type"
+      @id = @id.is_a?(String) ? @id.to_i : -1
     end
     # rubocop:enable Metrics/MethodLength
 

data/lib/kameleoon/data/data.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 require 'kameleoon/exceptions'
+require 'kameleoon/utils'
 
 module Kameleoon
   NONCE_LENGTH = 16
@@ -12,12 +13,12 @@ module Kameleoon
     CONVERSION = 'CONVERSION'
     DEVICE = 'DEVICE'
     PAGE_VIEW = 'PAGE_VIEW'
+    ASSIGNED_VARIATION = 'ASSIGNED_VARIATION'
   end
 
   # Represents base class for any Kameleoon data
   class Data
-    attr_reader :instance
-    attr_accessor :sent
+    attr_reader :instance, :sent
 
     def initialize(data_type)
       @instance = data_type
@@ -28,10 +29,28 @@ module Kameleoon
       raise KameleoonError.new('ToDo: implement this method.'), 'ToDo: implement this method.'
     end
 
+    def mark_as_sent
+      @sent = true
+      @nonce = nil
+    end
+  end
+
+  class DuplicationSafeData < Data
+    def initialize(data_type)
+      super(data_type)
+      @nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
+    end
+
+    private
+
+    attr_reader :nonce
+  end
+
+  class DuplicationUnsafeData < Data
     private
 
     def nonce
-      @nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH) if @nonce.nil?
+      @nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH) if !@sent && @nonce.nil?
       @nonce
     end
   end

data/lib/kameleoon/data/device.rb

@@ -12,8 +12,9 @@ module Kameleoon
   end
 
   # Device uses for sending deviceType parameter for tracking calls
-  class Device < Data
+  class Device < DuplicationUnsafeData
     attr_reader :device_type
+
     def initialize(device_type)
       super(DataType::DEVICE)
       @device_type = device_type

data/lib/kameleoon/data/manager/assigned_variation.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/data'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  module DataManager
+    ##
+    # AssignedVariation represents a variation assigned to a visitor.
+    class AssignedVariation < DuplicationUnsafeData
+      EVENT_TYPE = 'experiment'
+
+      attr_reader :experiment_id, :variation_id, :rule_type, :assignment_time
+
+      def initialize(experiment_id, variation_id, rule_type, assignment_time: nil)
+        super(DataType::ASSIGNED_VARIATION)
+        @experiment_id = experiment_id
+        @variation_id = variation_id
+        @rule_type = rule_type
+        @assignment_time = assignment_time || Time.new.to_i
+      end
+
+      def obtain_full_post_text_line
+        params = {
+          eventType: EVENT_TYPE,
+          id: @experiment_id,
+          variationId: @variation_id,
+          nonce: nonce
+        }
+        Kameleoon::Network::UriHelper.encode_query(params)
+      end
+
+      def valid?(respool_time)
+        respool_time.nil? || (@assignment_time >= respool_time)
+      end
+    end
+  end
+end

data/lib/kameleoon/data/manager/data_array_storage.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module DataManager
+    ##
+    # DataArrayStorage is a readonly accessor to a sequntial storage of specific visitor data.
+    # It is thread-safe
+    class DataArrayStorage
+      def initialize(mutex, array)
+        @mutex = mutex
+        @array = array
+      end
+
+      def enumerate(&blk)
+        return if @array.nil?
+
+        @mutex.with_read_lock do
+          @array.each { |v| blk.call(v) }
+        end
+      end
+
+      def last
+        return nil if @array.nil?
+
+        value = nil
+        @mutex.with_read_lock do
+          value = @array.last
+        end
+        value
+      end
+
+      def size
+        return 0 if @array.nil?
+
+        value = nil
+        @mutex.with_read_lock do
+          value = @array.size
+        end
+        value
+      end
+    end
+  end
+end

data/lib/kameleoon/data/manager/data_map_storage.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module DataManager
+    ##
+    # DataMapStorage is a readonly accessor to a key-value based storage of specific visitor data.
+    # It is thread-safe
+    class DataMapStorage
+      def initialize(mutex, map)
+        @mutex = mutex
+        @map = map
+      end
+
+      def enumerate(&blk)
+        return if @map.nil?
+
+        @mutex.with_read_lock do
+          @map.each { |_k, v| blk.call(v) }
+        end
+      end
+
+      def get(key)
+        return nil if @map.nil?
+
+        value = nil
+        @mutex.with_read_lock do
+          value = @map[key]
+        end
+        value
+      end
+
+      def size
+        return 0 if @map.nil?
+
+        value = nil
+        @mutex.with_read_lock do
+          value = @map.size
+        end
+        value
+      end
+    end
+  end
+end

data/lib/kameleoon/data/manager/page_view_visit.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module DataManager
+    class PageViewVisit
+      attr_reader :page_view, :count
+
+      def initialize(page_view, count = 1)
+        @page_view = page_view
+        @count = count
+      end
+
+      def overwrite(page_view)
+        @page_view = page_view
+        @count += 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'kameleoon/data/browser'
+require 'kameleoon/data/conversion'
+require 'kameleoon/data/custom_data'
+require 'kameleoon/data/device'
+require 'kameleoon/data/page_view'
+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'
+
+module Kameleoon
+  module DataManager
+    ##
+    # 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
+      attr_accessor :legal_consent
+
+      def initialize
+        @mutex = Concurrent::ReadWriteLock.new
+        @legal_consent = false
+        update_last_activity_time
+      end
+
+      def update_last_activity_time
+        @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?
+        @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
+        count = 0
+        @mutex.with_read_lock do
+          count += 1 unless @device.nil?
+          count += 1 unless @browser.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
+      end
+
+      def custom_data
+        DataMapStorage.new(@mutex, @custom_data_map)
+      end
+
+      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 add_data(log_func, *args)
+        @mutex.with_write_lock do
+          args.each do |data|
+            case data
+            when Kameleoon::UserAgent
+              add_user_agent(data)
+            when Kameleoon::Device
+              add_device(data)
+            when Kameleoon::Browser
+              add_browser(data)
+            when Kameleoon::CustomData
+              add_custom_data(data)
+            when Kameleoon::PageView
+              add_page_view(data)
+            when Kameleoon::Conversion
+              add_conversion(data)
+            else
+              log_func&.call("Data has unsupported type '#{data.class}'")
+            end
+          end
+        end
+      end
+
+      def assign_variation(variation)
+        @mutex.with_write_lock do
+          @variations = {} if @variations.nil?
+          @variations[variation.experiment_id] = variation
+        end
+      end
+
+      private
+
+      def add_user_agent(user_agent)
+        @user_agent = user_agent.value
+      end
+
+      def add_device(device)
+        @device = device
+      end
+
+      def add_browser(browser)
+        @browser = browser
+      end
+
+      def add_custom_data(custom_data)
+        @custom_data_map = {} if @custom_data_map.nil?
+        @custom_data_map[custom_data.id] = custom_data
+      end
+
+      def add_page_view(page_view)
+        return if page_view.url.nil? || page_view.url.empty?
+
+        @page_view_visits = {} if @page_view_visits.nil?
+        visit = @page_view_visits[page_view.url]
+        if visit.nil?
+          visit = DataManager::PageViewVisit.new(page_view)
+        else
+          visit.overwrite(page_view)
+        end
+        @page_view_visits[page_view.url] = visit
+      end
+
+      def add_conversion(conversion)
+        @conversions = [] if @conversions.nil?
+        @conversions.push(conversion)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'rufus/scheduler'
+require 'kameleoon/data/manager/visitor'
+
+module Kameleoon
+  module DataManager
+    ##
+    # VisitorManager stores Visitor instances and manages visitor sessions.
+    # It is thread-safe except `stop` method
+    class VisitorManager
+      attr_reader :expiration_period
+
+      def initialize(expiration_period)
+        @expiration_period = expiration_period
+        @visitors = Concurrent::Map.new
+        start
+      end
+
+      def stop
+        return if @purge_job.nil?
+
+        @purge_job.unschedule
+        @purge_job = nil
+      end
+
+      def get_visitor(visitor_code)
+        @visitors.compute_if_present(visitor_code) do |visitor|
+          visitor.update_last_activity_time
+          visitor
+        end
+      end
+
+      def get_or_create_visitor(visitor_code)
+        @visitors.compute(visitor_code) do |former_v|
+          next DataManager::Visitor.new if former_v.nil?
+
+          former_v.update_last_activity_time
+          former_v
+        end
+      end
+
+      def enumerate(&blk)
+        @visitors.each_pair { |vc, v| blk.call(vc, v) }
+      end
+
+      def size
+        @visitors.size
+      end
+
+      private
+
+      def 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
+      end
+
+      def start
+        stop unless @purge_job.nil?
+        @purge_job = Rufus::Scheduler.singleton.schedule_every @expiration_period do
+          purge
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/data/page_view.rb

@@ -6,7 +6,7 @@ require_relative 'data'
 
 module Kameleoon
   # Represents page view data for tracking calls
-  class PageView < Data
+  class PageView < DuplicationSafeData
     attr_reader :url, :title, :referrer
 
     # @param [String] url Url of the page
@@ -15,6 +15,7 @@ module Kameleoon
     def initialize(url, title, referrers = nil)
       super(DataType::PAGE_VIEW)
       @url = url || ''
+      print('Kameleoon SDK: Url for PageView is required parameter, the data will be ignored.') if url == ''
       @title = title || ''
       @referrers = referrers.instance_of?(Integer) ? [referrers] : referrers
     end