kameleoon-client-ruby 2.2.0 → 3.0.0

data/lib/kameleoon/kameleoon_client_config.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  # KameleoonClient configuration which can be used instead of an external configuration file
+  class KameleoonClientConfig
+    DEFAULT_REFRESH_INTERVAL_MINUTES = 60
+    DEFAULT_SESSION_DURATION_MINUTES = 30
+    DEFAULT_TIMEOUT_MILLISECONDS = 10_000
+
+    attr_reader :client_id, :client_secret, :refresh_interval_second, :session_duration_second,
+                :default_timeout_millisecond, :environment, :top_level_domain, :verbose_mode
+
+    def initialize(
+      client_id,
+      client_secret,
+      refresh_interval_minute: DEFAULT_REFRESH_INTERVAL_MINUTES,
+      session_duration_minute: DEFAULT_SESSION_DURATION_MINUTES,
+      default_timeout_millisecond: DEFAULT_TIMEOUT_MILLISECONDS,
+      environment: nil,
+      top_level_domain: nil,
+      verbose_mode: false
+    )
+      raise Exception::ConfigCredentialsInvalid, 'Client ID is not specified' if client_id&.empty? != false
+      raise Exception::ConfigCredentialsInvalid, 'Client secret is not specified' if client_secret&.empty? != false
+
+      @verbose_mode = verbose_mode || false
+
+      @client_id = client_id
+      @client_secret = client_secret
+
+      if refresh_interval_minute.nil?
+        refresh_interval_minute = DEFAULT_REFRESH_INTERVAL_MINUTES
+      elsif refresh_interval_minute <= 0
+        log('Configuration refresh interval must have positive value. ' \
+          "Default refresh interval (#{DEFAULT_REFRESH_INTERVAL_MINUTES} minutes) is applied.")
+        refresh_interval_minute = DEFAULT_REFRESH_INTERVAL_MINUTES
+      end
+      @refresh_interval_second = refresh_interval_minute * 60
+
+      if session_duration_minute.nil?
+        session_duration_minute = DEFAULT_SESSION_DURATION_MINUTES
+      elsif session_duration_minute <= 0
+        log('Session duration must have positive value. ' \
+          "Default session duration (#{DEFAULT_SESSION_DURATION_MINUTES} minutes) is applied.")
+        session_duration_minute = DEFAULT_SESSION_DURATION_MINUTES
+      end
+      @session_duration_second = session_duration_minute * 60
+
+      if default_timeout_millisecond.nil?
+        @default_timeout_millisecond = DEFAULT_TIMEOUT_MILLISECONDS
+      elsif default_timeout_millisecond <= 0
+        log('Default timeout must have positive value. ' \
+          "Default timeout (#{DEFAULT_TIMEOUT_MILLISECONDS} ms) is applied.")
+        @default_timeout_millisecond = DEFAULT_TIMEOUT_MILLISECONDS
+      else
+        @default_timeout_millisecond = default_timeout_millisecond
+      end
+
+      @environment = environment
+
+      if top_level_domain.nil?
+        log('Setting top level domain is strictly recommended, otherwise you may have problems when using subdomains.')
+      end
+      @top_level_domain = top_level_domain
+    end
+
+    def self.read_from_yaml(path)
+      yaml = YAML.load_file(path) if File.exist?(path)
+      if yaml.nil?
+        warn "Kameleoon SDK: Configuration file with path #{path} does not exist"
+        yaml = {}
+      end
+      KameleoonClientConfig.new(
+        yaml['client_id'],
+        yaml['client_secret'],
+        refresh_interval_minute: yaml['refresh_interval_minute'],
+        session_duration_minute: yaml['session_duration_minute'],
+        default_timeout_millisecond: yaml['default_timeout_millisecond'],
+        environment: yaml['environment'],
+        top_level_domain: yaml['top_level_domain'],
+        verbose_mode: yaml['verbose_mode']
+      )
+    end
+
+    private
+
+    def log(text)
+      print "Kameleoon SDK Log: #{text}\n" if @verbose_mode
+    end
+  end
+end

