kameleoon-client-ruby 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e62c8e4dfa35f91706257ff5367a266736af7c03786803ad8f9fff06aa8c194
-  data.tar.gz: 7773e082be938108b42c65cd0109392413bf938619cf04cc994617111c746f15
+  metadata.gz: a985a05999f2b8caeba131919f70ae77a1e6df7d125b82bf040a1056b300c1e5
+  data.tar.gz: d603f64d8801a3945236de7891ccde5c9a2c6747f18cb704954591a43abc5a99
 SHA512:
-  metadata.gz: d74b03762402a1f4c6e7349bb085e3b185ee564f0a7f645a16f7bb8da0321b73689adad785d52bdce48e9a0646f6b10de6c3f2fc8016b9459b713eafbda77e6f
-  data.tar.gz: a835f8b23265a2ae8241114fb2c5fe1f8965544fb348c2f6c16d714fe543fa6396b5bc6cbf7f68d8ac5e5391b8cbf594f55086e8c24290fda57a7b18ac5f57c4
+  metadata.gz: 89a04fd8440e3d2f3c17a6878df42088f6258979d1ec384ea8e2eaf7a3bd60c8e99624bb424bf925f86177ea9d58a98df2ddbf5adcc60871833140df600fc3d1
+  data.tar.gz: a61ec90742b861ce596e8526d32bef2186f722e0d2524250c470fcb5bc8de3a90711c391edbf9e8f64d4bad6b5fccb00cc3f8dd4d874cfd6f45268775defecf8

data/lib/kameleoon/client.rb

@@ -104,8 +104,7 @@ module Kameleoon
         variation_id = nil
         EM.synchrony do
           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") || ""
+          body = (data_not_sent(visitor_code).map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8")
           path = get_experiment_register_url(visitor_code, experiment_id)
           request_options = { :path => path, :body => body }
           log "Trigger experiment request: " + request_options.inspect
@@ -203,7 +202,11 @@ module Kameleoon
     #
     def flush(visitor_code = nil)
       check_visitor_code(visitor_code) unless visitor_code.nil?
-      track_data(visitor_code)
+      if !visitor_code.nil?
+        track_data(visitor_code)
+      else
+        @data.select { |_, values| values.any? { |data| !data.sent } }.each_key { |key| flush(key) }
+      end
     end
 
     ##
@@ -254,7 +257,7 @@ module Kameleoon
           connexion_options = { :connect_timeout => (timeout.to_f / 1000.0) }
           request_options = {
             :path => get_experiment_register_url(visitor_code, id),
-            :body => (data_not_sent(visitor_code).values.map { |data| data.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8")
+            :body => (data_not_sent(visitor_code).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
@@ -652,67 +655,58 @@ module Kameleoon
       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"),
+        :body => (data_not_sent.map{ |it| it.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8"),
         :head => { "Content-Type" => "text/plain"}
       }
       trial = 0
       success = false
       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
-              success = true
-              break
-            end
-            trial += 1
+        while trial < 10
+          log "Send Experiment Tracking " + options.inspect
+          response = post_sync(options, @tracking_url)
+          log "Response " + response.inspect
+          if is_successful_sync(response)
+            data_not_sent.each { |it| it.sent = true }
+            success = true
+            break
           end
-          EM.stop
+          trial += 1
         end
         if success
           log "Post to experiment tracking is done after " + (trial + 1).to_s + " trials"
-        elsif 
+        else 
           log "Post to experiment tracking is failed after " + trial.to_s + " trials"          
         end
-        Thread.exit
       end
     end
 
-    def track_data(visitor_code = nil)
+    def track_data(visitor_code)
       Thread.new do
-        EM.synchrony do
-          trials = 10
-          concurrency = 1
-          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 => 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)
-                  entry.last.each { |data| data.sent = true }
-                end
-                iter.return(request)
-              }
-              request.errback { iter.return(request) }
-            end
-            data_not_sent = data_not_sent(visitor_code)
-            trials -= 1
+        trials = 0
+        data_not_sent = data_not_sent(visitor_code)
+        log "Start post tracking data: " + data_not_sent.inspect
+        while trials < 10 && !data_not_sent.empty?
+          options = {
+            :path => get_data_register_url(visitor_code),
+            :body => (data_not_sent.map{ |it| it.obtain_full_post_text_line }.join("\n") || "").encode("UTF-8"),
+            :head => { "Content-Type" => "text/plain" }
+          }
+          log "Post tracking data for visitor_code: " + visitor_code + " with options: " + options.inspect
+          response = post_sync(options, @tracking_url)
+          log "Response " + response.inspect
+          if is_successful_sync(response)
+            data_not_sent.each { |it| it.sent = true }
+            success = true
+            break
           end
-          log "Post to data tracking is done."
-          EM.stop
+          trials += 1
+        end
+        if success
+          log "Post to data tracking is done after " + (trials + 1).to_s + " trials"
+        else
+          log "Post to data tracking is failed after " + trials.to_s + " trials"          
         end
-        Thread.exit
       end
     end
 
@@ -722,12 +716,8 @@ module Kameleoon
       end
     end
 
-    def data_not_sent(visitor_code = nil)
-      if visitor_code.nil?
-        @data.select {|key, values| values.any? {|data| !data.sent}}
-      else
-        @data.select { |key, values| key == visitor_code && values.any? {|data| !data.sent} }
-      end
+    def data_not_sent(visitor_code)
+      @data.key?(visitor_code) ? @data[visitor_code].reject(&:sent) : []
     end
 
     def log(text)

data/lib/kameleoon/request.rb

@@ -22,7 +22,11 @@ module Kameleoon
     end
 
     def get_sync(url = API_URL, connexion_options = {})
-      request_sync(Method::GET, url, connexion_options)
+      request_sync(Method::GET, url, connexion_options, {})
+    end
+
+    def post_sync(request_options, url = API_URL, connexion_options = {})
+      request_sync(Method::POST, url, connexion_options, request_options)
     end
 
     private
@@ -41,7 +45,7 @@ module Kameleoon
       end
     end
 
-    def request_sync(method, url, connexion_options)
+    def request_sync(method, url, connexion_options, request_options)
       request_options = {} if request_options.nil?
       add_user_agent(request_options)
       case method
@@ -50,6 +54,14 @@ module Kameleoon
           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(request_options[:path], initheader = request_options[:head])
+          request.body = request_options[:body]
+          response = http.request(request)
+          response
         else
           print "Unknown request type"
           return false

data/lib/kameleoon/version.rb

@@ -1,3 +1,3 @@
 module Kameleoon
-  VERSION = '1.1.1'
+  VERSION = '1.1.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kameleoon-client-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-04 00:00:00.000000000 Z
+date: 2022-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request