rox-rollout 4.7.2 → 5.0.3

data/lib/rox/core/core.rb

@@ -11,6 +11,7 @@ require 'rox/core/network/request_configuration_builder'
 require 'rox/core/network/request'
 require 'rox/core/network/configuration_fetcher'
 require 'rox/core/network/configuration_fetcher_roxy'
+require 'rox/core/network/configuration_fetcher_self_managed'
 require 'rox/core/network/state_sender'
 require 'rox/core/notifications/notification_listener'
 require 'rox/core/register/registerer'
@@ -20,8 +21,10 @@ require 'rox/core/entities/flag_setter'
 require 'rox/core/impression/impression_invoker'
 require 'rox/core/reporting/error_reporter'
 require 'rox/core/security/signature_verifier'
+require 'rox/core/security/signature_verifier_mock'
 require 'rox/core/utils/periodic_task'
 require 'rox/core/client/dynamic_api'
+require 'rox/core/error_handling/userspace_unhandled_error_invoker'
 
 module Rox
   module Core
@@ -31,14 +34,10 @@ module Rox
         @custom_property_repository = CustomPropertyRepository.new
         @target_group_repository = TargetGroupRepository.new
         @experiment_repository = ExperimentRepository.new
-        @parser = Parser.new
+        @user_unhandled_error_invoker = Rox::Core::UserspaceUnhandledErrorInvoker.new
+        @parser = Parser.new(@user_unhandled_error_invoker)
 
-        experiments_extensions = ExperimentsExtensions.new(@parser, @target_group_repository, @flag_repository, @experiment_repository)
-        properties_extensions = PropertiesExtensions.new(@parser, @custom_property_repository)
-        experiments_extensions.extend
-        properties_extensions.extend
-
-        @configuration_fetched_invoker = ConfigurationFetchedInvoker.new
+        @configuration_fetched_invoker = ConfigurationFetchedInvoker.new(@user_unhandled_error_invoker)
         @registerer = Registerer.new(@flag_repository)
 
         @sdk_settings = nil
@@ -51,65 +50,109 @@ module Rox
         @push_updates_listener = nil
       end
 
-      def setup(sdk_settings, device_properties, rox_options)
+      def userspace_unhandled_error_handler=(handler)
+        @user_unhandled_error_invoker.handler = handler
+      end
+
+      def setup(sdk_settings, device_properties)
         @sdk_settings = sdk_settings
+        @rox_options = device_properties.rox_options
 
-        roxy_path = rox_options.nil? || rox_options.roxy_url.nil? ? nil : rox_options.roxy_url
+        experiments_extensions = ExperimentsExtensions.new(@parser, @target_group_repository, @flag_repository,
+                                                           @experiment_repository)
+        properties_extensions = PropertiesExtensions.new(@parser, @custom_property_repository, @rox_options.dynamic_property_rule_handler)
+        experiments_extensions.extend
+        properties_extensions.extend
 
-        if roxy_path.nil?
-          validate_api_key(sdk_settings&.api_key)
-        end
+        roxy_path = @rox_options.nil? || @rox_options.roxy_url.nil? ? nil : @rox_options.roxy_url
+
+        validate_api_key(sdk_settings&.api_key) if roxy_path.nil?
 
         # TODO: Analytics.Analytics.Initialize(deviceProperties.RolloutKey, deviceProperties)
-        @internal_flags = InternalFlags.new(@experiment_repository, @parser)
+        @internal_flags = InternalFlags.new(@experiment_repository, @parser, @rox_options)
 
         # TODO: impressionInvoker = new ImpressionInvoker(internalFlags, customPropertyRepository, deviceProperties, Analytics.Analytics.Client, roxyPath != null);
-        @impression_invoker = ImpressionInvoker.new(@internal_flags, @custom_property_repository, device_properties, nil, !roxy_path.nil?)
+        @impression_invoker = ImpressionInvoker.new(@internal_flags, @custom_property_repository, device_properties,
+                                                    nil, !roxy_path.nil?, @user_unhandled_error_invoker)
         @flag_setter = FlagSetter.new(@flag_repository, @parser, @experiment_repository, @impression_invoker)
         buid = BUID.new(sdk_settings, device_properties, @flag_repository, @custom_property_repository)
 
