kameleoon-client-ruby 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3462fcc69d821034025ac9299b880f4e63ed5debca86aa85bcb5236b9658b0cb
-  data.tar.gz: 0eaf3a74b42adfb6b561048e9934ebf529047ea5307551f795a630a855b19404
+  metadata.gz: 4f1490fd854e391fea3b908cad394e328a3540b6368942b72c1a9979c9002b87
+  data.tar.gz: 3abf894648cd3662a1a3a3453254014fa20c5405af28f6e01c8e336c810c6031
 SHA512:
-  metadata.gz: 157327482deee68063a881afca8d8b576f854d1fff756d589f4021e1793c7e1966ddfdd9120c36df189e51522518e6fb678f523373ee1525abf4aa932599b906
-  data.tar.gz: 8bfbf4b4917773954aba26163c3252a10f1890b49c047c46724c8e4eff4d1cdcefc64150ff801e4920d7ddb47479a4c5f3fc0c771299283a12af625f78b5de24
+  metadata.gz: 76f8eb07daaf102c292c9ed04a6d788dfcef4a7cf757875603a68d2a1272b8e543dbfabd89226a6f775cd71d243998b8b897e6339c616d0a87b03624054720e3
+  data.tar.gz: d8f94272a6afa522a6ea5c48e3c0f9b91fec6bd1b2382e0ff2a9a94cfbdfb3c23d9f278a5bf143d4161a05cff385ad335d278a5634e8f3a23f4f63373c6da281

data/lib/kameleoon/configuration/settings.rb

@@ -6,16 +6,19 @@ module Kameleoon
     # KameleoonConfigurationSettings is used for saving setting's parameters, e.g
     # state of real time update for site code and etc
     class Settings
-      attr_accessor :real_time_update, :is_consent_required
+      attr_accessor :real_time_update
+      attr_reader :is_consent_required, :data_api_domain
 
       def initialize
         @real_time_update = false
         @is_consent_required = false
+        @data_api_domain = nil
       end
 
       def update(configuration)
         @real_time_update = configuration['realTimeUpdate'] || false
         @is_consent_required = configuration['consentType'] == 'REQUIRED'
+        @data_api_domain = configuration['dataApiDomain']
       end
     end
   end

data/lib/kameleoon/kameleoon_client.rb

@@ -10,10 +10,12 @@ require 'kameleoon/data/manager/visitor_manager'
 require 'kameleoon/configuration/feature_flag'
 require 'kameleoon/configuration/variation'
 require 'kameleoon/configuration/data_file'
+require 'kameleoon/network/access_token_source'
 require 'kameleoon/network/activity_event'
-require 'kameleoon/network/url_provider'
 require 'kameleoon/network/network_manager'
+require 'kameleoon/network/url_provider'
 require 'kameleoon/network/cookie/cookie_manager'
+require 'kameleoon/managers/warehouse/warehouse_manager'
 require 'kameleoon/real_time/real_time_configuration_service'
 require 'kameleoon/hybrid/manager'
 require 'kameleoon/storage/cache_factory'
@@ -50,9 +52,11 @@ module Kameleoon
       @network_manager = Network::NetworkManager.new(
         config.environment,
         config.default_timeout_millisecond,
-        Network::UrlProvider.new(site_code, Network::UrlProvider::DEFAULT_DATA_API_URL),
+        Network::AccessTokenSourceFactory.new(config.client_id, config.client_secret, method(:log)),
+        Network::UrlProvider.new(site_code),
         method(:log)
       )
+      @warehouse_manager = Managers::Warehouse::WarehouseManager.new(@network_manager, @visitor_manager, method(:log))
       @cookie_manager = Network::Cookie::CookieManager.new(config.top_level_domain)
       @readiness = ClientReadiness.new
     end
@@ -264,7 +268,7 @@ module Kameleoon
     # 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 (in milliseconds). Equals default_timeout in a config file.
+    # @param [Integer] timeout Timeout for request (in milliseconds). Equals default_timeout in a config file.
     # This field is optional.
     #
     # @return [Hash] Hash object of the json object.
@@ -282,7 +286,7 @@ module Kameleoon
     # 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.
+    # @param [Integer] 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.
@@ -293,6 +297,33 @@ module Kameleoon
       data_array
     end
 
