kameleoon-client-ruby 2.1.0 → 2.2.0

data/lib/kameleoon/data/page_view.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'kameleoon/network/uri_helper'
+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
+      params = {
+        eventType: 'page',
+        href: @url,
+        title: @title,
+        nonce: nonce
+      }
+      params[:referrersIndices] = "[#{@referrers.each(&:to_s).join(',')}]" if
+        !@referrers.nil? && !@referrers.empty?
+      Kameleoon::Network::UriHelper.encode_query(params)
+    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/content_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Network
+    module ContentType
+      TEXT = 'text/plain'
+      JSON = 'application/json'
+      FORM = 'application/x-www-form-urlencoded'
+    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

data/lib/kameleoon/network/method.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Network
+    module Method
+      GET = 'GET'
+      POST = 'POST'
+    end
+  end
+end

data/lib/kameleoon/network/net_provider.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'em-synchrony/em-http'
+require 'net/http'
+require 'kameleoon/version'
+require 'kameleoon/network/response'
+require 'kameleoon/exceptions'
+
+module Kameleoon
+  module Network
+    class NetProvider
+      def make_request(_request)
+        raise KameleoonError, 'Call of not implemented method!'
+      end
+
+      private
+
+      def collect_headers(request)
+        headers = { 'Content-Type': request.content_type }
+        headers['User-Agent'] = request.user_agent unless request.user_agent.nil?
+        headers
+      end
+
+      def unknown_method_response(method, request)
+        Response.new("Unknown request method '#{method}'", nil, nil, request)
+      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)
+        end
+        Response.new(nil, resp.code.to_i, resp.body, request)
+      end
+    end
+  end
+end

data/lib/kameleoon/network/network_manager.rb

@@ -0,0 +1,114 @@
+# 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'
+
+module Kameleoon
+  module Network
+    ##
+    # NetworkManager is used to make API calls.
+    class NetworkManager
+      FETCH_CONFIGURATION_ATTEMPT_NUMBER = 4
+      TRACKING_CALL_ATTEMPT_NUMBER = 4
+      TRACKING_CALL_RETRY_DELAY = 5.0 # in seconds
+
+      attr_reader :environment, :default_timeout, :url_provider
+
+      def initialize(environment, default_timeout, url_provider, log_func = nil)
+        @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
+
+      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
+      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)
+      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)
+      end
+
+      def send_tracking_data(visitor_code, lines, user_agent, timeout = nil)
+        return if lines.nil? || lines.empty?
+
+        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)
+        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
+        end
+      end
+
+      private
+
+      def log_failure(request, message)
+        return if @log_func.nil?
+
+        premsg = "#{request.method} call '#{request.url}' "
+        premsg += request.data.nil? ? 'failed' : "(data '#{request.data}') failed"
+        @log_func.call("#{premsg}: #{message}")
+      end
+
+      def delay(period)
+        sleep(period)
+      end
+
+      def ensure_timeout(timeout)
+        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
+      end
+    end
+  end
+end

data/lib/kameleoon/network/request.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Network
+    ##
+    # Request represents HTTP request.
+    class Request
+      attr_reader :method, :url, :content_type, :timeout, :user_agent, :data
+
+      def initialize(method, url, content_type, timeout, user_agent = nil, data = nil)
+        @method = method
+        @url = url
+        @content_type = content_type
+        @timeout = timeout
+        @user_agent = user_agent
+        @data = !data.nil? && data.is_a?(String) ? data.encode('UTF-8') : data
+      end
+    end
+  end
+end