-        request_config_builder = RequestConfigurationBuilder.new(sdk_settings, buid, device_properties, roxy_path)
+        request_config_builder = RequestConfigurationBuilder.new(sdk_settings, buid, device_properties)
 
         client_request = Request.new
         err_reporter_request = Request.new
 
         @error_reporter = ErrorReporter.new(err_reporter_request, device_properties, buid)
 
-        if roxy_path.nil?
-          @configuration_fetcher = ConfigurationFetcher.new(request_config_builder, client_request, @configuration_fetched_invoker)
-          @state_sender = StateSender.new(@sdk_settings, device_properties, @flag_repository, @custom_property_repository)
+        if @rox_options.self_managed?
+          @configuration_fetcher = ConfigurationFetcherSelfManaged.new(request_config_builder, client_request,
+                                                                       @configuration_fetched_invoker)
+          @state_sender = StateSender.new(@sdk_settings, device_properties, @flag_repository,
+                                          @custom_property_repository)
+          @flag_repository.register_flag_added_handler { @state_sender.delayed_send }
+          @custom_property_repository.register_property_added_handler { @state_sender.delayed_send }
+        elsif roxy_path.nil?
+          @configuration_fetcher = ConfigurationFetcher.new(request_config_builder, client_request,
+                                                            @configuration_fetched_invoker)
+          @state_sender = StateSender.new(@sdk_settings, device_properties, @flag_repository,
+                                          @custom_property_repository)
           @flag_repository.register_flag_added_handler { @state_sender.delayed_send }
           @custom_property_repository.register_property_added_handler { @state_sender.delayed_send }
         else
-          @configuration_fetcher = ConfigurationFetcherRoxy.new(request_config_builder, client_request, @configuration_fetched_invoker)
+          @configuration_fetcher = ConfigurationFetcherRoxy.new(request_config_builder, client_request,
+                                                                @configuration_fetched_invoker)
         end
 
         configuration_fetched_handler = nil
-        unless rox_options.nil?
-          configuration_fetched_handler = rox_options.configuration_fetched_handler
-        end
+        configuration_fetched_handler = @rox_options.configuration_fetched_handler unless @rox_options.nil?
 
-        @configuration_fetched_invoker.register_fetched_handler(&wrap_configuration_fetched_handler(&configuration_fetched_handler))
+        @configuration_fetched_invoker.register_start_stop_push(proc do |args|
+          start_or_stop_push_updated_listener unless args.fetcher_status == FetcherStatus::ERROR_FETCHED_FAILED
+        end)
+
+        @configuration_fetched_invoker.register_fetched_handler(&configuration_fetched_handler)
 
-        Thread.new do
+        @thread = Thread.new do
           Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception)
           fetch
-          @state_sender&.delayed_send
+          @state_sender&.send
 
-          if !rox_options.nil? && !rox_options.impression_handler.nil?
-            @impression_invoker.register_impression_handler(&rox_options.impression_handler)
+          if !@rox_options.nil? && !@rox_options.impression_handler.nil?
+            @impression_invoker.register_impression_handler(&@rox_options.impression_handler)
           end
 
-          if !rox_options.nil? && !rox_options.fetch_interval.nil?
-            PeriodicTask.run(rox_options.fetch_interval) { fetch }
+          if !@rox_options.nil? && !@rox_options.fetch_interval.nil?
+            PeriodicTask.run(@rox_options.fetch_interval) { fetch }
           end
         end
       end
 
+      def shutdown
+        return if @thread.nil?
+
+        Thread.kill(@thread)
+        @thread = nil
+
+        unless @push_updates_listener.nil?
+          @push_updates_listener.stop
+          @push_updates_listener = nil
+        end
+
+        #return if @analytics_client.nil?
+
+        #@analytics_client.flush
+      end
+
       def fetch
         return if @configuration_fetcher.nil?
 
-        configuration_parser = ConfigurationParser.new(SignatureVerifier.new, @error_reporter, @configuration_fetched_invoker)
+        signature_verifier = if @rox_options.self_managed?
+                               SignatureVerifierMock.new
+                             else
+                               SignatureVerifier.new
+                             end
+        configuration_parser = ConfigurationParser.new(signature_verifier, @error_reporter,
+                                                       @configuration_fetched_invoker)
         result = @configuration_fetcher.fetch
         return if result.nil?
 