+    ##
+    # Retrieves data associated with a visitor's warehouse audiences and adds it to the visitor.
+    # Retrieves all audience data associated with the visitor in your data warehouse using the specified
+    # `visitor_code` and `warehouse_key`. The `warehouse_key` is typically your internal user ID.
+    # The `custom_data_index` parameter corresponds to the Kameleoon custom data that Kameleoon uses to target your
+    # visitors. You can refer to the
+    # <a href="https://help.kameleoon.com/warehouse-audience-targeting/">warehouse targeting documentation</a>
+    # for additional details. The method returns a `CustomData` object, confirming
+    # that the data has been added to the visitor and is available for targeting purposes.
+    #
+    # @param [String] visitor_code A unique visitor identification string, can't exceed 255 characters length.
+    # This field is mandatory.
+    # @param [Integer] custom_data_index An integer representing the index of the custom data you want to use to target
+    # your BigQuery Audiences. This field is mandatory.
+    # @param [String] warehouse_key A key to identify the warehouse data, typically your internal user ID.
+    # This field is optional.
+    # @param [Integer] timeout Timeout for request (in milliseconds). Equals default_timeout in a config file.
+    # This field is optional.
+    #
+    # @raise [Kameleoon::Exception::VisitorCodeInvalid] If the visitor code is empty or longer than 255 chars.
+    # @raise [JSON::ParserError]
+    #
+    # @return [Kameleoon::CustomData] A `CustomData` instance confirming that the data has been added to the visitor.
+    def get_visitor_warehouse_audience(visitor_code, custom_data_index, timeout = nil, warehouse_key: nil)
+      @warehouse_manager.get_visitor_warehouse_audience(visitor_code, custom_data_index, warehouse_key, timeout)
+    end
+
     ##
     # Returns a list of all feature flag keys
     #
@@ -443,6 +474,7 @@ module Kameleoon
       @data_file = Configuration::DataFile.new(@config.environment).init(configuration)
       @cookie_manager.consent_required =
         @data_file.settings.is_consent_required && !@data_file.has_any_targeted_delivery_rule
+      @network_manager.url_provider.apply_data_api_domain(@data_file.settings.data_api_domain)
 
       call_update_handler_if_needed(!time_stamp.nil?)
       log "Feature flags are fetched: #{response.inspect}"

data/lib/kameleoon/managers/warehouse/warehouse_manager.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/custom_data'
+require 'kameleoon/utils'
+
+module Kameleoon
+  module Managers
+    module Warehouse
+      class WarehouseManager
+        WAREHOUSE_AUDIENCES_FIELD_NAME = 'warehouseAudiences'
+
+        def initialize(network_manager, visitor_manager, log_func = nil)
+          @network_manager = network_manager
+          @visitor_manager = visitor_manager
+          @log_func = log_func
+        end
+
+        def get_visitor_warehouse_audience(visitor_code, custom_data_index, warehouse_key = nil, timeout = nil)
+          Utils::VisitorCode.validate(visitor_code)
+          remote_data_key = warehouse_key.nil? || warehouse_key.empty? ? visitor_code : warehouse_key
+          response = @network_manager.get_remote_data(remote_data_key, timeout)
+          remote_data = response.is_a?(String) ? JSON.parse(response) : nil
+          warehouse_audiences = remote_data.is_a?(Hash) ? remote_data[WAREHOUSE_AUDIENCES_FIELD_NAME] : nil
+          data_values = warehouse_audiences.is_a?(Hash) ? warehouse_audiences.keys : []
+          warehouse_audiences_data = CustomData.new(custom_data_index, *data_values)
+          visitor = @visitor_manager.get_or_create_visitor(visitor_code)
+          visitor.add_data(@log_func, warehouse_audiences_data)
+          warehouse_audiences_data
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/network/access_token_source.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'time'
+
+module Kameleoon
+  module Network
+    class AccessTokenSource
+      TOKEN_EXPIRATION_GAP = 60 # in seconds
+      TOKEN_OBSOLESCENCE_GAP = 1800 # in seconds
+      JWT_ACCESS_TOKEN_FIELD = 'access_token'
+      JWT_EXPIRES_IN_FIELD = 'expires_in'
+
+      def initialize(network_manager, client_id, client_secret, log_func)
+        @network_manager = network_manager
+        @client_id = client_id
+        @client_secret = client_secret
+        @fetching = false
+        @log_func = log_func
+      end
+
+      def get_token
+        now = Time.new.to_i
+        token = @cached_token
+        return fetch_token if token.nil? || token.expired?(now)
+
+        Thread.new { fetch_token } if !@fetching && token.obsolete?(now)
+        token.value
+      end
+
+      def discard_token(token)
+        @cached_token = nil if @cached_token&.value == token
+      end
+
+      private
+
+      def fetch_token
+        @fetching = true
+        response_content = @network_manager.fetch_access_jwtoken(@client_id, @client_secret)
+        unless response_content
+          @log_func&.call('Failed to fetch access JWT')
+          return nil
+        end
+        begin
+          jwt = JSON.parse(response_content)
+          token = jwt[JWT_ACCESS_TOKEN_FIELD]
+          expires_in = jwt[JWT_EXPIRES_IN_FIELD]
+        rescue JSON::ParserError => e
+          @log_func&.call("Failed to parse access JWT: #{e}")
+          return nil
+        end
+        unless token.is_a?(String) && !token.empty? && expires_in.is_a?(Integer) && expires_in.positive?
+          @log_func&.call('Failed to read access JWT')
+          return nil
+        end
+        handle_fetched_token(token, expires_in)
+      ensure
+        @fetching = false
+      end
+
+      def handle_fetched_token(token, expires_in)
+        now = Time.new.to_i
+        exp_time = now + expires_in - TOKEN_EXPIRATION_GAP
+        if expires_in > TOKEN_OBSOLESCENCE_GAP
+          obs_time = now + expires_in - TOKEN_OBSOLESCENCE_GAP
+        else
+          obs_time = exp_time
+          unless @log_func.nil?
+            issue = expires_in <= TOKEN_EXPIRATION_GAP ? 'cache the token' : 'refresh cached token in background'
+            @log_func.call("Access token life time (#{expires_in}s) is not long enough to #{issue}")
+          end
+        end
+        @cached_token = ExpiringToken.new(token, exp_time, obs_time)
+        token
+      end
+    end
+
+    class ExpiringToken
+      attr_reader :value, :expiration_time, :obsolescence_time
+
+      def initialize(value, expiration_time, obsolescence_time)
+        @value = value
+        @expiration_time = expiration_time
+        @obsolescence_time = obsolescence_time
+      end
+
+      def expired?(now)
+        now >= @expiration_time
+      end
+
+      def obsolete?(now)
+        now >= @obsolescence_time
+      end
+    end
+
+    class AccessTokenSourceFactory
+      def initialize(client_id, client_secret, log_func)
+        @client_id = client_id
+        @client_secret = client_secret
+        @log_func = log_func
+      end
+
+      def create(network_manager)
+        AccessTokenSource.new(network_manager, @client_id, @client_secret, @log_func)
+      end
+    end
+  end
+end

