kameleoon-client-ruby 2.1.1 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1aef3f7b97d4a32024bec989ed4356cc1d10425c16b419b55f524cf1abfd4f52
-  data.tar.gz: 5705b067a3effc12b7f38ccef23e01ee28e370b99a212fd371ce0c863184c3ec
+  metadata.gz: 7d51a71ea79cd23f422a5235fce6f2e3fb94cae538b01222dd4c23b770985e59
+  data.tar.gz: 29f2501a20ffedf1637ee6d441b637358982761955d6235317f49b5284f17b70
 SHA512:
-  metadata.gz: 99cc273ca6010c9ce2c451e7a7cb3795e4b264b670fb8009436e5b9ddbaacf388e894f0922926bf92113ebf9f211636f4b4fc2a34fc01babcf848327bba798f8
-  data.tar.gz: 3686a34890b5438e5d0ca878cbb0bfb89386f2150267c73ef27754d207c6f918aad3355a312045251d3dea15fc2faa6558433f172b907ae4e913c7b60cc204f4
+  metadata.gz: 7f4855238a2e8731458757336bc964a36d537e77e7e1b30eb73b5c7e270ee59ee021813b620c0997b9781a8e062b10f3a4797eaceffcd9ca731e5e86f11f1e12
+  data.tar.gz: e7d3659d4de54bc0be3aadf6ed96d213bf148ce481306ad8668b589dd892a26a74e78206c6d78dd9577c915e96bab1351c19f08c95ce8b4ae85aaef237b6bd6f

data/lib/kameleoon/client.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require 'kameleoon/targeting/models'
-require 'kameleoon/request'
 require 'kameleoon/exceptions'
 require 'kameleoon/cookie'
+require 'kameleoon/data/custom_data'
 require 'kameleoon/data/user_agent'
 require 'kameleoon/configuration/feature_flag'
 require 'kameleoon/configuration/variation'
@@ -11,6 +11,7 @@ require 'kameleoon/configuration/settings'
 require 'kameleoon/network/activity_event'
 require 'kameleoon/network/experiment_event'
 require 'kameleoon/network/url_provider'
+require 'kameleoon/network/network_manager'
 require 'kameleoon/real_time/real_time_configuration_service'
 require 'kameleoon/storage/variation_storage'
 require 'kameleoon/hybrid/manager'
@@ -30,30 +31,19 @@ module Kameleoon
   # Client for Kameleoon
   #
   class Client
-    include Request
     include Cookie
     include Exception
 
     ##
     # You should create Client with the Client Factory only.
     #
-    def initialize(site_code, path_config_file, interval, default_timeout, client_id = nil, client_secret = nil)
-      config = YAML.load_file(path_config_file)
+    def initialize(site_code, config)
       @site_code = site_code
-      @default_timeout = config['default_timeout'] || default_timeout # in ms
-      refresh_interval = config['actions_configuration_refresh_interval']
-      @interval = refresh_interval.nil? ? interval : "#{refresh_interval}m"
-      data_api_url = config['tracking_url'] || Network::UrlProvider::DEFAULT_DATA_API_URL
-      @url_provider = Network::UrlProvider.new(@site_code, data_api_url)
+      read_config(config)
       @real_time_configuration_service = nil
       @update_configuration_handler = nil
       @fetch_configuration_update_job = nil
-      @client_id = client_id || config['client_id']
-      @client_secret = client_secret || config['client_secret']
-      @data_maximum_size = config['visitor_data_maximum_size'] || 500 # mb
-      @environment = config['environment'] || DEFAULT_ENVIRONMENT
       @settings = Kameleoon::Configuration::Settings.new
-      @verbose_mode = config['verbose_mode'] || false
       @experiments = []
       @feature_flags = []
       @data = {}
@@ -65,6 +55,12 @@ module Kameleoon
         Kameleoon::Storage::CacheFactoryImpl.new,
         method(:log)
       )
+      @network_manager = Network::NetworkManager.new(
+        @environment,
+        @default_timeout,
+        Network::UrlProvider.new(@site_code, Network::UrlProvider::DEFAULT_DATA_API_URL),
+        method(:log)
+      )
     end
 
     ##
@@ -268,7 +264,7 @@ module Kameleoon
     # associated targeting segment conditions were not fulfilled. He should see the reference variation
     # @raise [Kameleoon::Exception::VisitorCodeNotValid] If the visitor code is empty or longer than 255 chars
     #