@@ -122,17 +165,22 @@ module Rox
 
         has_changes = @last_configurations.nil? || @last_configurations.data != result.data
         @last_configurations = result
-        @configuration_fetched_invoker.invoke(FetcherStatus::APPLIED_FROM_NETWORK, configuration.signature_date, has_changes)
+        @configuration_fetched_invoker.invoke(FetcherStatus::APPLIED_FROM_NETWORK, configuration.signature_date,
+                                              has_changes)
+      end
+
+      def register_with_namespace(namespace, rox_container)
+        @registerer.register_instance(rox_container, namespace)
       end
 
-      def register(ns, rox_container)
-        @registerer.register_instance(rox_container, ns)
+      def register(*args)
+        rox_container = args.pop
+        namespace = args.length == 1 ? args.pop : ''
+        @registerer.register_instance(rox_container, namespace)
       end
 
       def context=(context)
-        @flag_repository.all_flags.each do |flag|
-          flag.context = context
-        end
+        @parser.global_context = context
       end
 
       def add_custom_property(property)
@@ -143,18 +191,11 @@ module Rox
         @custom_property_repository.add_custom_property_if_not_exists(property)
       end
 
-      def wrap_configuration_fetched_handler(&handler)
-        lambda do |args|
-          start_or_stop_push_updated_listener unless args.fetcher_status == FetcherStatus::ERROR_FETCHED_FAILED
-          handler.call(args) unless handler.nil?
-        end
-      end
-
       def start_or_stop_push_updated_listener
         if @internal_flags.enabled?('rox.internal.pushUpdates')
           if @push_updates_listener.nil?
             @push_updates_listener = NotificationListener.new(Environment.notifications_path, @sdk_settings.api_key)
-            @push_updates_listener.on 'changed' do |data|
+            @push_updates_listener.on 'changed' do |_data|
               fetch
             end
             @push_updates_listener.start
@@ -171,12 +212,16 @@ module Rox
         Rox::Core::DynamicApi.new(@flag_repository, entities_provider)
       end
 
+      def dump_state
+        @state_sender.dump_state
+      end
+
       def validate_api_key(api_key)
         valid_api_key_pattern = /^[a-f\d]{24}$/
         if api_key&.strip&.empty?
-          raise ArgumentError.new('Blank Rollout api key - must be specified')
+          raise ArgumentError, 'Blank Rollout api key - must be specified'
         elsif !valid_api_key_pattern.match(api_key)
-          raise ArgumentError.new('Illegal Rollout api key')
+          raise ArgumentError, 'Illegal Rollout api key'
         end
       end
     end

data/lib/rox/core/entities/default_flag_values.rb

@@ -0,0 +1,10 @@
+module Rox
+  module Core
+    class DefaultFlagValues
+      STRING = ''
+      INT = 0
+      FLOAT = 0.0
+      BOOLEAN = false
+    end
+  end
+end

data/lib/rox/core/entities/flag.rb

@@ -1,20 +1,35 @@
-require 'rox/core/entities/variant'
+require 'rox/core/entities/rox_string'
+require 'rox/core/entities/default_flag_values'
 
 module Rox
   module Core
-    class Flag < Variant
+    class Flag < RoxString
       FLAG_TRUE_VALUE = 'true'.freeze
       FLAG_FALSE_VALUE = 'false'.freeze
 
-      def initialize(default_value = false)
-        super(default_value ? Flag::FLAG_TRUE_VALUE : Flag::FLAG_FALSE_VALUE, [Flag::FLAG_FALSE_VALUE, Flag::FLAG_TRUE_VALUE])
+      def initialize(default_value = DefaultFlagValues::BOOLEAN)
+        super(default_value ? Flag::FLAG_TRUE_VALUE : Flag::FLAG_FALSE_VALUE, [Flag::FLAG_FALSE_VALUE,
+                                                                               Flag::FLAG_TRUE_VALUE])
       end
 
       def enabled?(context)