data/lib/kameleoon/network/net_provider.rb

@@ -8,7 +8,7 @@ require 'kameleoon/exceptions'
 module Kameleoon
   module Network
     class NetProvider
-      def make_request(_request)
+      def make_request(request)
         raise KameleoonError, 'Call of not implemented method!'
       end
 
@@ -16,6 +16,7 @@ module Kameleoon
 
       def collect_headers(request)
         headers = request.extra_headers || {}
+        headers['Authorization'] = "Bearer #{request.access_token}" unless request.access_token.nil?
         headers['Content-Type'] = request.content_type
         headers['User-Agent'] = request.user_agent unless request.user_agent.nil?
         headers
@@ -29,30 +30,28 @@ module Kameleoon
     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)
+        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
         body = resp.body
         body = nil if body&.empty?
         Response.new(nil, resp.code.to_i, body, request)
+      rescue => e
+        Response.new(e, nil, nil, request)
       end
     end
   end

data/lib/kameleoon/network/network_manager.rb

@@ -4,6 +4,7 @@ require 'kameleoon/network/content_type'
 require 'kameleoon/network/method'
 require 'kameleoon/network/request'
 require 'kameleoon/network/net_provider'
+require 'kameleoon/network/uri_helper'
 require 'kameleoon/version'
 
 module Kameleoon
@@ -11,17 +12,19 @@ module Kameleoon
     ##
     # NetworkManager is used to make API calls.
     class NetworkManager
-      FETCH_CONFIGURATION_ATTEMPT_NUMBER = 4
-      TRACKING_CALL_ATTEMPT_NUMBER = 4
+      FETCH_CONFIGURATION_ATTEMPT_NUMBER = 3
+      TRACKING_CALL_ATTEMPT_NUMBER = 3
       TRACKING_CALL_RETRY_DELAY = 5.0 # in seconds
       SDK_TYPE_HEADER = 'X-Kameleoon-SDK-Type'
       SDK_VERSION_HEADER = 'X-Kameleoon-SDK-Version'
+      ACCESS_TOKEN_GRANT_TYPE = 'client_credentials'
 
-      attr_reader :environment, :default_timeout, :url_provider
+      attr_reader :environment, :default_timeout, :access_token_source, :url_provider
 
