kameleoon-client-ruby 2.3.0 → 3.1.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/managers/warehouse/warehouse_manager.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/custom_data'
+require 'kameleoon/utils'
+
+module Kameleoon
+  module Managers
+    module Warehouse
+      class WarehouseManager
+        WAREHOUSE_AUDIENCES_FIELD_NAME = 'warehouseAudiences'
+
+        def initialize(network_manager, visitor_manager, log_func = nil)
+          @network_manager = network_manager
+          @visitor_manager = visitor_manager
+          @log_func = log_func
+        end
+
+        def get_visitor_warehouse_audience(visitor_code, custom_data_index, warehouse_key = nil, timeout = nil)
+          Utils::VisitorCode.validate(visitor_code)
+          remote_data_key = warehouse_key.nil? || warehouse_key.empty? ? visitor_code : warehouse_key
+          response = @network_manager.get_remote_data(remote_data_key, timeout)
+          remote_data = response.is_a?(String) ? JSON.parse(response) : nil
+          warehouse_audiences = remote_data.is_a?(Hash) ? remote_data[WAREHOUSE_AUDIENCES_FIELD_NAME] : nil
+          data_values = warehouse_audiences.is_a?(Hash) ? warehouse_audiences.keys : []
+          warehouse_audiences_data = CustomData.new(custom_data_index, *data_values)
+          visitor = @visitor_manager.get_or_create_visitor(visitor_code)
+          visitor.add_data(@log_func, warehouse_audiences_data)
+          warehouse_audiences_data
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/network/access_token_source.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'time'
+
+module Kameleoon
+  module Network
+    class AccessTokenSource
+      TOKEN_EXPIRATION_GAP = 60 # in seconds
+      TOKEN_OBSOLESCENCE_GAP = 1800 # in seconds
+      JWT_ACCESS_TOKEN_FIELD = 'access_token'
+      JWT_EXPIRES_IN_FIELD = 'expires_in'
+
+      def initialize(network_manager, client_id, client_secret, log_func)
+        @network_manager = network_manager
+        @client_id = client_id
+        @client_secret = client_secret
+        @fetching = false
+        @log_func = log_func
+      end
+
+      def get_token
+        now = Time.new.to_i
+        token = @cached_token
+        return fetch_token if token.nil? || token.expired?(now)
+
+        Thread.new { fetch_token } if !@fetching && token.obsolete?(now)
+        token.value
+      end
+
+      def discard_token(token)
+        @cached_token = nil if @cached_token&.value == token
+      end
+
+      private
+
+      def fetch_token
+        @fetching = true
+        response_content = @network_manager.fetch_access_jwtoken(@client_id, @client_secret)
+        unless response_content
+          @log_func&.call('Failed to fetch access JWT')
+          return nil
+        end
+        begin
+          jwt = JSON.parse(response_content)
+          token = jwt[JWT_ACCESS_TOKEN_FIELD]
+          expires_in = jwt[JWT_EXPIRES_IN_FIELD]
+        rescue JSON::ParserError => e
+          @log_func&.call("Failed to parse access JWT: #{e}")
+          return nil
+        end
+        unless token.is_a?(String) && !token.empty? && expires_in.is_a?(Integer) && expires_in.positive?
+          @log_func&.call('Failed to read access JWT')
+          return nil
+        end
+        handle_fetched_token(token, expires_in)
+      ensure
+        @fetching = false
+      end
+
+      def handle_fetched_token(token, expires_in)
+        now = Time.new.to_i
+        exp_time = now + expires_in - TOKEN_EXPIRATION_GAP
+        if expires_in > TOKEN_OBSOLESCENCE_GAP
+          obs_time = now + expires_in - TOKEN_OBSOLESCENCE_GAP
+        else
+          obs_time = exp_time
+          unless @log_func.nil?
+            issue = expires_in <= TOKEN_EXPIRATION_GAP ? 'cache the token' : 'refresh cached token in background'
+            @log_func.call("Access token life time (#{expires_in}s) is not long enough to #{issue}")
+          end
+        end
+        @cached_token = ExpiringToken.new(token, exp_time, obs_time)
+        token
+      end
+    end
+
+    class ExpiringToken
+      attr_reader :value, :expiration_time, :obsolescence_time
+
+      def initialize(value, expiration_time, obsolescence_time)
+        @value = value
+        @expiration_time = expiration_time
+        @obsolescence_time = obsolescence_time
+      end
+
+      def expired?(now)
+        now >= @expiration_time
+      end
+
+      def obsolete?(now)
+        now >= @obsolescence_time
+      end
+    end
+
+    class AccessTokenSourceFactory
+      def initialize(client_id, client_secret, log_func)
+        @client_id = client_id
+        @client_secret = client_secret
+        @log_func = log_func
+      end
+
+      def create(network_manager)
+        AccessTokenSource.new(network_manager, @client_id, @client_secret, @log_func)
+      end
+    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'
@@ -9,14 +8,16 @@ require 'kameleoon/exceptions'
 module Kameleoon
   module Network
     class NetProvider