-    # DEPRECATED. Please use `is_feature_active` instead.
+    # DEPRECATED. Please use `feature_active?` instead.
     def activate_feature(visitor_code, feature_key)
       warn '[DEPRECATION] `activate_feature` is deprecated.  Please use `feature_active?` instead.'
       feature_active?(visitor_code, feature_key)
@@ -399,13 +395,8 @@ module Kameleoon
     #
     # @return [Hash] Hash object of the json object.
     def get_remote_data(key, timeout = @default_timeout)
-      connexion_options = { connect_timeout: (timeout.to_f / 1000.0) }
-      url = @url_provider.make_api_data_get_request_url(key)
-      log "Retrieve API Data connexion: #{connexion_options.inspect}"
-      response = get_sync(url, connexion_options)
-      return nil unless successful_sync?(response)
-
-      JSON.parse(response.body) unless response.nil?
+      response = @network_manager.get_remote_data(key, timeout)
+      JSON.parse(response) if response
     end
 
     ##
@@ -415,6 +406,26 @@ module Kameleoon
       get_remote_data(key, timeout)
     end
 
+    ##
+    # The get_remote_visitor_data is a method for retrieving custom data for
+    # the latest visit of `visitor_code` from Kameleoon Data API and optionally adding it
+    # to the storage so that other methods could decide whether the current visitor is targeted or not.
+    #
+    # @param [String] visitor_code The visitor code for which you want to retrieve the assigned data.
+    # This field is mandatory.
+    # @param [Bool] add_data A boolean indicating whether the method should automatically add retrieved data
+    # for a visitor. If not specified, the default value is `True`. This field is optional.
+    # @param [Int] timeout Timeout for request (in milliseconds). Equals default_timeout in a config file.
+    # This field is optional.
+    #
+    # @return [Array] An array of data assigned to the given visitor.
+    def get_remote_visitor_data(visitor_code, timeout = nil, add_data: true)
+      response = @network_manager.get_remote_visitor_data(visitor_code, timeout)
+      data_array = parse_custom_data_array(visitor_code, response)
+      add_data(visitor_code, *data_array) if add_data && !data_array.empty?
+      data_array
+    end
+
     ##
     # Returns a list of all experiment ids
     #
@@ -494,11 +505,23 @@ module Kameleoon
     private
 
     REFERENCE = 0
-    DEFAULT_ENVIRONMENT = 'production'
     CACHE_EXPIRATION_TIMEOUT = 5
     attr :site_code, :client_id, :client_secret, :access_token, :experiments, :feature_flags, :scheduler, :data,
          :tracking_url, :default_timeout, :interval, :memory_limit, :verbose_mode
 
+    def read_config(config)
+      @client_id = config.client_id
+      @client_secret = config.client_secret
+      @default_timeout = config.default_timeout # in ms
+      @interval = "#{config.configuration_refresh_interval}m"
+      @data_maximum_size = config.visitor_data_maximum_size
+      @environment = config.environment
+      @verbose_mode = config.verbose_mode
+      if @client_id.nil? || @client_secret.nil?
+        warn 'Kameleoon SDK: Credentials are invalid: client_id or client_secret (or both) are empty'
+      end
+    end
+
     def fetch_configuration
       Rufus::Scheduler.singleton.in '0s' do
         log('Initial configuration fetch is started.')
@@ -509,7 +532,7 @@ module Kameleoon
     def fetch_configuration_job(time_stamp = nil)
       EM.synchrony do
         begin
-          ok = obtain_configuration(@environment, time_stamp)
+          ok = obtain_configuration(time_stamp)
           if !ok && @settings.real_time_update
             @settings.real_time_update = false
             log('Switching to polling mode due to failed fetch')
@@ -542,7 +565,7 @@ module Kameleoon
     def start_real_time_configuration_service_if_needed
       return unless @real_time_configuration_service.nil?
 
-      url = @url_provider.make_real_time_url
+      url = @network_manager.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(url, fetch_func, method(:log))
@@ -579,13 +602,12 @@ module Kameleoon
     #   { 'field' => field, 'operator' => operator, 'parameters' => parameters }
     # end
 
-    def obtain_configuration(environment = @environment, time_stamp = nil)
+    def obtain_configuration(time_stamp = nil)
       log 'Fetching configuration from Client-Config service'
