kameleoon-client-ruby 1.0.0 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0d398647ef17fa8d33046f2f591973a57a00fde17fef994d955f23ea474538d
-  data.tar.gz: fc466cc6b762e1b4759dee2de2914c33ce27274b90bfe00394db5a80017f186e
+  metadata.gz: e0deee13cb73acd60d605f479ab0e2ebf374e38e7516d9bea0590b0adbdd7f53
+  data.tar.gz: 7c06c8d843f6f291d946375d495a3d573e31f932942c5b6edb2f86abf4d9183f
 SHA512:
-  metadata.gz: ad96e42e9c7b75436dca8a6529d2118693b94be8edc7a6d7ee35bfa5cd0909235885f383a313b306912bb79a43aac6b8aee0c6e44d55135c79cca158113fba50
-  data.tar.gz: d2e75d812cf12088420984120337be790c7b3c60574181572d995f9ac613cf5b884820fddc4e7e2b4938ed3444f27d298e883f1560da34d83150d4b71207077a
+  metadata.gz: 8d14ce02c0a2577988a0161292683e9a455c9532dda0fd69e5428d0f0a2bd08bb38114cf8b161d4a123921e08429cf1db126f7b3033d43a0889c4f6eea2d064b
+  data.tar.gz: de09c74c6587cbd9f53f44a6673b1d3e2832d3aa135376405d0e7eaef9933bc0891243cc34cb039d2eb72b8b8fa5eeb5045b9e4c69b4a4979aabcae154e8361b

data/README.md