data/lib/kameleoon/network/response.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module Network
+    ##
+    # Response represents HTTP response.
+    class Response
+      attr_reader :error, :code, :body, :request
+
+      def initialize(error, code, body, request)
+        @error = error
+        @code = code
+        @body = body
+        @request = request
+      end
+
+      def success?
+        @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/uri_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'uri'
+
+module Kameleoon
+  module Network
+    ##
+    # UriHelper contains functions which helps working with URIs.
+    module UriHelper
+      def self.encode_uri(uri)
+        encoded = CGI.escape(uri)
+        encoded.gsub!(/%21|%27|%28|%29|%2A|\+/,
+                      '%21' => '!',
+                      '%27' => "'",
+                      '%28' => '(',
+                      '%29' => ')',
+                      '%2A' => '*',
+                      '+' => '%20')
+        encoded
+      end
+
+      def self.encode_query(params)
+        params.delete_if { |_k, v| v.nil? || (v == '') }
+        encoded = URI.encode_www_form(params)
+        encoded.gsub!(/%21|%27|%28|%29|%7E|\+/,
+                      '%21' => '!',
+                      '%27' => "'",
+                      '%28' => '(',
+                      '%29' => ')',
+                      '%7E' => '~',
+                      '+' => '%20')
+        encoded
+      end
+    end
+  end
+end

data/lib/kameleoon/network/url_provider.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'kameleoon/version'
+require 'kameleoon/network/uri_helper'
+
+module Kameleoon
+  module Network
+    ##
+    # UrlProvider is used as a source of URLs for network calls.
+    class UrlProvider
+      TRACKING_PATH = '/visit/events'
+      VISITOR_DATA_PATH = '/visit/visitor'
+      GET_DATA_PATH = '/map/map'
+      POST_DATA_PATH = '/map/maps'
+      CONFIGURATION_API_URL = 'https://client-config.kameleoon.com/mobile'
+      RT_CONFIGURATION_URL = 'https://events.kameleoon.com:8110/sse'
+
+      DEFAULT_DATA_API_URL = 'https://data.kameleoon.io'
+      TEST_DATA_API_URL = 'https://data.kameleoon.net'
+
+      attr_reader :site_code, :data_api_url
+
+      def initialize(site_code, data_api_url)
+        @site_code = site_code
+        @data_api_url = data_api_url
+      end
+
+      def make_tracking_url(visitor_code)
+        params = {
+          sdkName: SDK_NAME,
+          sdkVersion: SDK_VERSION,
+          siteCode: @site_code,
+          visitorCode: visitor_code
+        }
+        "#{@data_api_url}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
+      end
+
+      def make_visitor_data_get_url(visitor_code)
+        params = {
+          siteCode: @site_code,
+          visitorCode: visitor_code,
+          currentVisit: true,
+          maxNumberPreviousVisits: 1,
+          customData: true,
+          version: 0
+        }
+        "#{@data_api_url}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
+      end
+
+      def make_api_data_get_request_url(key)
+        params = {
+          siteCode: @site_code,
+          key: key
+        }
+        "#{@data_api_url}#{GET_DATA_PATH}?#{UriHelper.encode_query(params)}"
+      end
+
+      def make_configuration_url(environment = nil, timestamp = nil)
+        params = { siteCode: @site_code }
+        params[:environment] = environment unless environment.nil?
+        params[:ts] = timestamp unless timestamp.nil?
+        "#{CONFIGURATION_API_URL}?#{UriHelper.encode_query(params)}"
+      end
+
+      def make_real_time_url
+        params = { siteCode: @site_code }
+        "#{RT_CONFIGURATION_URL}?#{UriHelper.encode_query(params)}"
+      end
+    end
+  end
+end

data/lib/kameleoon/targeting/condition.rb

@@ -1,28 +1,57 @@
 # frozen_string_literal: true
+require 'kameleoon/exceptions'
 
 module Kameleoon
   # @api private
   module Targeting
+    module ConditionType
+      CUSTOM_DATUM = 'CUSTOM_DATUM'
+      TARGET_EXPERIMENT = 'TARGET_EXPERIMENT'
+      EXCLUSIVE_EXPERIMENT = 'EXCLUSIVE_EXPERIMENT'
+      PAGE_URL = 'PAGE_URL'
+      PAGE_TITLE = 'PAGE_TITLE'
+      VISITOR_CODE = 'VISITOR_CODE'
+      DEVICE_TYPE = 'DEVICE_TYPE'
+      BROWSER = 'BROWSER'
+      SDK_LANGUAGE = 'SDK_LANGUAGE'
+      CONVERSIONS = 'CONVERSIONS'
+    end
+
+    module Operator
+      UNDEFINED = 'UNDEFINED'
+      CONTAINS = 'CONTAINS'
+      EXACT = 'EXACT'
+      REGULAR_EXPRESSION = 'REGULAR_EXPRESSION'
+      LOWER = 'LOWER'
+      EQUAL = 'EQUAL'
+      GREATER = 'GREATER'
+      IS_TRUE = 'TRUE'
+      IS_FALSE = 'FALSE'
+      AMONG_VALUES = 'AMONG_VALUES'
+      ANY = 'ANY'
+      UNKNOWN = 'UNKNOWN'
+    end
+
+    # Base class for all targeting conditions
     class Condition