-      url = @url_provider.make_configuration_url(environment, time_stamp)
-      request = request_configuration(url)
-      return false unless request
+      response = @network_manager.fetch_configuration(time_stamp)
+      return false unless response
 
-      configuration = JSON.parse(request.response)
+      configuration = JSON.parse(response)
       @experiments = Kameleoon::Configuration::Experiment.create_from_array(configuration['experiments']) ||
                      @experiments
       @feature_flags = Kameleoon::Configuration::FeatureFlag.create_from_array(
@@ -593,7 +615,7 @@ module Kameleoon
       )
       @settings.update(configuration['configuration'])
       call_update_handler_if_needed(!time_stamp.nil?)
-      log "Feature flags are fetched: #{request.inspect}"
+      log "Feature flags are fetched: #{response.inspect}"
       true
     end
 
@@ -616,15 +638,6 @@ module Kameleoon
       nil
     end
 
-    def request_configuration(url)
-      request = EM::Synchrony.sync get({}, url)
-      unless successful?(request)
-        log "Failed to fetch #{request.inspect}"
-        return false
-      end
-      request
-    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
@@ -760,39 +773,15 @@ module Kameleoon
     ##
     # helper method for sending tracking requests for new FF
     def _send_tracking_request(visitor_code, experiment_id = nil, variation_id = nil)
+      user_agent = @user_agents[visitor_code]&.value
       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
         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
+      @network_manager.send_tracking_data(visitor_code, data_not_sent, user_agent)
     end
 
     ##
@@ -808,5 +797,28 @@ module Kameleoon
               'Unknown type for feature variable'
       end
     end
+
+    ##
+    # helper method used by `get_remote_visitor_data`
+    def parse_custom_data_array(visitor_code, response)
+      return [] unless response
+
+      raw = JSON.parse(response)
+      latest_record = raw['currentVisit']
+      if latest_record.nil?
+        previous_visits = raw['previousVisits']
+        return [] unless previous_visits
+
+        latest_record = previous_visits.first
+      end
+      events = latest_record['customDataEvents']
+      return [] if events.nil?
+
+      events.map { |ev| ev['data'] }.compact
+            .map { |jcd| CustomData.new(jcd['index'] || -1, *(jcd['valuesCountMap'] || {}).keys) }
+    rescue StandardError => e
+      log("Parsing of visitor data of '#{visitor_code}' failed: #{e}")
+      []
+    end
   end
 end

data/lib/kameleoon/client_config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  # Client configuration which can be used instead of an external configuration file
+  class ClientConfig
+    CONFIGURATION_UPDATE_INTERVAL = 60
+    VISITOR_DATA_MAXIMUM_SIZE = 500
+    DEFAULT_TIMEOUT = 2000 # milli-seconds
+
+    attr_reader :client_id, :client_secret, :data_refresh_interval, :default_timeout, :configuration_refresh_interval,
+                :visitor_data_maximum_size, :environment, :verbose_mode
+
+    def initialize(
+      client_id: nil,
+      client_secret: nil,
+      configuration_refresh_interval: CONFIGURATION_UPDATE_INTERVAL,
+      default_timeout: DEFAULT_TIMEOUT,
+      visitor_data_maximum_size: VISITOR_DATA_MAXIMUM_SIZE,
+      environment: nil,
+      verbose_mode: false
+    )
+      @client_id = client_id
+      @client_secret = client_secret
+      @configuration_refresh_interval = configuration_refresh_interval || CONFIGURATION_UPDATE_INTERVAL
+      @default_timeout = default_timeout || DEFAULT_TIMEOUT
+      @visitor_data_maximum_size = visitor_data_maximum_size || VISITOR_DATA_MAXIMUM_SIZE
+      @environment = environment
+      @verbose_mode = verbose_mode || false
+    end
+
+    def self.make_from_yaml(yaml)
+      yaml ||= {}
+      ClientConfig.new(
+        client_id: yaml['client_id'],
+        client_secret: yaml['client_secret'],
+        configuration_refresh_interval: yaml['actions_configuration_refresh_interval'],
+        default_timeout: yaml['default_timeout'],
+        visitor_data_maximum_size: yaml['visitor_data_maximum_size'],
+        environment: yaml['environment'],
+        verbose_mode: yaml['verbose_mode']
+      )
+    end
+  end
+end

data/lib/kameleoon/data/browser.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'json'
+require 'kameleoon/network/uri_helper'
 require_relative 'data'
 
 module Kameleoon
