kameleoon-client-ruby 1.0.10 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b70d1fc8cd47248dd68ba217e9a860577008e008cac7e6f562ab1856b3dc24c3
-  data.tar.gz: 03ddd4ce4f1ea480bc5adfc347c9f2168af952cc9036ce5cff494af9699a4dfe
+  metadata.gz: a985a05999f2b8caeba131919f70ae77a1e6df7d125b82bf040a1056b300c1e5
+  data.tar.gz: d603f64d8801a3945236de7891ccde5c9a2c6747f18cb704954591a43abc5a99
 SHA512:
-  metadata.gz: d3d39ad2e27a0312ff090f58a93cba6aa69450fd7763fbdc1375bd146bf1af909dde84815073fc7cf7d60b8aa123cb4cc139e8dee19c30aba3a88ae021475633
-  data.tar.gz: bfb92b7c42f02fde8d90484efef51abe294eaece630e97e7d0168e7974dd89d06b9069e9226c23bc2cf25755a2c1d4e41c87d114a1093b6e391a04d440f60de7
+  metadata.gz: 89a04fd8440e3d2f3c17a6878df42088f6258979d1ec384ea8e2eaf7a3bd60c8e99624bb424bf925f86177ea9d58a98df2ddbf5adcc60871833140df600fc3d1
+  data.tar.gz: a61ec90742b861ce596e8526d32bef2186f722e0d2524250c470fcb5bc8de3a90711c391edbf9e8f64d4bad6b5fccb00cc3f8dd4d874cfd6f45268775defecf8

data/lib/kameleoon/client.rb

@@ -9,6 +9,8 @@ require 'rufus/scheduler'
 require 'yaml'
 require 'json'
 require 'em-synchrony'
+require 'em-synchrony/em-http'
+require 'em-synchrony/fiber_iterator'
 require 'objspace'
 require 'time'
 
@@ -29,8 +31,10 @@ module Kameleoon
       @site_code = site_code
       @blocking = blocking
       @default_timeout = config['default_timeout'] || default_timeout # in ms
-      @interval = config['actions_configuration_refresh_interval'].to_s + 'm' || interval
+      refresh_interval = config['actions_configuration_refresh_interval']
+      @interval = refresh_interval.nil? ? interval : "#{refresh_interval}m"
       @tracking_url = config['tracking_url'] || "https://api-ssx.kameleoon.com"
+      @api_data_url = "https://api-data.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 # mb
@@ -100,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
@@ -199,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
 
     ##
@@ -250,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
@@ -293,7 +300,7 @@ module Kameleoon
     # A feature variable can be changed easily via our web application.
     #
     # @param [String | Integer] feature_key
-    # @param [String ] variable_key
+    # @param [String] variable_key
     #
     # @raise [Kameleoon::Exception::FeatureConfigurationNotFound]
     # @raise [Kameleoon::Exception::FeatureVariableNotFound]
@@ -318,6 +325,30 @@ module Kameleoon
       end
     end
 
+    ##
+    # The retrieved_data_from_remote_source method allows you to retrieve data (according to a key passed as argument) 
+    # stored on a remote Kameleoon server. Usually data will be stored on our remote servers via the use of our Data API. 
+    # This method, along with the availability of our highly scalable servers for this purpose, provides a convenient way
+    # to quickly store massive amounts of data that can be later retrieved for each of your visitors / users.
+    #
+    # @param [String] key Key you want to retrieve data. This field is mandatory.
+    # @param [Int] timeout Timeout for request. Equals default_timeout in a config file. This field is optional.
+    #
+    # @return [Hash] Hash object of the json object.
+    #
+    #
+    def retrieve_data_from_remote_source(key, timeout = @default_timeout)
+      connexion_options = { connect_timeout: (timeout.to_f / 1000.0) }
+      path = get_api_data_request_url(key)
+      log "Retrieve API Data connexion: #{connexion_options.inspect}"
+      response = get_sync(@api_data_url + path, connexion_options)
+      if is_successful_sync(response)
+        JSON.parse(response.body) unless response.nil?
+      else
+        return nil
+      end
+    end
+
     private
 
     API_SSX_URL = 'https://api-ssx.kameleoon.com'
@@ -582,6 +613,14 @@ module Kameleoon
       "/dataTracking?" + URI.encode_www_form(get_common_ssx_parameters(visitor_code))
     end
 
+    def get_api_data_request_url(key)
+      mapKey = {
+        siteCode: site_code,
+        key: key
+      }
+      "/data?#{URI.encode_www_form(mapKey)}"
+    end
+
     def get_feature_flag(feature_key)
       if feature_key.is_a?(String)
         feature_flag = @feature_flags.select { |ff| ff['identificationKey'] == feature_key}.first
@@ -616,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
 
@@ -686,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

@@ -1,5 +1,6 @@
 require "em-synchrony/em-http"
 require "kameleoon/version"
+require 'net/http'
 
 module Kameleoon
   # @api private
@@ -20,6 +21,14 @@ module Kameleoon
       request(Method::POST, request_options, url, connexion_options)
     end
 
+    def get_sync(url = API_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
 
     def request(method, request_options, url, connexion_options)
@@ -29,7 +38,30 @@ module Kameleoon
         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).aget request_options
+          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?
+      add_user_agent(request_options)
+      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(request_options[:path], initheader = request_options[:head])
+          request.body = request_options[:body]
+          response = http.request(request)
+          response
         else
           print "Unknown request type"
           return false
@@ -40,6 +72,10 @@ module Kameleoon
       !request.nil? && request != false && /20\d/.match(request.response_header.status.to_s)
     end
 
+    def is_successful_sync(response)
+      !response.nil? && response != false && response.is_a?(Net::HTTPSuccess)
+    end
+
     def add_user_agent(request_options)
       if request_options[:head].nil?
         request_options[:head] = {'Kameleoon-Client' => 'sdk/ruby/' + Kameleoon::VERSION}

data/lib/kameleoon/version.rb

@@ -1,3 +1,3 @@
 module Kameleoon
-  VERSION = '1.0.10'
+  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.0.10
+  version: 1.1.2
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-28 00:00:00.000000000 Z
+date: 2022-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request