-        value(context) == Flag::FLAG_TRUE_VALUE
+        merged_context = MergedContext.new(@parser&.global_context, context)
+        value = internal_enabled?(merged_context)
+        if [true, false].include? value
+          send_impressions(value, merged_context)
+          return value
+        end
+
+        send_impressions(DefaultFlagValues::BOOLEAN, merged_context)
+        DefaultFlagValues.BOOLEAN
+      end
+
+      def value(context = nil)
+        merged_context = MergedContext.new(@parser&.global_context, context)
+        internal_value(merged_context, false)
       end
 
-      def internal_enabled?(context, nil_instead_of_default)
+      def internal_enabled?(context, nil_instead_of_default = false)
         val = internal_value(context, nil_instead_of_default)
         nil_instead_of_default && val.nil? ? nil : (val == Flag::FLAG_TRUE_VALUE)
       end
@@ -28,4 +43,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/entities/flag_setter.rb

@@ -7,9 +7,9 @@ module Rox
         @experiment_repository = experiment_repository
         @impression_invoker = impression_invoker
 
-        @flag_repository.register_flag_added_handler do |variant|
-          exp = @experiment_repository.experiment_by_flag(variant.name)
-          set_flag_data(variant, exp)
+        @flag_repository.register_flag_added_handler do |string|
+          exp = @experiment_repository.experiment_by_flag(string.name)
+          set_flag_data(string, exp)
         end
       end
 
@@ -31,9 +31,9 @@ module Rox
         end
       end
 
-      def set_flag_data(variant, experiment = nil)
-        variant.set_for_evaluation(@parser, experiment, @impression_invoker)
+      def set_flag_data(string, experiment = nil)
+        string.set_for_evaluation(@parser, experiment, @impression_invoker)
       end
     end
   end
-end
+end

data/lib/rox/core/entities/rox_double.rb

@@ -0,0 +1,11 @@
+require 'rox/core/entities/rox_string'
+
+module Rox
+  module Core
+    class RoxDouble < RoxString
+      def value(context = nil)
+        internal_value(context, false, Float)
+      end
+    end
+  end
+end

data/lib/rox/core/entities/rox_int.rb

@@ -0,0 +1,11 @@
+require 'rox/core/entities/rox_string'
+
+module Rox
+  module Core
+    class RoxInt < RoxString
+      def value(context = nil)
+        internal_value(context, false, Integer)
+      end
+    end
+  end
+end

data/lib/rox/core/entities/{variant.rb → rox_string.rb}

@@ -4,22 +4,31 @@ require 'rox/core/impression/models/reporting_value'
 
 module Rox
   module Core
-    class Variant
-      attr_accessor :default_value, :options, :name, :context, :condition, :parser, :impression_invoker, :client_experiment
+    class RoxString
+      attr_accessor :default_value, :options, :name, :condition, :parser, :impression_invoker,
+                    :client_experiment
 
       def initialize(default_value, options = [])
         @default_value = default_value
         @options = options.clone
+        raise ArgumentError, 'options should be an array' unless options.is_a?(Array)
+        if options.length > 0 && options.any? { |x| x.class != default_value.class }
+          raise ArgumentError, 'options should be the same type as default value'
+        end
         @options << default_value unless options.include?(default_value)
 
         @condition = nil
         @parser = nil
-        @context = nil
         @impression_invoker = nil
         @client_experiment = nil
         @name = nil
       end
 
+      def send_impressions(return_value, merged_context)
+        reporting_value = ReportingValue.new(@name, return_value, @client_experiment)
+        @impression_invoker&.invoke(reporting_value, @client_experiment, merged_context)
+      end
+
       def set_for_evaluation(parser, experiment, impression_invoker)
         if experiment.nil?
           @client_experiment = nil
@@ -37,24 +46,22 @@ module Rox
         internal_value(context, false)
       end
 
-      def internal_value(context, nil_instead_of_default)
+      def internal_value(context, nil_instead_of_default, evaluated_type = String)
         return_value = nil_instead_of_default ? nil : @default_value
-        merged_context = MergedContext.new(@context, context)
+        merged_context = MergedContext.new(@parser&.global_context, context)
 