@@ -24,10 +27,13 @@ module Kameleoon
     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
+      params = {
+        eventType: 'staticData',
+        browserIndex: @type,
+        nonce: nonce
+      }
+      params[:browserVersion] = @version if @version.is_a?(Integer) || (@version.is_a?(Float) && !@version.nan?)
+      Kameleoon::Network::UriHelper.encode_query(params)
     end
   end
 end

data/lib/kameleoon/data/conversion.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'kameleoon/network/uri_helper'
 require_relative 'data'
 
 module Kameleoon
@@ -19,8 +20,14 @@ module Kameleoon
     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}"
+      params = {
+        eventType: 'conversion',
+        goalId: @goal_id,
+        revenue: @revenue,
+        negative: @negative,
+        nonce: nonce
+      }
+      Kameleoon::Network::UriHelper.encode_query(params)
     end
   end
 end

data/lib/kameleoon/data/custom_data.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'kameleoon/network/uri_helper'
 require_relative 'data'
 
 module Kameleoon
@@ -46,8 +47,14 @@ module Kameleoon
       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}"
+      params = {
+        eventType: 'customData',
+        index: @id,
+        valuesCountMap: str_values,
+        overwrite: 'true',
+        nonce: nonce
+      }
+      Kameleoon::Network::UriHelper.encode_query(params)
     end
   end
 end

data/lib/kameleoon/data/data.rb

@@ -28,8 +28,11 @@ module Kameleoon
       raise KameleoonError.new('ToDo: implement this method.'), 'ToDo: implement this method.'
     end
 
-    def self.encode(url)
-      Network::UriHelper.encode_uri(url)
+    private
+
+    def nonce
+      @nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH) if @nonce.nil?
+      @nonce
     end
   end
 end

data/lib/kameleoon/data/device.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'kameleoon/network/uri_helper'
 require_relative 'data'
 
 module Kameleoon
@@ -19,8 +20,12 @@ module Kameleoon
     end
 
     def obtain_full_post_text_line
-      nonce = Kameleoon::Utils.generate_random_string(NONCE_LENGTH)
-      "eventType=staticData&deviceType=#{@device_type}&nonce=#{nonce}"
+      params = {
+        eventType: 'staticData',
+        deviceType: @device_type,
+        nonce: nonce
+      }
+      Kameleoon::Network::UriHelper.encode_query(params)
     end
   end
 end

data/lib/kameleoon/data/page_view.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'kameleoon/network/uri_helper'
 require_relative 'data'
 
 module Kameleoon
@@ -19,13 +20,15 @@ module Kameleoon
     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}"
+      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/factory.rb

@@ -1,29 +1,43 @@
 # frozen_string_literal: true
 
 require 'kameleoon/client'
+require 'kameleoon/client_config'
 
 module Kameleoon
   # A Factory class for creating kameleoon clients
   module ClientFactory
-    CONFIGURATION_UPDATE_INTERVAL = '60m'
     CONFIG_PATH = '/etc/kameleoon/client-ruby.yaml'
-    DEFAULT_TIMEOUT = 2000 # milli-seconds
 
     @clients = {}
 
-    def self.create(site_code, config_path = CONFIG_PATH, client_id = nil, client_secret = nil)
-      if @clients[site_code].nil?
-        client = Client.new(site_code, config_path, CONFIGURATION_UPDATE_INTERVAL,
-                            DEFAULT_TIMEOUT, client_id, client_secret)
+    def self.create(site_code, config_path = CONFIG_PATH, config: nil)
+      if config.nil?
+        config_yaml = YAML.load_file(config_path) if File.exist?(config_path)
+        if config_yaml.nil?
+          warn "Kameleoon SDK: Configuration file with path #{config_path} does not exist" if config_yaml.nil?
+          config_yaml = {}
+        end
+      end
+      environment = config&.environment || (config_yaml || {})['environment']
+      client = @clients[get_client_key(site_code, environment)]
+      if client.nil?
+        config = ClientConfig.make_from_yaml(config_yaml) if config.nil?
+        client = Client.new(site_code, config)
         client.send(:log, "Client created with site code: #{site_code}")
         client.send(:fetch_configuration)
         @clients.store(site_code, client)
       end
-      @clients[site_code]
+      client
+    end
+
+    def self.forget(site_code, environment = '')
+      @clients.delete(get_client_key(site_code, environment))
     end
 