-      def make_request(_request)
+      def make_request(request)
         raise KameleoonError, 'Call of not implemented method!'
       end
 
       private
 
       def collect_headers(request)
-        headers = { 'Content-Type': request.content_type }
+        headers = request.extra_headers || {}
+        headers['Authorization'] = "Bearer #{request.access_token}" unless request.access_token.nil?
+        headers['Content-Type'] = request.content_type
         headers['User-Agent'] = request.user_agent unless request.user_agent.nil?
         headers
       end
@@ -26,65 +27,31 @@ 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
-        begin
-          case request.method
-          when Method::GET
-            req = Net::HTTP::Get.new(request.url)
-          when Method::POST
-            req = Net::HTTP::Post.new(request.url)
-            req.body = request.data
-          else
-            return unknown_method_response(request.method, request)
-          end
-          timeout = request.timeout.to_f / 1000.0
-          headers = collect_headers(request)
-          headers.each { |k, v| req[k] = v }
-          uri = URI(request.url)
-          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, open_timeout: timeout,
-                                                  read_timeout: timeout, ssl_timeout: timeout) do |http|
-            resp = http.request(req)
-          end
-        rescue => e
-          return Response.new(e, nil, nil, request)
+        case request.method
+        when Method::GET
+          req = Net::HTTP::Get.new(request.url)
+        when Method::POST
+          req = Net::HTTP::Post.new(request.url)
+          req.body = request.data
+        else
+          return unknown_method_response(request.method, request)
+        end
+        timeout = request.timeout.to_f / 1000.0
+        headers = collect_headers(request)
+        headers.each { |k, v| req[k] = v }
+        uri = URI(request.url)
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, open_timeout: timeout,
+                                                read_timeout: timeout, ssl_timeout: timeout) do |http|
+          resp = http.request(req)
         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)
+      rescue => e
+        Response.new(e, nil, nil, request)
       end
     end
   end

data/lib/kameleoon/network/network_manager.rb

@@ -1,27 +1,31 @@
 # 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/network/uri_helper'
+require 'kameleoon/version'
 
 module Kameleoon
   module Network
     ##
     # NetworkManager is used to make API calls.
     class NetworkManager
-      FETCH_CONFIGURATION_ATTEMPT_NUMBER = 4
-      TRACKING_CALL_ATTEMPT_NUMBER = 4
+      FETCH_CONFIGURATION_ATTEMPT_NUMBER = 3
+      TRACKING_CALL_ATTEMPT_NUMBER = 3
       TRACKING_CALL_RETRY_DELAY = 5.0 # in seconds
+      SDK_TYPE_HEADER = 'X-Kameleoon-SDK-Type'
+      SDK_VERSION_HEADER = 'X-Kameleoon-SDK-Version'
+      ACCESS_TOKEN_GRANT_TYPE = 'client_credentials'
 
-      attr_reader :environment, :default_timeout, :url_provider
+      attr_reader :environment, :default_timeout, :access_token_source, :url_provider
 
-      def initialize(environment, default_timeout, url_provider, log_func = nil)
+      def initialize(environment, default_timeout, access_token_source_factory, url_provider, log_func = nil)
         @environment = environment
         @default_timeout = default_timeout