-        if !@parser.nil? && !@condition.nil? && !@condition.empty?
+        unless @parser.nil? || @condition.nil? || @condition.empty?
           evaluation_result = @parser.evaluate_expression(@condition, merged_context)
           unless evaluation_result.nil?
-            value = evaluation_result.string_value
-            if !value.nil? && !value.empty?
-              return_value = value
-            end
+            value = evaluated_type == String ? evaluation_result.string_value : evaluation_result.value
+            is_empty = value.is_a?(String) && value.empty?
+            return_value = value if !value.nil? && !is_empty
           end
         end
 
-        @impression_invoker.invoke(ReportingValue.new(@name, return_value), @client_experiment, merged_context) if @impression_invoker != nil
-
+        send_impressions(return_value, merged_context)
         return_value
       end
     end
   end
-end
+end

data/lib/rox/core/error_handling/exception_trigger.rb

@@ -0,0 +1,10 @@
+module Rox
+  module Core
+    module ExceptionTrigger
+      DYNAMIC_PROPERTIES_RULE = 1
+      CONFIGURATION_FETCHED_HANDLER = 2
+      IMPRESSION_HANDLER = 3
+      CUSTOM_PROPERTY_GENERATOR = 4
+    end
+  end
+end

data/lib/rox/core/error_handling/userspace_handler_exception.rb

@@ -0,0 +1,13 @@
+module Rox
+  module Core
+    class UserspaceHandlerException < StandardError
+      attr_accessor :exception_source, :exception_trigger, :original_exception
+      def initialize(exception_source, exception_trigger, original_exception)
+        @exception_source = exception_source
+        @exception_trigger = exception_trigger
+        @original_exception = original_exception
+        super('user unhandled exception in roxx expression')
+      end
+    end
+  end
+end

data/lib/rox/core/error_handling/userspace_unhandled_error_invoker.rb

@@ -0,0 +1,41 @@
+require 'rox/core/logging/logging'
+
+module Rox
+  module Core
+    class UserspaceUnhandledErrorInvoker
+      def initialize(user_unhandler_error_handler = nil)
+        @user_unhandler_error_handler = user_unhandler_error_handler
+      end
+
+      def invoke(exception_source, exception_trigger, exception)
+        unless @user_unhandler_error_handler
+          Logging.logger.error("User Unhandled Error Occurred, no fallback handler was set, exception ignored: #{exception}")
+          return
+        end
+
+        begin
+          userspace_unhandled_error_args = UserspaceUnhandledErrorArgs.new(exception_source, exception_trigger, exception)
+          @user_unhandler_error_handler.call(userspace_unhandled_error_args)
+        rescue StandardError => e
+          Logging.logger.error("User Unhandled Error Handler itself threw an exception. original exception: #{e}")
+        end
+      end
+
+      def handler=(handler)
+        @user_unhandler_error_handler = handler
+      end
+    end
+
+    class UserspaceUnhandledErrorArgs
+      def initialize(exception_source = nil, exception_trigger = nil, exception = nil)
+        @exception_source = exception_source
+        @exception_trigger = exception_trigger
+        @exception = exception
+      end
+
+      def to_s
+        "UserspaceUnhandledErrorArgs(#{@exception_source}, #{@exception_trigger}, #{@exception})"
+      end
+    end
+  end
+end

data/lib/rox/core/impression/impression_args.rb

@@ -1,5 +1,5 @@
 module Rox
   module Core
-    ImpressionArgs = Struct.new(:reporting_value, :experiment, :context)
+    ImpressionArgs = Struct.new(:reporting_value, :context)
   end
-end
+end

data/lib/rox/core/impression/impression_invoker.rb

@@ -1,23 +1,58 @@
 require 'rox/core/impression/impression_args'
+require 'rox/core/logging/logging'
+require 'rox/core/error_handling/exception_trigger'
+require 'rox/core/consts/property_type'
 
 module Rox
   module Core
     class ImpressionInvoker
-      def initialize(internal_flags, custom_property_repository, device_properties, analytics_client, is_roxy)
+      def initialize(internal_flags, custom_property_repository, device_properties, analytics_client, is_roxy, user_unhandled_error_invoker)
         @internal_flags = internal_flags
         @custom_property_repository = custom_property_repository
         @device_properties = device_properties
         @analytics_client = analytics_client
         @is_roxy = is_roxy