-    def self.forget(site_code)
-      @clients.delete(site_code)
+    private_class_method
+
+    def self.get_client_key(site_code, environment)
+      site_code + (environment || '')
     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/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

@@ -21,6 +21,7 @@ module Kameleoon
       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' => '!',

data/lib/kameleoon/version.rb

@@ -2,7 +2,7 @@
 
 module Kameleoon
   SDK_NAME = 'RUBY'
-  SDK_VERSION = '2.1.1'
+  SDK_VERSION = '2.3.0'
 
   # SdkManager is a helper method for fetching / obtaining version of SDK from string
   class SdkVersion

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.3.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-28 00:00:00.000000000 Z
+date: 2023-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -76,6 +76,7 @@ files:
 - README.md
 - lib/kameleoon.rb
 - lib/kameleoon/client.rb
+- lib/kameleoon/client_config.rb
 - lib/kameleoon/configuration/experiment.rb
 - lib/kameleoon/configuration/feature_flag.rb
 - lib/kameleoon/configuration/rule.rb
@@ -95,7 +96,13 @@ files:
 - lib/kameleoon/factory.rb
 - lib/kameleoon/hybrid/manager.rb
 - lib/kameleoon/network/activity_event.rb
+- lib/kameleoon/network/content_type.rb
 - lib/kameleoon/network/experiment_event.rb
+- lib/kameleoon/network/method.rb
+- lib/kameleoon/network/net_provider.rb
+- lib/kameleoon/network/network_manager.rb
+- lib/kameleoon/network/request.rb
+- lib/kameleoon/network/response.rb
 - lib/kameleoon/network/uri_helper.rb
 - lib/kameleoon/network/url_provider.rb
 - lib/kameleoon/real_time/real_time_configuration_service.rb
@@ -103,7 +110,6 @@ files:
 - lib/kameleoon/real_time/sse_client.rb
 - lib/kameleoon/real_time/sse_message.rb
 - lib/kameleoon/real_time/sse_request.rb
-- lib/kameleoon/request.rb
 - lib/kameleoon/storage/cache.rb
 - lib/kameleoon/storage/cache_factory.rb
 - lib/kameleoon/storage/variation_storage.rb

data/lib/kameleoon/request.rb

@@ -1,76 +0,0 @@
-require 'em-synchrony/em-http'
-require 'kameleoon/version'
-require 'net/http'
-
-module Kameleoon
-  # @api private
-  module Request
-    protected
-
-    module Method
-      GET = 'get'.freeze
-      POST = 'post'.freeze
-    end
-
-    def get(request_options, url, connexion_options = {})
-      request(Method::GET, request_options, url, connexion_options)
-    end
-
-    def post(request_options, url, connexion_options = {})
-      request(Method::POST, request_options, url, connexion_options)
-    end
-
-    def get_sync(url, connexion_options = {})
-      request_sync(Method::GET, url, connexion_options, {})
-    end
-
-    def post_sync(request_options, url, connexion_options = {})
-      request_sync(Method::POST, url, connexion_options, request_options)
-    end
-
-    private
-
-    def request(method, request_options, url, connexion_options)
-      connexion_options[:tls] = { verify_peer: false }
-      case method
-        when Method::POST then
-          return EventMachine::HttpRequest.new(url, connexion_options).apost request_options
-        when Method::GET then
-          return EventMachine::HttpRequest.new(url, connexion_options).get request_options
-        else
-          print 'Unknown request type'
-          return false
-      end
-    end
-
-    def request_sync(method, url, connexion_options, request_options)
-      request_options = {} if request_options.nil?
-      case method
-        when Method::GET then
-          uri = URI(url)
-          request = Net::HTTP.new(url)
-          response = Net::HTTP.get_response(uri)
-          response
-        when Method::POST then
-          uri = URI.parse(url)
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-          request = Net::HTTP::Post.new(uri, initheader = request_options[:head])
-          request.body = request_options[:body]
-          response = http.request(request)
-          response
-        else
-          print "Unknown request type"
-          return false
-      end
-    end
-
-    def successful?(request)
-      !request.nil? && request != false && /20\d/.match(request.response_header.status.to_s)
-    end
-
-    def successful_sync?(response)
-      !response.nil? && response != false && response.is_a?(Net::HTTPSuccess)
-    end
-  end
-end