-      def initialize(environment, default_timeout, url_provider, log_func = nil)
+      def initialize(environment, default_timeout, access_token_source_factory, url_provider, log_func = nil)
         @environment = environment
         @default_timeout = default_timeout
+        @access_token_source = access_token_source_factory.create(self)
         @url_provider = url_provider
         @sync_net_provider = SyncNetProvider.new
         @log_func = log_func
@@ -32,31 +35,21 @@ module Kameleoon
         timeout = ensure_timeout(timeout)
         sdk_headers = { SDK_TYPE_HEADER => SDK_NAME, SDK_VERSION_HEADER => SDK_VERSION }
         request = Request.new(Method::GET, url, ContentType::JSON, timeout, extra_headers: sdk_headers)
-        attempts_left = FETCH_CONFIGURATION_ATTEMPT_NUMBER
-        while attempts_left.positive?
-          response = @sync_net_provider.make_request(request)
-          result = handle_response(response)
-          return result if result
-
-          attempts_left -= 1
-        end
-        false
+        make_call(request, false, FETCH_CONFIGURATION_ATTEMPT_NUMBER - 1)
       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)
+        make_call(request, true)
       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)
+        make_call(request, true)
       end
 
       def send_tracking_data(visitor_code, lines, user_agent, timeout = nil)
@@ -67,23 +60,55 @@ module Kameleoon
         data = (lines.map(&:obtain_full_post_text_line).join("\n") || '').encode('UTF-8')
         request = Request.new(Method::POST, url, ContentType::TEXT, timeout, user_agent: user_agent, data: 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(&:mark_as_sent)
-              break
-            end
-            attempts_left -= 1
-            break unless attempts_left.positive?
-
-            delay(TRACKING_CALL_RETRY_DELAY)
-          end
+          result = make_call(request, true, TRACKING_CALL_ATTEMPT_NUMBER - 1, TRACKING_CALL_RETRY_DELAY)
+          lines.each(&:mark_as_sent) if result != false
         end
       end
 
+      def fetch_access_jwtoken(client_id, client_secret, timeout = nil)
+        url = @url_provider.make_access_token_url
+        timeout = ensure_timeout(timeout)
+        data_map = {
+          grant_type: ACCESS_TOKEN_GRANT_TYPE,
+          client_id: client_id,
+          client_secret: client_secret
+        }
+        data = UriHelper.encode_query(data_map).encode('UTF-8')
+        request = Request.new(Method::POST, url, ContentType::FORM, timeout, data: data)
+        make_call(request, false)
+      end
+
       private
 
+      def make_call(request, try_access_token_auth, retry_limit = 0, retry_delay = 0)
+        attempt = 0
+        success = false
+        while !success && (attempt <= retry_limit)
+          delay(retry_delay) if attempt.positive? && retry_delay.positive?
+          try_authorize(request) if try_access_token_auth
+          response = @sync_net_provider.make_request(request)
+          if !response.error.nil?
+            log_failure(response.request, "Error occurred during request: #{response.error}")
+          elsif response.code / 100 != 2
+            if ((response.code == 401) || (response.code == 403)) && response.request.access_token
+              @log_func&.call("Unexpected rejection of access token '#{response.request.access_token}'")
+              @access_token_source.discard_token(response.request.access_token)
+              if attempt == retry_limit
+                try_access_token_auth = false
+                retry_delay = 0
+                request.authorize(nil)
+                attempt -= 1
+              end
+            end
+            log_failure(response.request, "Received unexpected status code '#{response.code}'")
+          else
+            success = true
+          end
+          attempt += 1
+        end
+        success ? response.body : false
+      end
+
       def log_failure(request, message)
         return if @log_func.nil?
 
@@ -100,15 +125,11 @@ module Kameleoon
         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
+      def try_authorize(request)
+        token = @access_token_source.get_token
+        return if request.authorize(token)
+
+        @log_func&.call("Failed to authorize #{request.method} call '#{request.url}'")
       end
     end
   end

data/lib/kameleoon/network/request.rb

@@ -5,7 +5,7 @@ module Kameleoon
     ##
     # Request represents HTTP request.
     class Request
-      attr_reader :method, :url, :content_type, :timeout, :user_agent, :extra_headers, :data
+      attr_reader :method, :url, :content_type, :timeout, :user_agent, :extra_headers, :data, :access_token
 
       def initialize(method, url, content_type, timeout, user_agent: nil, extra_headers: nil, data: nil)
         @method = method
@@ -16,6 +16,10 @@ module Kameleoon
         @extra_headers = extra_headers
         @data = !data.nil? && data.is_a?(String) ? data.encode('UTF-8') : data
       end
+
+      def authorize(access_token)
+        @access_token = access_token
+      end
     end
   end
 end

data/lib/kameleoon/network/url_provider.rb

@@ -12,17 +12,29 @@ module Kameleoon
       VISITOR_DATA_PATH = '/visit/visitor'
       GET_DATA_PATH = '/map/map'
       POST_DATA_PATH = '/map/maps'
+      ACCESS_TOKEN_PATH = '/oauth/token'
+
       CONFIGURATION_API_URL_FORMAT = 'https://sdk-config.kameleoon.eu/%s'
       RT_CONFIGURATION_URL = 'https://events.kameleoon.com:8110/sse'
+      DEFAULT_DATA_API_DOMAIN = 'data.kameleoon.io'
+      TEST_DATA_API_DOMAIN = 'data.kameleoon.net'
+      DEFAULT_AUTOMATION_API_DOMAIN = 'api.kameleoon.com'
+      TEST_AUTOMATION_API_DOMAIN = 'api.kameleoon.net'
 
-      DEFAULT_DATA_API_URL = 'https://data.kameleoon.io'
-      TEST_DATA_API_URL = 'https://data.kameleoon.net'
-
-      attr_reader :site_code, :data_api_url
+      attr_reader :site_code, :data_api_domain, :automation_api_domain
 
-      def initialize(site_code, data_api_url)
+      def initialize(
+        site_code,
+        data_api_domain = DEFAULT_DATA_API_DOMAIN,
+        automation_api_domain = DEFAULT_AUTOMATION_API_DOMAIN
+      )
         @site_code = site_code
-        @data_api_url = data_api_url
+        @data_api_domain = data_api_domain
+        @automation_api_domain = automation_api_domain
+      end
+
+      def apply_data_api_domain(domain)
+        @data_api_domain = domain if domain.is_a?(String)
       end
 
       def make_tracking_url(visitor_code)
@@ -32,7 +44,7 @@ module Kameleoon
           siteCode: @site_code,
           visitorCode: visitor_code
         }