data/lib/kameleoon/kameleoon_client_factory.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require 'kameleoon/kameleoon_client'
+require 'kameleoon/kameleoon_client_config'
+
+module Kameleoon
+  # A Factory class for creating kameleoon clients
+  module KameleoonClientFactory
+    CONFIG_PATH = '/etc/kameleoon/client-ruby.yaml'
+
+    @clients = Concurrent::Map.new
+
+    def self.create(site_code, config: nil, config_path: CONFIG_PATH)
+      unless config.is_a?(KameleoonClientConfig)
+        config_path = CONFIG_PATH unless config_path.is_a?(String)
+        config = KameleoonClientConfig.read_from_yaml(config_path)
+      end
+      key = get_client_key(site_code, config.environment)
+      @clients.compute_if_absent(key) do
+        client = KameleoonClient.new(site_code, config)
+        client.send(:log, "Client created with site code: #{site_code}")
+        client.send(:fetch_configuration_initially)
+        client
+      end
+    end
+
+    def self.forget(site_code, environment = nil)
+      key = get_client_key(site_code, environment)
+      @clients.compute_if_present(key) do |client|
+        client.send(:dispose)
+        nil
+      end
+    end
+
+    private_class_method
+
+    def self.get_client_key(site_code, environment)
+      environment.nil? ? site_code : "#{site_code}/#{environment}"
+    end
+  end
+end

data/lib/kameleoon/network/activity_event.rb

@@ -12,20 +12,23 @@ module Kameleoon
     class ActivityEvent
       EVENT_TYPE = 'activity'
 
-      attr_accessor :sent
+      attr_reader :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
+          nonce: Kameleoon::Utils.generate_random_string(Kameleoon::NONCE_LENGTH)
         }
         UriHelper.encode_query(params)
       end
+
+      def mark_as_sent
+        @sent = true
+      end
     end
   end
 end

data/lib/kameleoon/network/cookie/cookie_manager.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'kameleoon/utils'
+
+module Kameleoon
+  module Network
+    module Cookie
+      COOKIE_KEY_JS = '_js_'
+      VISITOR_CODE_COOKIE = 'kameleoonVisitorCode'
+      COOKIE_TTL_SECONDS = 380 * 86_400 # 380 days in seconds
+
+      class CookieManager
+        attr_accessor :consent_required
+
+        def initialize(top_level_domain)
+          @consent_required = false
+          @top_level_domain = top_level_domain
+        end
+
+        def get_or_add(cookies, default_visitor_code = nil)
+          return if cookies.nil?
+
+          visitor_code = get_visitor_code_from_cookies(cookies)
+          unless visitor_code.nil?
+            Utils::VisitorCode.validate(visitor_code)
+            # Remove adding cookies when we will be sure that it doesn't break anything
+            add(visitor_code, cookies) unless @consent_required
+            return visitor_code
+          end
+
+          if default_visitor_code.nil?
+            visitor_code = Utils::VisitorCode.generate
+            add(visitor_code, cookies) unless @consent_required
+            return visitor_code
+          end
+
+          visitor_code = default_visitor_code
+          Utils::VisitorCode.validate(visitor_code)
+          add(visitor_code, cookies)
+          visitor_code
+        end
+
+        def update(visitor_code, consent, cookies)
+          return if cookies.nil?
+
+          if consent
+            add(visitor_code, cookies)
+          else
+            remove(cookies)
+          end
+        end
+
+        private
+
+        def add(visitor_code, cookies)
+          cookie = {
+            value: visitor_code,
+            expires: Time.now + COOKIE_TTL_SECONDS,
+            path: '/',
+            domain: @top_level_domain
+          }
+          cookies[VISITOR_CODE_COOKIE] = cookie
+        end
+
+        def remove(cookies)
+          cookies[VISITOR_CODE_COOKIE] = nil if @consent_required
+        end
+
+        def get_visitor_code_from_cookies(cookies)
+          cookie = cookies[VISITOR_CODE_COOKIE]
+          case cookie
+          when String
+            visitor_code = cookie
+          when Hash
+            visitor_code = cookie[:value]
+          end
+          visitor_code = visitor_code[COOKIE_KEY_JS.size..] if visitor_code&.start_with?(COOKIE_KEY_JS)
+          visitor_code = nil if visitor_code&.empty?
+          visitor_code
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/network/net_provider.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'em-synchrony/em-http'
 require 'net/http'
 require 'kameleoon/version'
 require 'kameleoon/network/response'
@@ -16,7 +15,8 @@ module Kameleoon
       private
 
       def collect_headers(request)
-        headers = { 'Content-Type': request.content_type }
+        headers = request.extra_headers || {}
+        headers['Content-Type'] = request.content_type
         headers['User-Agent'] = request.user_agent unless request.user_agent.nil?
         headers
       end
@@ -26,40 +26,6 @@ module Kameleoon
       end
     end
 