@@ -6,7 +6,7 @@ This is the repository for the Kameleoon Ruby SDK.
 #### Prerequisite:
 * [Install ruby](https://www.ruby-lang.org/en/documentation/installation)
 
-#### Build and install:
+#### Build and install the gem:
 * Run `./buildAndInstallGem.sh`
 
 ### How to run tests
@@ -14,5 +14,9 @@ This is the repository for the Kameleoon Ruby SDK.
 * Build and install Kameleoon Gem locally (infos above).
 * Install rake: `gem install rake`
 
-#### Test:
-* Run `rake test`
+#### Run Tests:
+##### Unit
+* Run `./test.sh -u`
+##### Integration
+Make sure you kill manually the server test app after the tests are done.
+* Run `./test.sh -i`

data/lib/kameleoon.rb

@@ -2,4 +2,4 @@
 # Kameleoon Ruby Client SDK
 #
 require "kameleoon/factory"
-require "kameleoon/client"
+require "kameleoon/client"

data/lib/kameleoon/client.rb

@@ -19,16 +19,18 @@ module Kameleoon
 
     ##
     # You should create Client with the Client Factory only.
+    #
     def initialize(site_code, path_config_file, blocking, interval, default_timeout, client_id = nil, client_secret = nil)
       config = YAML.load_file(path_config_file)
       @site_code = site_code
       @blocking = blocking
-      @default_timeout = config['default_timeout'] || default_timeout
-      @interval = config['actions_configuration_refresh_interval'] || interval
+      @default_timeout = config['default_timeout'] || default_timeout # in ms
+      @interval = config['actions_configuration_refresh_interval'].to_s + 'm' || interval
       @tracking_url = config['tracking_url'] || "https://api-ssx.kameleoon.com"
       @client_id = client_id || config['client_id']
       @client_secret = client_secret || config['client_secret']
-      @data_maximum_size = config['visitor_data_maximum_size'] || 500
+      @data_maximum_size = config['visitor_data_maximum_size'] || 500 # mb
+      @verbose_mode = config['verbose_mode'] || false
       @experiments = []
       @feature_flags = []
       @data = {}
@@ -37,7 +39,6 @@ module Kameleoon
     ##
     # Obtain a visitor code.
     #
-    #
     # This method should be called to obtain the Kameleoon visitor_code for the current visitor.
     # This is especially important when using Kameleoon in a mixed front-end and back-end environment,
     # where user identification consistency must be guaranteed.
@@ -51,10 +52,9 @@ module Kameleoon
     # In any case, the server-side (via HTTP header) kameleoonVisitorCode cookie is set with the value. Then this
     # identifier value is finally returned by the method.
     #
-    #
     # @param [Hash] cookies Cookies of the request.
     # @param [String] top_level_domain Top level domain of your website, settled while writing cookie.
-    # @param [String] default_visitor_vode - Optional - Define your default visitor_code (maximum length 100 chars).
+    # @param [String] default_visitor_code - Optional - Define your default visitor_code (maximum length 100 chars).
     #
     # @return [String] visitor code
     #
@@ -68,6 +68,7 @@ module Kameleoon
 
     ##
     # Trigger an experiment.
+    #
     # If such a visitor_code has never been associated with any variation, the SDK returns a randomly selected variation.
     # If a user with a given visitor_code is already registered with a variation, it will detect the previously
     # registered variation and return the variation_id.
@@ -77,29 +78,33 @@ module Kameleoon
     # @param [String] visitor_code Visitor code
     # @param [Integer] experiment_id Id of the experiment you want to trigger.
     #
-    # @return [Integer] Variation id
+    # @return [Integer] Id of the variation
     #
-    # @raise [Kameleoon::Exception::ExperimentNotFound] Raise when experiment configuration is not found
+    # @raise [Kameleoon::Exception::ExperimentConfigurationNotFound] Raise when experiment configuration is not found
     # @raise [Kameleoon::Exception::NotActivated] The visitor triggered the experiment, but did not activate it. Usually, this happens because the user has been associated with excluded traffic
     # @raise [Kameleoon::Exception::NotTargeted] The visitor is not targeted by the experiment, as the associated targeting segment conditions were not fulfilled. He should see the reference variation
+    #
     def trigger_experiment(visitor_code, experiment_id, timeout = @default_timeout)
       experiment = @experiments.find { |experiment| experiment['id'].to_s == experiment_id.to_s }
       if experiment.nil?
-        raise Exception::ExperimentNotFound.new(experiment_id)
+        raise Exception::ExperimentConfigurationNotFound.new(experiment_id)
       end
       if @blocking
         variation_id = nil
         EM.synchrony do
-          connexion_options = { :connect_timeout => timeout }
+          connexion_options = { :connect_timeout => (timeout.to_f / 1000.0) }
           body = @data.values.flatten.select { |data| !data.sent }.map { |data| data.obtain_full_post_text_line }
                       .join("\n") || ""
           path = get_experiment_register_url(visitor_code, experiment_id)
           request_options = { :path => path, :body => body }
+          log "Trigger experiment request: " + request_options.inspect
+          log "Trigger experiment connexion:" + connexion_options.inspect
           request = EM::Synchrony.sync post(request_options, @tracking_url, connexion_options)
           if is_successful(request)
             variation_id = request.response
           else
-            raise Exception::ExperimentNotFound.new(experiment_id) if variation_id.nil?
+            log "Failed to trigger experiment: " + request.inspect
+            raise Exception::ExperimentConfigurationNotFound.new(experiment_id) if variation_id.nil?
           end
           EM.stop
         end
@@ -111,16 +116,16 @@ module Kameleoon
         variation_id.to_i
       else
         visitor_data = @data.select { |key, value| key.to_s == visitor_code }.values.flatten! || []
-        if experiment['targetingSegment'].check_tree(visitor_data)
+        if experiment['targetingSegment'].nil? || experiment['targetingSegment'].check_tree(visitor_data)
           threshold = obtain_hash_double(visitor_code, experiment['respoolTime'], experiment['id'])
           experiment['deviations'].each do |key, value|
             threshold -= value
             if threshold < 0
-              post_beacon("experimentTracking", visitor_code, experiment_id, key)
+              track_experiment(visitor_code, experiment_id, key)
               return key.to_s.to_i
             end
           end
-          post_beacon("experimentTracking", visitor_code, experiment_id, REFERENCE, true)
+          track_experiment(visitor_code, experiment_id, REFERENCE, true)
           raise Exception::NotActivated.new(visitor_code)
         end
         raise Exception::NotTargeted.new(visitor_code)
@@ -128,7 +133,9 @@ module Kameleoon
     end
 
     ##
-    # Associate various data to a visitor. Note that this method doesn't return any value and doesn't interact with the
+    # Associate various data to a visitor.
+    #
+    # Note that this method doesn't return any value and doesn't interact with the
     # Kameleoon back-end servers by itself. Instead, the declared data is saved for future sending via the flush method.
     # This reduces the number of server calls made, as data is usually grouped into a single server call triggered by
     # the execution of the flush method.
@@ -151,13 +158,14 @@ module Kameleoon
 
     ##
     # Track conversions on a particular goal
+    #
     # This method requires visitor_code and goal_id to track conversion on this particular goal.
     # In addition, this method also accepts revenue as a third optional argument to track revenue. The visitor_code usually is identical to the one that was used when triggering the experiment.
     # The track_conversion method doesn't return any value. This method is non-blocking as the server call is made asynchronously.
     #
     # @param [String] visitor_code Visitor code
     # @param [Integer] goal_id Id of the goal
-    # @param [Float] revenue Revenue of the conversion. This field is optional
+    # @param [Float] revenue Optional - Revenue of the conversion.
     #
     def track_conversion(visitor_code, goal_id, revenue = 0.0)
       add_data(visitor_code, Conversion.new(goal_id, revenue))
@@ -166,6 +174,7 @@ module Kameleoon
 
     ##
     # Flush the associated data.
+    #
     # The data added with the method add_data, is not directly sent to the kameleoon servers.
     # It's stored and accumulated until it is sent automatically by the trigger_experiment or track_conversion methods.
     # With this method you can manually send it.
@@ -173,11 +182,12 @@ module Kameleoon
     # @param [String] visitor_code Optional field - Visitor code, without visitor code it flush all of the data
     #
     def flush(visitor_code = nil)
-      post_beacon("dataTracking", visitor_code)
+      track_data(visitor_code)
     end
 
     ##
     # Obtain variation associated data.
+    #
     # To retrieve JSON data associated with a variation, call the obtain_variation_associated_data method of our SDK.
     # The JSON data usually represents some metadata of the variation, and can be configured on our web application
     # interface or via our Automation API.
@@ -186,20 +196,21 @@ module Kameleoon
     #
     # @param [Integer] variation_id
     #
-    # @return [String] json string of the variation data.
+    # @return [Hash] Hash object of the json object.
     #
     # @raise [Kameleoon::Exception::VariationNotFound] Raise exception if the variation is not found.
+    #
     def obtain_variation_associated_data(variation_id)
       variation = @experiments.map { |experiment| experiment['variations'] }.flatten.select { |variation| variation['id'].to_i == variation_id.to_i }.first
       if variation.nil?
         raise Exception::VariationNotFound.new(variation_id)
       else
-        variation['customJson'].to_json
+        variation['customJson']
       end
     end
 
     #
-    # Method to activate a feature toggle.
+    # Activate a feature toggle.
     #
     # This method takes a visitor_code and feature_key (or feature_id) as mandatory arguments to check if the specified feature will be active for a given user.
     # If such a user has never been associated with this feature flag, the SDK returns a boolean value randomly (true if the user should have this feature or false if not). If a user with a given visitorCode is already registered with this feature flag, it will detect the previous featureFlag value.
@@ -208,26 +219,31 @@ module Kameleoon
     # @param [String] visitor_code
     # @param [String | Integer] feature_key
     #
-    # @raise [Kameleoon::Exception::FeatureFlagNotFound]
+    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound]
     # @raise [Kameleoon::Exception::NotTargeted]