+        @user_unhandled_error_invoker = user_unhandled_error_invoker
 
         @impression_handlers = []
         @mutex = Mutex.new
       end
 
-      def invoke(reporting_value, client_experiment, context)
-        # TODO: Implement analytics logic
+      # TODO: write analytics client and initiate it before using it
+      def call_analytics_gateway(reporting_value, stickiness_property, context)
+        begin
+          analytics_enabled = @internal_flags.enabled?('rox.internal.analytics')
+          if analytics_enabled && !@is_roxy
+            prop = @custom_property_repository.custom_property(stickiness_property) || @custom_property_repository.custom_property("rox.#{Rox::Core::PropertyType::DISTINCT_ID.name}")
+            distinct_id = '(null_distinct_id'
+            unless prop.nil?
+              prop_value = prop.value(context)
+              distinct_id = prop_value if prop_value.instance_of?(String)
+            end
 
-        raise_impression_event(ImpressionArgs.new(reporting_value, client_experiment, context))
+            event_time = (Time.now.to_f * 1000.0).to_i
+            begin
+              event_time = ENV['rox.analytics.ms'].to_i
+            rescue StandardError
+            end
+
+            @analytics_client.track({
+                                      flag: reporting_value.name,
+                                      value: reporting_value.value,
+                                      distinctId: distinct_id,
+                                      experimentVersion: '0',
+                                      type: 'IMPRESSION',
+                                      time: event_time
+                                    })
+          end
+        rescue StandardError => ex
+          Logging.logger.error('Failed to send analytics', ex)
+        end
+      end
+      
+      def invoke(reporting_value, stickiness_property, context)
+        #call_analytics_gateway
+        raise_impression_event(ImpressionArgs.new(reporting_value, context))
       end
 
       def register_impression_handler(&block)
@@ -33,9 +68,14 @@ module Rox
         end
 
         handlers.each do |handler|
-          handler.call(args)
+          begin
+            handler.call(args)
+          rescue StandardError => e
+            @user_unhandled_error_invoker.invoke(handler, ExceptionTrigger::IMPRESSION_HANDLER, e)
+            Logging.logger.error('Impresssion handler exception', e)
+          end
         end
       end
     end
   end
-end
+end

data/lib/rox/core/impression/models/experiment.rb

@@ -11,4 +11,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/impression/models/reporting_value.rb

@@ -1,5 +1,13 @@
 module Rox
   module Core
-    ReportingValue = Struct.new(:name, :value)
+    class ReportingValue
+      attr_reader :name, :value, :targeting
+
+      def initialize(name, value, experiment = nil)
+        @name = name
+        @value = value
+        @targeting = !experiment.nil?
+      end
+    end
   end
-end
+end

data/lib/rox/core/logging/logging.rb

@@ -5,8 +5,8 @@ module Rox
     class Logging
       @logger = nil
 
-      def self.logger=(logger)
-        @logger = logger
+      class << self
+        attr_writer :logger
       end
 
       def self.logger
@@ -14,4 +14,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/logging/no_op_logger.rb

@@ -8,4 +8,4 @@ module Rox
       def warn(message, ex = nil); end
     end
   end
-end
+end

data/lib/rox/core/network/configuration_fetcher.rb

@@ -19,8 +19,8 @@ module Rox
           end
 
           write_fetch_error_to_log_and_invoke_fetch_handler(source, fetch_result)
-        rescue StandardError => ex
-          write_fetch_exception_to_log_and_invoke_fetch_handler(source, ex)
+        rescue StandardError => e
+          write_fetch_exception_to_log_and_invoke_fetch_handler(source, e)
         end
 
         nil

data/lib/rox/core/network/configuration_fetcher_roxy.rb

@@ -14,8 +14,8 @@ module Rox
           else
             write_fetch_error_to_log_and_invoke_fetch_handler(source, fetch_roxy)
           end
-        rescue StandardError => ex
-          write_fetch_exception_to_log_and_invoke_fetch_handler(source, ex)
+        rescue StandardError => e
+          write_fetch_exception_to_log_and_invoke_fetch_handler(source, e)
         end
 
         nil