-      attr_accessor :type, :include
+      attr_reader :type, :include
 
       def initialize(json_condition)
-        if json_condition['targetingType'].nil?
-          raise Exception::NotFound.new('targetingType'), 'targetingType missed'
-        end
+        raise Exception::NotFound.new('targetingType'), 'targetingType missed' if json_condition['targetingType'].nil?
 
         @type = json_condition['targetingType']
-
-        if json_condition['include'].nil? && json_condition['isInclude'].nil?
-          raise Exception::NotFound.new('include / isInclude missed'), 'include / isInclude missed'
-        end
-
-        @include = json_condition['include'] || json_condition['isInclude']
+        @include = json_condition['isInclude'].nil? ? true : json_condition['isInclude']
       end
 
-      def check(conditions)
+      def check(_data)
         raise 'Abstract method `check` call'
       end
+
+      protected
+
+      def get_last_targeting_data(list_data, data_type)
+        list_data.select { |data| data.instance == data_type }.last
+      end
     end
   end
 end

data/lib/kameleoon/targeting/condition_factory.rb

@@ -1,22 +1,45 @@
-require 'kameleoon/targeting/conditions/custom_datum'
-require 'kameleoon/targeting/conditions/target_experiment'
-require 'kameleoon/targeting/conditions/exclusive_experiment'
+require_relative 'conditions/custom_datum'
+require_relative 'conditions/target_experiment'
+require_relative 'conditions/exclusive_experiment'
+require_relative 'conditions/page_title_condition'
+require_relative 'conditions/page_url_condition'
+require_relative 'conditions/visitor_code_condition'
+require_relative 'conditions/device_condition'
+require_relative 'conditions/conversion_condition'
+require_relative 'conditions/browser_condition'
+require_relative 'conditions/sdk_language_condition'
+require_relative 'conditions/unknown_condition'
 
 module Kameleoon
-  #@api private
+  # @api private
   module Targeting
+    # Module for create different targeting conditions
     module ConditionFactory
       def get_condition(condition_json)
-        condition = nil
         case condition_json['targetingType']
-        when ConditionType::CUSTOM_DATUM.to_s
-          condition = CustomDatum.new(condition_json)
-        when ConditionType::TARGET_EXPERIMENT.to_s
-          condition = TargetExperiment.new(condition_json)
-        when ConditionType::EXCLUSIVE_EXPERIMENT.to_s
-          condition = ExclusiveExperiment.new(condition_json)
+        when ConditionType::CUSTOM_DATUM
+          CustomDatum.new(condition_json)
+        when ConditionType::TARGET_EXPERIMENT
+          TargetExperiment.new(condition_json)
+        when ConditionType::EXCLUSIVE_EXPERIMENT
+          ExclusiveExperiment.new(condition_json)
+        when ConditionType::PAGE_URL
+          PageUrlCondition.new(condition_json)
+        when ConditionType::PAGE_TITLE
+          PageTitleCondition.new(condition_json)
+        when ConditionType::VISITOR_CODE
+          VisitorCodeCondition.new(condition_json)
+        when ConditionType::DEVICE_TYPE
+          DeviceCondition.new(condition_json)
+        when ConditionType::CONVERSIONS
+          ConversionCondition.new(condition_json)
+        when ConditionType::BROWSER
+          BrowserCondition.new(condition_json)
+        when ConditionType::SDK_LANGUAGE
+          SdkLanguageCondition.new(condition_json)
+        else
+          UnknownCondition.new(condition_json)
         end
-        condition
       end
     end
   end