+    #
     def activate_feature(visitor_code, feature_key, timeout = @default_timeout)
       feature_flag = get_feature_flag(feature_key)
       id = feature_flag['id']
       if @blocking
         result = nil
         EM.synchrony do
-          connexion_options = { :connect_timeout => timeout }
+          connexion_options = { :connect_timeout => (timeout.to_f / 1000.0) }
           request_options = {
             :path => get_experiment_register_url(visitor_code, id),
-            :body => (select_data_to_sent(visitor_code).values.map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8")
+            :body => (data_not_sent(visitor_code).values.map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8")
           }
+          log "Activate feature request: " + request_options.inspect
+          log "Activate feature connexion:" + connexion_options.inspect
           request = EM::Synchrony.sync post(request_options, @tracking_url, connexion_options)
           if is_successful(request)
             result = request.response
+          else
+            log "Failed to get activation:" + result.inspect
           end
           EM.stop
         end
-        raise Exception::FeatureFlagNotFound.new(id) if result.nil?
+        raise Exception::FeatureConfigurationNotFound.new(id) if result.nil?
         result.to_s != "null"
 
       else
@@ -235,10 +251,10 @@ module Kameleoon
         if feature_flag['targetingSegment'].nil? || feature_flag['targetingSegment'].check_tree(visitor_data)
           threshold = obtain_hash_double(visitor_code, {}, id)
           if threshold <= feature_flag['expositionRate']
-            post_beacon("experimentTracking", visitor_code, id, feature_flag["variationsId"].first)
+            track_experiment(visitor_code, id, feature_flag["variationsId"].first)
             return true
           else
-            post_beacon("experimentTracking", visitor_code, id, REFERENCE, true)
+            track_experiment(visitor_code, id, REFERENCE, true)
             return false
           end
         else
@@ -248,17 +264,21 @@ module Kameleoon
     end
 
     ##
-    #  Method To retrieve a feature variable. A feature variable can be changed easily via our web application.
+    # Retrieve a feature variable.
+    #
+    # A feature variable can be changed easily via our web application.
     #
     # @param [String | Integer] feature_key
     # @param [String ] variable_key
     #
-    # @raise [Kameleoon::Exception::FeatureFlagNotFound]
+    # @raise [Kameleoon::Exception::FeatureConfigurationNotFound]
+    # @raise [Kameleoon::Exception::FeatureVariableNotFound]
+    #
     def obtain_feature_variable(feature_key, variable_key)
       feature_flag = get_feature_flag(feature_key)
       custom_json = feature_flag["variations"].first['customJson'][variable_key.to_s]
       if custom_json.nil?
-        raise Exception::FeatureFlagNotFound.new("Feature variable not found")
+        raise Exception::FeatureVariableNotFound.new("Feature variable not found")
       end
       case custom_json['type']
       when "Boolean"
@@ -268,9 +288,9 @@ module Kameleoon
       when "Number"
         return custom_json['value'].to_f
       when "Json"
-        return custom_json['value'].to_json
+        return custom_json['value']
       else
-        raise Exception::FeatureFlagNotFound.new("Unknown type for feature variable")
+        raise TypeError.new("Unknown type for feature variable")
       end
     end
 
@@ -278,15 +298,16 @@ module Kameleoon
     API_SSX_URL = "https://api-ssx.kameleoon.com"
     REFERENCE = 0
     attr :site_code, :client_id, :client_secret, :access_token, :experiments, :feature_flags, :scheduler, :data,
-         :blocking, :tracking_url, :default_timeout, :interval, :memory_limit
+         :blocking, :tracking_url, :default_timeout, :interval, :memory_limit, :verbose_mode
 
     def fetch_configuration
-      print "=> Starting Scheduler"
       @scheduler = Rufus::Scheduler.singleton
       @scheduler.every @interval do
+        log("Scheduled job to fetch configuration is starting.")
         fetch_configuration_job
       end
       @scheduler.schedule '0s' do
+        log("Start-up, fetching is starting")
         fetch_configuration_job
       end
     end
@@ -300,8 +321,8 @@ module Kameleoon
           @feature_flags ||= []
         else
           site_id = site.first['id']
-          @experiments = obtain_tests(site_id)
-          @feature_flags = obtain_feature_flags(site_id)
+          @experiments = obtain_tests(site_id) || @experiments
+          @feature_flags = obtain_feature_flags(site_id) || @feature_flags
         end
         EM.stop
       end
@@ -322,15 +343,19 @@ module Kameleoon
     end
 
     def obtain_site
+      log "Fetching site"
       query_params = { 'perPage' => 1 }
       filters = [hash_filter('code', 'EQUAL', [@site_code])]
       request = fetch_one('sites', query_params, filters)
       if request != false
-        JSON.parse(request.response)
+        sites = JSON.parse(request.response)
+        log "Sites are fetched: " + sites.inspect
+        sites
       end
     end
 
     def obtain_access_token
+      log "Fetching bearer token"
       body = {
         'grant_type' => 'client_credentials',
         'client_id' => @client_id,
@@ -341,6 +366,9 @@ module Kameleoon
       request = EM::Synchrony.sync post({ :path => '/oauth/token', :body => body, :head => header })
       if is_successful(request)
         @access_token = JSON.parse(request.response)['access_token']
+        log "Bearer Token is fetched: " + @access_token.to_s
+      else
+        log "Failed to fetch bearer token: " + request.inspect
       end
     end
 
@@ -369,26 +397,32 @@ module Kameleoon
     end
 
     def obtain_tests(site_id, per_page = -1)
+      log "Fetching experiments"
       query_values = { 'perPage' => per_page }
       filters = [
         hash_filter('siteId', 'EQUAL', [site_id]),
         hash_filter('status', 'EQUAL', ['ACTIVE']),
         hash_filter('type', 'IN', ['SERVER_SIDE', 'HYBRID'])
       ]
-      fetch_all('experiments', query_values, filters).map { |it| JSON.parse(it.response) }.flatten.map do |test|
+      experiments = fetch_all('experiments', query_values, filters).map { |it| JSON.parse(it.response) }.flatten.map do |test|
         complete_experiment(test)
       end
+      log "Experiment are fetched: " + experiments.inspect
+      experiments
     end
 
     def obtain_feature_flags(site_id, per_page = -1)
+      log "Fetching feature flags"
       query_values = { 'perPage' => per_page }
       filters = [
         hash_filter('siteId', 'EQUAL', [site_id]),
         hash_filter('status', 'EQUAL', ['ACTIVE'])
       ]
-      fetch_all('feature-flags', query_values, filters).map { |it| JSON.parse(it.response) }.flatten.map do |ff|
+      feature_flags = fetch_all('feature-flags', query_values, filters).map { |it| JSON.parse(it.response) }.flatten.map do |ff|
         complete_experiment(ff)
       end
+      log "Feature flags are fetched: " + feature_flags.inspect
+      feature_flags
     end
 
     def fetch_all(path, query_values = {}, filters = [])
@@ -411,6 +445,7 @@ module Kameleoon
       end
       request = EM::Synchrony.sync get({ :path => path, :query => query_values, :head => hash_headers })
       unless is_successful(request)
+        log "Failed to fetch" + request.inspect
         return false
       end
       request
@@ -437,6 +472,10 @@ module Kameleoon
       url
     end
 
+    def get_data_register_url(visitor_code)
+      "/dataTracking?" + URI.encode_www_form(get_common_ssx_parameters(visitor_code))
+    end
+
     def get_feature_flag(feature_key)
       if feature_key.is_a?(String)
         feature_flag = @feature_flags.select { |ff| ff['identificationKey'] == feature_key}.first
@@ -446,24 +485,53 @@ module Kameleoon
         raise TypeError.new("Feature key should be a String or an Integer.")
       end
       if feature_flag.nil?
-        raise Exception::FeatureFlagNotFound.new(feature_key)
+        raise Exception::FeatureConfigurationNotFound.new(feature_key)
       end
       feature_flag
     end
 
-    def post_beacon(type = "dataTracking", visitor_code = nil, experiment_id = nil, variation_id = nil, none_variation = false)
+    def track_experiment(visitor_code, experiment_id, variation_id = nil, none_variation = false)
+      data_not_sent = data_not_sent(visitor_code)
+      options = {
+        :path => get_experiment_register_url(visitor_code, experiment_id, variation_id, none_variation),
+        :body => ((data_not_sent.values[0] || []).map{ |it| it.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8"),
+        :head => { "Content-Type" => "text/plain"}
+      }
+      trial = 0
+      log "Start post tracking experiment: " + data_not_sent.inspect
+      Thread.new do
+        EM.synchrony do
+          while trial < 10
+            request = EM::Synchrony.sync post(options, @tracking_url)
+            log "Request " + request.inspect
+            if is_successful(request)
+              (data_not_sent.values[0] || []).each { |it| it.sent = true }
+              EM.stop
+            end
+            trial += 1
+          end
+          EM.stop
+        end
+        log "Post to experiment tracking is done after " + trial.to_s + " trials"
+        Thread.exit
+      end
+    end
+
+    def track_data(visitor_code = nil)
       Thread.new do
         EM.synchrony do
-          entries = select_data_to_sent(visitor_code)
           trials = 10
           concurrency = 1
-          while !entries.empty? && trials > 0
-            EM::Synchrony::Iterator.new(entries, concurrency).map do |entry, iter|
+          data_not_sent = data_not_sent(visitor_code)
+          log "Start post tracking data: " + data_not_sent.inspect
+          while trials > 0 && !data_not_sent.empty?
+            EM::Synchrony::Iterator.new(data_not_sent, concurrency).map do |entry, iter|
               options = {
-                :path => build_beacon_path(type, entry.first || visitor_code, experiment_id, variation_id, none_variation),
+                :path => get_data_register_url(entry.first),
                 :body => (entry.last.map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8"),
                 :head => { "Content-Type" => "text/plain" }
               }
+              log "Post tracking data for visitor_code: " + entry.first + " with options: " + options.inspect
               request = post(options, @tracking_url)
               request.callback {
                 if is_successful(request)
@@ -473,16 +541,17 @@ module Kameleoon
               }
               request.errback { iter.return(request) }
             end
-            entries = select_data_to_sent(visitor_code)
+            data_not_sent = data_not_sent(visitor_code)
             trials -= 1
           end
+          log "Post to data tracking is done."
           EM.stop
         end
         Thread.exit
       end
     end
 
-    def select_data_to_sent(visitor_code)
+    def data_not_sent(visitor_code = nil)
       if visitor_code.nil?
         @data.select {|key, values| values.any? {|data| !data.sent}}
       else
@@ -490,13 +559,9 @@ module Kameleoon
       end
     end
 
-    def build_beacon_path(type, visitor_code, experiment_id = nil, variation_id = nil, none_variation = nil)
-      if type == "dataTracking"
-        return "/dataTracking?" + URI.encode_www_form(get_common_ssx_parameters(visitor_code))
-      elsif type == "experimentTracking"
-        return get_experiment_register_url(visitor_code, experiment_id, variation_id, none_variation)
-      else
-        raise TypeError("Unknown type for post_beacon: " + type.to_s)
+    def log(text)
+      if @verbose_mode
+        print "Kameleoon Log: " + text.to_s + "\n"
       end
     end
   end

data/lib/kameleoon/exceptions.rb

@@ -15,16 +15,21 @@ module Kameleoon
         super("Variation " + id.to_s)
       end
     end
-    class ExperimentNotFound < NotFound
+    class ExperimentConfigurationNotFound	 < NotFound
       def initialize(id = "")
         super("Experiment " + id.to_s)
       end
     end
-    class FeatureFlagNotFound < NotFound
+    class FeatureConfigurationNotFound < NotFound
       def initialize(id = "")
         super("Feature flag " + id.to_s)
       end
     end
+    class FeatureVariableNotFound < NotFound
+      def initialize(key = "")
+        super("Feature variable " + key.to_s)
+      end
+    end
     class CredentialsNotFound < NotFound
       def initialize
         super("Credentials")

data/lib/kameleoon/factory.rb

@@ -2,9 +2,9 @@ require 'kameleoon/client'
 
 module Kameleoon
   module ClientFactory
-    CONFIGURATION_UPDATE_INTERVAL= "60m"
+    CONFIGURATION_UPDATE_INTERVAL = '60m'
     CONFIG_PATH = "/etc/kameleoon/client-ruby.yaml"
-    DEFAULT_TIMEOUT = 2 #seconds
+    DEFAULT_TIMEOUT = 2000 #milli-seconds
 
     ##
     # Create a kameleoon client object, each call create a new client.
@@ -17,6 +17,8 @@ module Kameleoon
     #
     def self.create(site_code, blocking = false, config_path = CONFIG_PATH, client_id = nil, client_secret = nil)
       client = Client.new(site_code, config_path, blocking, CONFIGURATION_UPDATE_INTERVAL, DEFAULT_TIMEOUT, client_id, client_secret)
+      client.send(:log, "Warning: you are using the blocking mode") if blocking
+      client.send(:log, "Client created with site code: " + site_code.to_s)
       client.send(:fetch_configuration)
       client
     end

data/lib/kameleoon/request.rb

@@ -1,4 +1,5 @@
 require "em-synchrony/em-http"
+require "kameleoon/version"
 
 module Kameleoon
   # @api private
@@ -22,7 +23,8 @@ module Kameleoon
     private
 
     def request(method, request_options, url, connexion_options)
-      request_options[:tls] = {verify_peer: true}
+      connexion_options[:tls] = {verify_peer: false}
+      add_user_agent(request_options)
       case method
         when Method::POST then
           return EventMachine::HttpRequest.new(url, connexion_options).apost request_options
@@ -37,6 +39,14 @@ module Kameleoon
     def is_successful(request)
       !request.nil? && request != false && /20\d/.match(request.response_header.status.to_s)
     end
+
+    def add_user_agent(request_options)
+      if request_options[:head].nil?
+        request_options[:head] = {'Kameleoon-Client' => 'sdk/ruby/' + Kameleoon::VERSION}
+      else
+        request_options[:head].store('Kameleoon-Client', 'sdk/ruby/' + Kameleoon::VERSION)
+      end
+    end
   end
 end
 

data/lib/kameleoon/version.rb

@@ -0,0 +1,3 @@
+module Kameleoon
+  VERSION = '1.0.5'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.5
 platform: ruby
 authors:
 - Kameleoon - Guillaume Grandjean
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-14 00:00:00.000000000 Z
+date: 2021-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -73,6 +73,7 @@ files:
 - lib/kameleoon/targeting/models.rb
 - lib/kameleoon/targeting/tree_builder.rb
 - lib/kameleoon/utils.rb
+- lib/kameleoon/version.rb
 homepage: https://developers.kameleoon.com/ruby-sdk.html
 licenses:
 - GPL-3.0