-    class EMNetProvider < NetProvider
-      def make_request(request)
-        connetion_options = {
-          tls: { verify_peer: false },
-          connect_timeout: request.timeout,
-          inactivity_timeout: request.timeout
-        }
-        headers = collect_headers(request)
-        request_options = { head: headers, body: request.data }
-        begin
-          case request.method
-          when Method::POST
-            EventMachine::HttpRequest.new(request.url, connetion_options).apost(request_options)
-          when Method::GET
-            EventMachine::HttpRequest.new(request.url, connetion_options).aget(request_options)
-          else
-            dfr = DeferrableResponse.new
-            dfr.response = unknown_method_response(request.method, request)
-            dfr
-          end
-        rescue => e
-          dfr = DeferrableResponse.new
-          dfr.response = Response.new(e, nil, nil, request)
-          dfr
-        end
-      end
-
-      def self.em_resp_to_response(request, resp)
-        return resp if resp.is_a?(Response)
-
-        Response.new(nil, resp.response_header.status, resp.response, request)
-      end
-    end
-
     class SyncNetProvider < NetProvider
       def make_request(request)
         resp = nil
@@ -84,7 +50,9 @@ module Kameleoon
         rescue => e
           return Response.new(e, nil, nil, request)
         end
-        Response.new(nil, resp.code.to_i, resp.body, request)
+        body = resp.body
+        body = nil if body&.empty?
+        Response.new(nil, resp.code.to_i, body, request)
       end
     end
   end

data/lib/kameleoon/network/network_manager.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'em-synchrony'
 require 'kameleoon/network/content_type'
 require 'kameleoon/network/method'
 require 'kameleoon/network/request'
 require 'kameleoon/network/net_provider'
+require 'kameleoon/version'
 
 module Kameleoon
   module Network
@@ -14,6 +14,8 @@ module Kameleoon
       FETCH_CONFIGURATION_ATTEMPT_NUMBER = 4
       TRACKING_CALL_ATTEMPT_NUMBER = 4
       TRACKING_CALL_RETRY_DELAY = 5.0 # in seconds
+      SDK_TYPE_HEADER = 'X-Kameleoon-SDK-Type'
+      SDK_VERSION_HEADER = 'X-Kameleoon-SDK-Version'
 
       attr_reader :environment, :default_timeout, :url_provider
 
@@ -21,7 +23,6 @@ module Kameleoon
         @environment = environment
         @default_timeout = default_timeout
         @url_provider = url_provider
-        @em_net_provider = EMNetProvider.new
         @sync_net_provider = SyncNetProvider.new
         @log_func = log_func
       end
@@ -29,11 +30,11 @@ module Kameleoon
       def fetch_configuration(timestamp = nil, timeout = nil)
         url = @url_provider.make_configuration_url(@environment, timestamp)
         timeout = ensure_timeout(timeout)
-        request = Request.new(Method::GET, url, ContentType::JSON, timeout)
+        sdk_headers = { SDK_TYPE_HEADER => SDK_NAME, SDK_VERSION_HEADER => SDK_VERSION }
+        request = Request.new(Method::GET, url, ContentType::JSON, timeout, extra_headers: sdk_headers)
         attempts_left = FETCH_CONFIGURATION_ATTEMPT_NUMBER
         while attempts_left.positive?
-          em_resp = EM::Synchrony.sync(@em_net_provider.make_request(request))
-          response = EMNetProvider.em_resp_to_response(request, em_resp)
+          response = @sync_net_provider.make_request(request)
           result = handle_response(response)
           return result if result
 
@@ -64,13 +65,13 @@ module Kameleoon
         url = @url_provider.make_tracking_url(visitor_code)
         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, data)
+        request = Request.new(Method::POST, url, ContentType::TEXT, timeout, user_agent: user_agent, data: data)
         Thread.new do
           attempts_left = TRACKING_CALL_ATTEMPT_NUMBER
           loop do
             response = @sync_net_provider.make_request(request)
             if handle_response(response) != false
-              lines.each { |line| line.sent = true }
+              lines.each(&:mark_as_sent)
               break
             end
             attempts_left -= 1

data/lib/kameleoon/network/request.rb

@@ -5,14 +5,15 @@ module Kameleoon
     ##
     # Request represents HTTP request.
     class Request
-      attr_reader :method, :url, :content_type, :timeout, :user_agent, :data
+      attr_reader :method, :url, :content_type, :timeout, :user_agent, :extra_headers, :data
 
