kameleoon-client-ruby 1.0.1 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1acddc80101273c13cdf39b6cf2fb497716e947981dbffcf4d31540ea1f62edc
-  data.tar.gz: c00f33ed4eb494f7b1f2b4009005e84492ccad9cc366ac8fd34888c6aa63e2eb
+  metadata.gz: dbb0fcb2b7bd0c35767c990d39eb0b5d06d996b4bbe1b3c43ec04ec03541a671
+  data.tar.gz: bcdf01f341003189b8a41d9184e792091603b1369b47bc5838786fa2f382c65d
 SHA512:
-  metadata.gz: 6b4a67c7e0f8315aaeb2e46c15c2961840099a40a874d56c821bfc5407aa4f506ea732cf90cad13abb406e1c2f6d98bea62fb07a9b7bf427798ad27a15ef11e3
-  data.tar.gz: a62a96d1a772835c9e4db7ad8c968c302339dae2b9937204c37bbd2d8f22f23d6c76dae15b8f8577a0e692e1a181d27177635e64fba0f1b090290c870c0f9034
+  metadata.gz: b81e0518ca8b69e837daa26fe467d2ab5b306ed0dd4770e83d7bd8d022fc7fe485a9c95cf89a44b8bdf5d4ea2af6b335842c19b354c9db30ff37134dd29d7cb3
+  data.tar.gz: 420d763b0a306809a0d784c44d7058a214e76b2e9ddf88727fe14bfe71d327a18172c621eb7d48cf18874f34d20f1e7c1b87b594c639f9dc769dee41aba1e1f1

data/lib/kameleoon/client.rb

@@ -30,6 +30,7 @@ module Kameleoon
       @client_id = client_id || config['client_id']
       @client_secret = client_secret || config['client_secret']
       @data_maximum_size = config['visitor_data_maximum_size'] || 500 # mb
+      @verbose_mode = config['verbose_mode'] || false
       @experiments = []
       @feature_flags = []
       @data = {}
@@ -96,10 +97,13 @@ module Kameleoon
                       .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
+            log "Failed to trigger experiment: " + request.inspect
             raise Exception::ExperimentConfigurationNotFound.new(experiment_id) if variation_id.nil?
           end
           EM.stop
@@ -112,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)
@@ -178,7 +182,7 @@ 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
 
     ##
@@ -227,11 +231,15 @@ module Kameleoon
           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
@@ -243,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
@@ -290,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
@@ -334,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,
@@ -353,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
 
@@ -381,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('status', 'IN', ['ACTIVE', 'DEVIATED']),
         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 = [])
@@ -423,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
@@ -449,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
@@ -463,19 +490,48 @@ module Kameleoon
       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)
@@ -485,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
@@ -502,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/factory.rb

@@ -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

@@ -23,7 +23,7 @@ module Kameleoon
     private
 
     def request(method, request_options, url, connexion_options)
-      #connexion_options[:tls] = {verify_peer: true}
+      connexion_options[:tls] = {verify_peer: false}
       add_user_agent(request_options)
       case method
         when Method::POST then
@@ -42,9 +42,9 @@ module Kameleoon
 
     def add_user_agent(request_options)
       if request_options[:head].nil?
-        request_options[:head] = {'User-Agent' => 'kameleoon-client-ruby/' + Kameleoon::VERSION}
+        request_options[:head] = {'Kameleoon-Client' => 'sdk/ruby/' + Kameleoon::VERSION}
       else
-        request_options[:head].store('User-Agent', 'kameleoon-client-ruby/' + Kameleoon::VERSION)
+        request_options[:head].store('Kameleoon-Client', 'sdk/ruby/' + Kameleoon::VERSION)
       end
     end
   end

data/lib/kameleoon/version.rb

@@ -1,3 +1,3 @@
 module Kameleoon
-  VERSION = '1.0.1'
+  VERSION = '1.0.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.6
 platform: ruby
 authors:
 - Kameleoon - Guillaume Grandjean
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-16 00:00:00.000000000 Z
+date: 2021-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request