+        @access_token_source = access_token_source_factory.create(self)
         @url_provider = url_provider
-        @em_net_provider = EMNetProvider.new
         @sync_net_provider = SyncNetProvider.new
         @log_func = log_func
       end
@@ -29,33 +33,23 @@ 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)
-        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)
-          result = handle_response(response)
-          return result if result
-
-          attempts_left -= 1
-        end
-        false
+        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)
+        make_call(request, false, FETCH_CONFIGURATION_ATTEMPT_NUMBER - 1)
       end
 
       def get_remote_data(key, timeout = nil)
         url = @url_provider.make_api_data_get_request_url(key)
         timeout = ensure_timeout(timeout)
         request = Request.new(Method::GET, url, ContentType::JSON, timeout)
-        response = @sync_net_provider.make_request(request)
-        handle_response(response)
+        make_call(request, true)
       end
 
       def get_remote_visitor_data(visitor_code, timeout = nil)
         url = @url_provider.make_visitor_data_get_url(visitor_code)
         timeout = ensure_timeout(timeout)
         request = Request.new(Method::GET, url, ContentType::JSON, timeout)
-        response = @sync_net_provider.make_request(request)
-        handle_response(response)
+        make_call(request, true)
       end
 
       def send_tracking_data(visitor_code, lines, user_agent, timeout = nil)
@@ -64,25 +58,57 @@ 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 }
-              break
-            end
-            attempts_left -= 1
-            break unless attempts_left.positive?
-
-            delay(TRACKING_CALL_RETRY_DELAY)
-          end
+          result = make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY)
+          lines.each(&:mark_as_sent) if result != false
         end
       end
 
+      def fetch_access_jwtoken(client_id, client_secret, timeout = nil)
+        url = @url_provider.make_access_token_url
+        timeout = ensure_timeout(timeout)
+        data_map = {
+          grant_type: ACCESS_TOKEN_GRANT_TYPE,
+          client_id: client_id,
+          client_secret: client_secret
+        }
+        data = UriHelper.encode_query(data_map).encode('UTF-8')
+        request = Request.new(Method::POST, url, ContentType::FORM, timeout, data: data)
+        make_call(request, false)
+      end
+
       private
 
+      def make_call(request, try_access_token_auth, retry_limit = 0, retry_delay = 0)
+        attempt = 0
+        success = false
+        while !success && (attempt <= retry_limit)
+          delay(retry_delay) if attempt.positive? && retry_delay.positive?
+          try_authorize(request) if try_access_token_auth
+          response = @sync_net_provider.make_request(request)
+          if !response.error.nil?
+            log_failure(response.request, "Error occurred during request: #{response.error}")
+          elsif response.code / 100 != 2
+            if ((response.code == 401) || (response.code == 403)) && response.request.access_token
+              @log_func&.call("Unexpected rejection of access token '#{response.request.access_token}'")
+              @access_token_source.discard_token(response.request.access_token)
+              if attempt == retry_limit
+                try_access_token_auth = false
+                retry_delay = 0
+                request.authorize(nil)
+                attempt -= 1
+              end
+            end
+            log_failure(response.request, "Received unexpected status code '#{response.code}'")
+          else
+            success = true
+          end
+          attempt += 1
+        end
+        success ? response.body : false
+      end
+
       def log_failure(request, message)
         return if @log_func.nil?
 
@@ -99,15 +125,11 @@ module Kameleoon
         timeout.nil? ? @default_timeout : timeout
       end
 
-      def handle_response(response)
-        if !response.error.nil?
-          log_failure(response.request, "Error occurred during request: #{response.error}")
-        elsif response.code / 100 != 2
-          log_failure(response.request, "Received unexpected status code '#{response.code}'")
-        else
-          return response.body
-        end
-        false
+      def try_authorize(request)
+        token = @access_token_source.get_token
+        return if request.authorize(token)
+
+        @log_func&.call("Failed to authorize #{request.method} call '#{request.url}'")
       end
     end
   end