kameleoon-client-ruby 2.3.0 → 3.0.0

data/lib/kameleoon/exceptions.rb

@@ -16,66 +16,61 @@ module Kameleoon
       end
     end
 
-    # Variation Not Found
-    class VariationConfigurationNotFound < NotFound
-      def initialize(id = '')
-        super("Variation #{id}")
-      end
-    end
-
-    # Experiment Configuration Not Found
-    class ExperimentConfigurationNotFound	< NotFound
-      def initialize(id = '')
-        super("Experiment #{id}")
+    # Feature Error
+    class FeatureError < KameleoonError
+      def initialize(msg)
+        super("Feature Error: #{msg}")
       end
     end
 
-    # Feature Flag Configuration Not Found
-    class FeatureConfigurationNotFound < NotFound
+    # Feature Not Found
+    class FeatureNotFound < FeatureError
       def initialize(id = '')
         super("Feature flag #{id}")
       end
     end
 
     # Feature Variable Not Found
-    class FeatureVariableNotFound < NotFound
+    class FeatureVariableNotFound < FeatureError
       def initialize(key = '')
         super("Feature variable #{key}")
       end
     end
 
-    # Credentials Not Found
-    class CredentialsNotFound < NotFound
-      def initialize
-        super('Credentials')
+    # Feature Variation Not Found
+    class FeatureVariationNotFound < FeatureError
+      def initialize(id = '')
+        super("Variation #{id}")
       end
     end
 
-    # Not Targeted (when visitor is not targeted for experiment or feature flag)
-    class NotTargeted < KameleoonError
-      def initialize(visitor_code = '')
-        super("Visitor #{visitor_code} is not targeted.")
+    # Feature Environment Disabled
+    class FeatureEnvironmentDisabled < FeatureError
+      def initialize(feature_key, environment = nil)
+        environment = environment.nil? ? 'default' : "'#{environment}'"
+        super("Feature '#{feature_key}' is disabled for #{environment} environment'")
       end
     end
 
-    # Not Allocated (when visitor is not allocated for experiment)
-    class NotAllocated < KameleoonError
-      def initialize(visitor_code = '')
-        super("Visitor #{visitor_code} is not targeted.")
+    # Config Error
+    class ConfigError < KameleoonError
+      def initialize(msg)
+        super("Config Error: #{msg}")
       end
     end
 
-    # Visitor Code Not Valod (empty or length > 255)
-    class VisitorCodeNotValid < KameleoonError
-      def initialize(message = '')
-        super("Visitor code not valid: #{message}")
-      end
+    # Config Credentials Invalid
+    class ConfigCredentialsInvalid < ConfigError
+    end
+
+    # Site Code is Empty
+    class SiteCodeIsEmpty < KameleoonError
     end
 
-    # SiteCode Disabled
-    class SiteCodeDisabled < KameleoonError
-      def initialize(message = '')
-        super("Site with siteCode '#{message}' is disabled")
+    # Visitor Code Not Valid (empty or length > 255)
+    class VisitorCodeInvalid < KameleoonError
+      def initialize(visitor_code)
+        super("Visitor code '#{visitor_code}' is not valid")
       end
     end
   end

data/lib/kameleoon/hybrid/manager.rb

@@ -10,50 +10,32 @@ module Kameleoon
     # Will be useful for Ruby 3.0
     # Abstract Manager class (interface)
     class Manager
-      def add_variation(_visitor, _experiment_id, _variation_id)
-        raise 'Abstract method `add` called'
-      end
-
-      def get_engine_tracking_code(_visitor)
+      def get_engine_tracking_code(_visitor_variations)
         raise 'Abstract method `get_engine_tracking_code` called'
       end
     end
 
     # Implementation of Cache with auto cleaning feature
     class ManagerImpl < Manager
-      def initialize(expiration_time, cleaning_interval, cache_factory, log_func)
+      def initialize(expiration_time, log_func)
         super()
-        # synchronization is necessary for adding same visitor_code from different threads
-        @mutex = Mutex.new
         @expiration_time = expiration_time
-        @cache_factory = cache_factory
         @log = log_func
-        # it's recommend to use cleaning_interval 3-4 times more than experiation_time for more performance
-        # in this case on every cleaning iteration storage will be cleaned 2/3 - 3/4 of volume
-        @cache = cache_factory.create(expiration_time, cleaning_interval)
         @log.call('Hybrid Manager was successfully initialized')
       end
 
-      def add_variation(visitor_code, experiment_id, variation_id)
-        @mutex.synchronize do
-          visitor_cache = @cache.get(visitor_code)
-          visitor_cache = @cache_factory.create(@expiration_time, 0) if visitor_cache.nil?
-          visitor_cache.set(experiment_id, variation_id)
-          @cache.set(visitor_code, visitor_cache)
-        end
-        @log.call("Hybrid Manager successfully added variation for visitor_code: #{visitor_code}, " \
-          "experiment: #{experiment_id}, variation: #{variation_id}")
-      end
-
-      def get_engine_tracking_code(visitor_code)
-        tracking_code = TC_INIT
-        visitor_cache = @cache.get(visitor_code)
-        return tracking_code if visitor_cache.nil?
-
-        visitor_cache.active_items.each_pair do |key, value|
-          tracking_code += format(TC_ASSIGN_VARIATION_TRIGGER_FORMAT, key, value, key)
+      def get_engine_tracking_code(visitor_variations)
+        tracking_code = [TC_INIT]
+        unless visitor_variations.nil?
+          expired_time = (Time.now - @expiration_time).to_i
+          visitor_variations.enumerate do |v|
+            if v.assignment_time > expired_time
+              v_code = format(TC_ASSIGN_VARIATION_TRIGGER_FORMAT, v.experiment_id, v.variation_id, v.experiment_id)
+              tracking_code.push(v_code)
+            end
+          end
         end
-        tracking_code
+        tracking_code.join
       end
     end
   end