-      def initialize(method, url, content_type, timeout, user_agent = nil, data = nil)
+      def initialize(method, url, content_type, timeout, user_agent: nil, 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
     end

data/lib/kameleoon/network/response.rb

@@ -18,13 +18,5 @@ module Kameleoon
         @error.nil? && (@code / 100 == 2)
       end
     end
-
-    class DeferrableResponse < EventMachine::DefaultDeferrable
-      attr_writer :response
-
-      def callback(&blk)
-        blk.call(@response)
-      end
-    end
   end
 end

data/lib/kameleoon/network/url_provider.rb

@@ -12,7 +12,7 @@ module Kameleoon
       VISITOR_DATA_PATH = '/visit/visitor'
       GET_DATA_PATH = '/map/map'
       POST_DATA_PATH = '/map/maps'
-      CONFIGURATION_API_URL = 'https://client-config.kameleoon.com/mobile'
+      CONFIGURATION_API_URL_FORMAT = 'https://sdk-config.kameleoon.eu/%s'
       RT_CONFIGURATION_URL = 'https://events.kameleoon.com:8110/sse'
 
       DEFAULT_DATA_API_URL = 'https://data.kameleoon.io'
@@ -56,10 +56,12 @@ module Kameleoon
       end
 
       def make_configuration_url(environment = nil, timestamp = nil)
-        params = { siteCode: @site_code }
+        url = format(CONFIGURATION_API_URL_FORMAT, @site_code)
+        params = {}
         params[:environment] = environment unless environment.nil?
         params[:ts] = timestamp unless timestamp.nil?
-        "#{CONFIGURATION_API_URL}?#{UriHelper.encode_query(params)}"
+        url = "#{url}?#{UriHelper.encode_query(params)}" unless params.empty?
+        url
       end
 
       def make_real_time_url

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

@@ -22,9 +22,8 @@ module Kameleoon
         @version_match_type = json_condition['versionMatchType']
       end
 
-      def check(list_data)
-        browser = get_last_targeting_data(list_data, Kameleoon::DataType::BROWSER)
-        browser && check_targeting(browser)
+      def check(browser)
+        browser.is_a?(Kameleoon::Browser) && check_targeting(browser)
       end
 
       private

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
+require 'kameleoon/data/conversion'
+require 'kameleoon/data/manager/data_array_storage'
 
 module Kameleoon
   # @api private
@@ -12,9 +13,16 @@ module Kameleoon
         @goal_id = json_condition['goalId']
       end
 
-      def check(list_data)
-        conversion = get_last_targeting_data(list_data, Kameleoon::DataType::CONVERSION)
-        conversion && (@goal_id.nil? || @goal_id == conversion.goal_id)
+      def check(conversion_storage)
+        return false unless conversion_storage.is_a?(Kameleoon::DataManager::DataArrayStorage)
+        return true if @goal_id.nil?
+
+        is_targeted = false
+        conversion_storage.enumerate do |conversion|
+          is_targeted = conversion.is_a?(Kameleoon::Conversion) && (@goal_id == conversion.goal_id)
+          break if is_targeted
+        end
+        is_targeted
       end
     end
   end

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

@@ -12,6 +12,10 @@ module Kameleoon
       include Kameleoon::Exception
 
       class << self
+        def op_undefined(values, value)
+          false
+        end
+
         def op_match(values, value)
           re = Regexp.new(value.to_s)
           values.any? { |v| re.match(v) }
@@ -26,7 +30,8 @@ module Kameleoon
         end
 
         def op_equal(values, value)
-          values.any? { |v| v.to_f == value.to_f }
+          epsilon = 1e-9
+          values.any? { |v| (v.to_f - value.to_f).abs < epsilon }
         end
 
         def op_greater(values, value)
@@ -52,6 +57,7 @@ module Kameleoon
       end
 
       @@op = {
+        Operator::UNDEFINED => method(:op_undefined),
         Operator::REGULAR_EXPRESSION => method(:op_match),
         Operator::CONTAINS => method(:op_contains),
         Operator::EXACT => method(:op_exact),
@@ -71,24 +77,24 @@ module Kameleoon
         end
 
         @type = ConditionType::CUSTOM_DATUM
-        @index = json_condition['customDataIndex']
+        @index = json_condition['customDataIndex'].to_i
         @operator = json_condition['valueMatchType']
+        @operation = @@op[@operator]
         @value = json_condition['value']
       end
 
-      def check(list_data)
-        is_targeted = false
-        custom_data = list_data.select { |data| data.instance == DataType::CUSTOM && data.id == @index }.last
-        if custom_data.nil?
-          is_targeted = (@operator == Operator::UNDEFINED.to_s)
-        elsif @operator != Operator::UNDEFINED.to_s
-          @operation = @@op[@operator]
-          unless @operation
-            raise KameleoonError.new("Undefined operator #{@operator}"), "Undefined operator #{@operator}"
+      def check(custom_data_storage)
+        is_targeted = nil
+        if custom_data_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+          custom_data = custom_data_storage.get(@index)
+          if custom_data.is_a?(Kameleoon::CustomData)
+            unless @operation
+              raise KameleoonError.new("Undefined operator #{@operator}"), "Undefined operator #{@operator}"
+            end
+            is_targeted = @operation.call(custom_data.values, @value)
           end
-
-          is_targeted = @operation.call(custom_data.values, @value)
         end
+        is_targeted = (@operator == Operator::UNDEFINED.to_s) if is_targeted.nil?
         is_targeted
       end
     end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
+require 'kameleoon/data/device'
 
 module Kameleoon
   # @api private
@@ -12,9 +12,8 @@ module Kameleoon
         @device_type = json_condition['device']
       end
 
-      def check(list_data)
-        device = get_last_targeting_data(list_data, Kameleoon::DataType::DEVICE)
-        device && @device_type == device.device_type
+      def check(device)
+        device.is_a?(Kameleoon::Device) && @device_type == device.device_type
       end
     end
   end

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

@@ -10,7 +10,8 @@ module Kameleoon
       def check(data)
         experiment_id = data.experiment_id
         storage = data.storage
-        storage.nil? || storage.empty? || (storage.length == 1 && !storage[experiment_id].nil?)
+        storage.is_a?(Kameleoon::DataManager::DataMapStorage) &&
+          (storage.size.zero? || ((storage.size == 1) && !storage.get(experiment_id).nil?))
       end
     end
   end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
+require 'kameleoon/data/manager/data_map_storage'
+require 'kameleoon/data/manager/page_view_visit'
 require_relative 'string_value_condition'
 
 module Kameleoon
@@ -12,9 +13,15 @@ module Kameleoon
         super(json_condition, json_condition['title'])
       end
 
-      def check(list_data)
-        page_view = get_last_targeting_data(list_data, Kameleoon::DataType::PAGE_VIEW)
-        page_view && check_targeting(page_view.title)
+      def check(page_view_visit_storage)
+        return false unless page_view_visit_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+
+        is_targeted = false
+        page_view_visit_storage.enumerate do |visit|
+          is_targeted = visit.is_a?(Kameleoon::DataManager::PageViewVisit) && check_targeting(visit.page_view.title)
+          break if is_targeted
+        end
+        is_targeted
       end
     end
   end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'kameleoon/data/data'
+require 'kameleoon/data/manager/data_map_storage'
+require 'kameleoon/data/manager/page_view_visit'
 require_relative 'string_value_condition'
 
 module Kameleoon
@@ -12,9 +13,22 @@ module Kameleoon
         super(json_condition, json_condition['url'])
       end
 
-      def check(list_data)
-        page_view = get_last_targeting_data(list_data, Kameleoon::DataType::PAGE_VIEW)
-        page_view && check_targeting(page_view.url)
+      def check(page_view_visit_storage)
+        return false unless page_view_visit_storage.is_a?(Kameleoon::DataManager::DataMapStorage)
+        return !page_view_visit_storage.get(condition_value).nil? if operator == Operator::EXACT
+
+        is_targeted = false
+        page_view_visit_storage.enumerate do |visit|
+          is_targeted = check_page_view_visit(visit)
+          break if is_targeted
+        end
+        is_targeted
+      end
+
+      private
+
+      def check_page_view_visit(visit)
+        visit.is_a?(Kameleoon::DataManager::PageViewVisit) && check_targeting(visit.page_view.url)
       end
     end
   end

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

@@ -19,6 +19,8 @@ module Kameleoon
 
       protected
 
+      attr_reader :operator, :condition_value
+
       def check_targeting(value)
         return false if value.nil?
 

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

@@ -24,16 +24,21 @@ module Kameleoon
       end
 
       def check(variation_storage)
-        is_targeted = false
-        variation_storage_exist = !variation_storage.nil? && !variation_storage.empty?
-        saved_variation = variation_storage[@experiment] unless variation_storage.nil?
+        return false unless variation_storage.is_a?(Kameleoon::DataManager::DataMapStorage) &&
+                            variation_storage.size.positive?
+
+        variation = variation_storage.get(@experiment)
+        return false unless variation.is_a?(Kameleoon::DataManager::AssignedVariation)
+
         case @operator
         when Operator::EXACT
-          is_targeted = variation_storage_exist && saved_variation == @variation
+          variation = variation_storage.get(@experiment)
+          variation.variation_id == @variation
         when Operator::ANY
-          is_targeted = variation_storage_exist
+          true
+        else
+          false
         end
-        is_targeted
       end
     end
   end