-        "#{@data_api_url}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
+        "https://#{@data_api_domain}#{TRACKING_PATH}?#{UriHelper.encode_query(params)}"
       end
 
       def make_visitor_data_get_url(visitor_code)
@@ -44,7 +56,7 @@ module Kameleoon
           customData: true,
           version: 0
         }
-        "#{@data_api_url}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
+        "https://#{@data_api_domain}#{VISITOR_DATA_PATH}?#{UriHelper.encode_query(params)}"
       end
 
       def make_api_data_get_request_url(key)
@@ -52,7 +64,7 @@ module Kameleoon
           siteCode: @site_code,
           key: key
         }
-        "#{@data_api_url}#{GET_DATA_PATH}?#{UriHelper.encode_query(params)}"
+        "https://#{@data_api_domain}#{GET_DATA_PATH}?#{UriHelper.encode_query(params)}"
       end
 
       def make_configuration_url(environment = nil, timestamp = nil)
@@ -68,6 +80,10 @@ module Kameleoon
         params = { siteCode: @site_code }
         "#{RT_CONFIGURATION_URL}?#{UriHelper.encode_query(params)}"
       end
+
+      def make_access_token_url
+        "https://#{@automation_api_domain}#{ACCESS_TOKEN_PATH}"
+      end
     end
   end
 end

data/lib/kameleoon/real_time/sse_client.rb

@@ -2,6 +2,8 @@
 
 require 'kameleoon/real_time/sse_message'
 
+# TODO: Fix hanging (https://project.kameleoon.net/issues/26520)
+
 module Kameleoon
   module RealTime
     ##

data/lib/kameleoon/version.rb

@@ -2,7 +2,7 @@
 
 module Kameleoon
   SDK_NAME = 'RUBY'
-  SDK_VERSION = '3.0.0'
+  SDK_VERSION = '3.1.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: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Kameleoon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-13 00:00:00.000000000 Z
+date: 2024-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-http-request
@@ -101,6 +101,8 @@ files:
 - lib/kameleoon/kameleoon_client.rb
 - lib/kameleoon/kameleoon_client_config.rb
 - lib/kameleoon/kameleoon_client_factory.rb
+- lib/kameleoon/managers/warehouse/warehouse_manager.rb
+- lib/kameleoon/network/access_token_source.rb
 - lib/kameleoon/network/activity_event.rb
 - lib/kameleoon/network/content_type.rb
 - lib/kameleoon/network/cookie/cookie_manager.rb