rox-rollout 4.7.3 → 5.0.0

data/e2e/rox_e2e_test.rb

@@ -1,4 +1,4 @@
-require "minitest/autorun"
+require 'minitest/autorun'
 require 'rox/server/rox_options'
 require 'rox/server/rox_server'
 require_relative 'container'
@@ -7,7 +7,7 @@ require_relative 'test_vars'
 
 module E2E
   class Logger
-    def debug(message, ex = nil)
+    def debug(message, _ex = nil)
       puts 'Before Rox.Setup', message
     end
 
@@ -15,7 +15,7 @@ module E2E
       puts 'Before Rox.Setup', message, ex
     end
 
-    def warn(message, ex = nil)
+    def warn(message, _ex = nil)
       puts 'Before Rox.Setup', message
     end
   end
@@ -30,8 +30,8 @@ module E2E
     end
 
     impression_handler = proc do |e|
-      if !e.nil? && !e.reporting_value.nil?
-        TestVars.is_impression_raised = true if e.reporting_value.name == 'flag_for_impression'
+      if !e.nil? && !e.reporting_value.nil? && (e.reporting_value.name == 'flag_for_impression')
+        TestVars.is_impression_raised = true
       end
       TestVars.impression_returned_args = e
     end
@@ -44,7 +44,7 @@ module E2E
     )
 
     @@container = Container.new
-    Rox::Server::RoxServer.register('', @@container)
+    Rox::Server::RoxServer.register(@@container)
     CustomProps.create_custom_props
     Rox::Server::RoxServer.setup('5b82864ebc3aec37aff1fdd5', option).join
 
@@ -56,7 +56,7 @@ module E2E
       assert_equal false, @@container.simple_flag_overwritten.enabled?
     end
 
-    def test_variant
+    def test_string
       assert_equal 'red', @@container.variant.value
     end
 
@@ -87,9 +87,9 @@ module E2E
       end
     end
 
-    def test_variant_with_context
-      some_positive_context = {'isDuckAndCover' => true}
-      some_negative_context = {'isDuckAndCover' => false}
+    def test_string_with_context
+      some_positive_context = { 'isDuckAndCover' => true }
+      some_negative_context = { 'isDuckAndCover' => false }
 
       assert_equal 'red', @@container.variant_with_context.value
 
@@ -121,18 +121,16 @@ module E2E
       assert_equal true, TestVars.is_impression_raised
       TestVars.is_impression_raised = false
 
-      context = {'var' => 'val'}
+      context = { 'var' => 'val' }
       flag_impression_value = @@container.flag_for_impression_with_experiment_and_context.enabled?(context)
       refute_nil TestVars.impression_returned_args
       refute_nil TestVars.impression_returned_args.reporting_value
-      assert_equal 'true', TestVars.impression_returned_args.reporting_value.value
+      assert_equal true, TestVars.impression_returned_args.reporting_value.value
       assert_equal true, flag_impression_value
-      assert_equal 'flag_for_impression_with_experiment_and_context', TestVars.impression_returned_args.reporting_value.name
+      assert_equal 'flag_for_impression_with_experiment_and_context',
+                   TestVars.impression_returned_args.reporting_value.name
 
       refute_nil TestVars.impression_returned_args
-      refute_nil TestVars.impression_returned_args.experiment
-      assert_equal '5b8f85ecbc3aec37aff20841', TestVars.impression_returned_args.experiment.identifier
-      assert_equal 'flag for impression with experiment and context', TestVars.impression_returned_args.experiment.name
 
       assert_equal 'val', TestVars.impression_returned_args.context['var']
     end
@@ -147,9 +145,9 @@ module E2E
       assert_equal false, @@container.flag_for_dependency.enabled?
     end
 
-    def test_variant_dependency_with_context
-      some_positive_context = {'isDuckAndCover' => true}
-      some_negative_context = {'isDuckAndCover' => false}
+    def test_string_dependency_with_context
+      some_positive_context = { 'isDuckAndCover' => true }
+      some_negative_context = { 'isDuckAndCover' => false }
 
       assert_equal 'White', @@container.flag_color_dependent_with_context.value
       assert_equal 'White', @@container.flag_color_dependent_with_context.value(some_negative_context)

data/e2e/test_vars.rb

@@ -1,11 +1,8 @@
 module E2E
   module TestVars
     class << self
-      attr_accessor :is_computed_boolean_prop_called, :is_computed_string_prop_called, :is_computed_int_prop_called, :is_computed_float_prop_called, :is_computed_semver_prop_called
-      attr_accessor :target_group1, :target_group2
-      attr_accessor :is_impression_raised, :is_prop_for_target_group_for_dependency
-
-      attr_accessor :configuration_fetched_count, :impression_returned_args
+      attr_accessor :is_computed_boolean_prop_called, :is_computed_string_prop_called, :is_computed_int_prop_called,
+                    :is_computed_float_prop_called, :is_computed_semver_prop_called, :target_group1, :target_group2, :is_impression_raised, :is_prop_for_target_group_for_dependency, :configuration_fetched_count, :impression_returned_args
     end
 
     @is_computed_boolean_prop_called = false
@@ -21,4 +18,4 @@ module E2E
     @configuration_fetched_count = 0
     @impression_returned_args = nil
   end
-end
+end

data/example/local.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
+require 'rox/server/rox_server'
+require 'rox/server/rox_options'
+
+API_HOST = 'http://localhost:8557'.freeze
+APP_KEY = '600571e330819d4842999e4f'.freeze
+DEV_MODE_SECRET = 'e56cda16749d8d0a9b91d34c'.freeze
+
+class Flags
+  attr_accessor :boolean_flag, :string_flag, :int_flag, :double_flag
+
+  def initialize
+    # Define the feature flags
+    @boolean_flag = Rox::Server::RoxFlag.new(true)
+    @string_flag = Rox::Server::RoxString.new('option 1', ['option 1', 'option 2', 'option 3'])
+    @int_flag = Rox::Server::RoxInt.new(1, [1, 2, 3])
+    @double_flag = Rox::Server::RoxDouble.new(4.0, [5.0, 6.0])
+  end
+end
+
+flags = Flags.new
+Rox::Server::RoxServer.register(flags)
+
+options = Rox::Server::RoxOptions.new(
+  self_managed_options: Rox::Server::SelfManagedOptions.new(
+    server_url: API_HOST,
+    analytics_url: 'http://127.0.0.1:8787'
+  ),
+  dev_mode_key: DEV_MODE_SECRET
+)
+
+Rox::Server::RoxServer.setup(APP_KEY, options)
+
+puts "boolean_flag is #{flags.boolean_flag.enabled?}"
+puts "boolean_flag is #{Rox::Server::RoxServer.dynamic_api.enabled?('boolean_flag', true)} (dynamic api)"
+puts "boolean_flag is #{Rox::Server::RoxServer.dynamic_api.enabled?('boolean_flag', true)} (dynamic api)"
+puts "string_flag is #{flags.string_flag.value}"
+puts "int_flag is #{flags.int_flag.value}"
+puts "double_flag is #{flags.double_flag.value}"

data/lib/rox/core/analytics.rb

@@ -0,0 +1,18 @@
+require 'segment/analytics'
+
+module Rox
+  module Core
+    # Analytics based on segment client
+    # https://segment.com/docs/connections/sources/catalog/libraries/server/ruby/
+    class Analytics
+      attr_reader :client
+
+      def initialize(key)
+        @client = Segment::Analytics.new({
+                                           write_key: key,
+                                           on_error: proc { |_status, msg| print msg }
+                                         })
+      end
+    end
+  end
+end

data/lib/rox/core/client/buid.rb

@@ -6,13 +6,13 @@ module Rox
   module Core
     class BUID
       BUID_GENERATORS = [
-          PropertyType::PLATFORM,
-          PropertyType::APP_KEY,
-          PropertyType::LIB_VERSION,
-          PropertyType::API_VERSION
+        PropertyType::PLATFORM,
+        PropertyType::APP_KEY,
+        PropertyType::LIB_VERSION,
+        PropertyType::API_VERSION
       ].freeze
 
-      def initialize(sdk_settings, device_properties, flag_repository, custom_property_repository)
+      def initialize(sdk_settings, device_properties, _flag_repository, _custom_property_repository)
         @sdk_settings = sdk_settings
         @device_properties = device_properties
         @buid = nil
@@ -31,11 +31,11 @@ module Rox
       end
 
       def query_string_parts
-        generators = BUID::BUID_GENERATORS.map {|pt, _| pt.name}
+        generators = BUID::BUID_GENERATORS.map { |pt, _| pt.name }
 
         {
-            PropertyType::BUID.name => value,
-            PropertyType::BUID_GENERATORS_LIST.name => generators.join(','),
+          PropertyType::BUID.name => value,
+          PropertyType::BUID_GENERATORS_LIST.name => generators.join(',')
         }
       end
 

data/lib/rox/core/client/device_properties.rb

@@ -4,11 +4,17 @@ require 'rox/core/consts/build'
 module Rox
   module Core
     class DeviceProperties
+      attr_reader :rox_options
+
       def initialize(sdk_settings, rox_options)
         @sdk_settings = sdk_settings
         @rox_options = rox_options
       end
 
+      def get(property)
+        all_properties[property.name]
+      end
+
       def all_properties
         {
           PropertyType::PACKAGE_NAME.name => @rox_options.version,
@@ -20,7 +26,7 @@ module Rox
           PropertyType::APP_RELEASE.name => @rox_options.version,
           PropertyType::DISTINCT_ID.name => distinct_id,
           PropertyType::APP_KEY.name => @sdk_settings.api_key,
-          PropertyType::PLATFORM.name => Build::PLATFORM,
+          PropertyType::PLATFORM.name => Build::PLATFORM
         }
       end
 

data/lib/rox/core/client/dynamic_api.rb

@@ -1,4 +1,5 @@
 require 'rox/core/entities/flag'
+require 'rox/server/flags/normalize_flag_type'
 
 module Rox
   module Core
@@ -9,28 +10,65 @@ module Rox
       end
 
       def enabled?(name, default_value, context = nil)
-        variant = @flag_repository.flag(name)
-        if variant.nil?
-          variant = @entities_provider.create_flag(default_value)
-          @flag_repository.add_flag(variant, name)
-        end
+        raise ArgumentError, 'flag name should be a string' unless name.is_a?(String)
+        raise ArgumentError, 'default value should be boolean' unless [true, false].include?(default_value)
 
-        return default_value unless variant.is_a?(Flag)
+        string = @flag_repository.flag(name)
+        if string.nil?
+          string = @entities_provider.create_flag(default_value)
+          @flag_repository.add_flag(string, name)
+        end
 
-        is_enabled = variant.internal_enabled?(context, nil_instead_of_default: true)
-        is_enabled.nil? ? default_value : is_enabled
+        merged_context = MergedContext.new(string.parser&.global_context, context)
+        return_value = unless string.is_a?(Flag)
+                         default_value
+                       else
+                         is_enabled = string.internal_enabled?(context, nil_instead_of_default: true)
+                         is_enabled.nil? ? default_value : is_enabled
+                       end
+        string.send_impressions(return_value, merged_context)
+        return_value
       end
 
       def value(name, default_value, context = nil, options = [])
-        variant = @flag_repository.flag(name)
-        if variant.nil?
-          variant = @entities_provider.create_variant(default_value, options)
-          @flag_repository.add_flag(variant, name)
+        generic_value(name, default_value, context, options)
+      end
+
+      def int_value(name, default_value, context = nil, options = [])
+        create_method = @entities_provider.method(:create_int)
+        normalize_method = Rox::Server::NormalizeFlagType.method(:normalize_int)
+        generic_value(name, default_value, context, options, Integer, create_method, normalize_method)
+      end
+
+      def double_value(name, default_value, context = nil, options = [])
+        create_method = @entities_provider.method(:create_double)
+        normalize_method = Rox::Server::NormalizeFlagType.method(:normalize_float)
+        generic_value(name, default_value, context, options, Float, create_method, normalize_method)
+      end
+
+      private
+
+      def generic_value(name, default_value, context, options, flag_type = String, create_method = nil, normalize_method = Rox::Server::NormalizeFlagType.method(:normalize_string))
+        unless name.is_a?(String)
+          raise ArgumentError, 'DynamicApi error - name must be string'
+        end
+
+        unless default_value.is_a?(flag_type)
+          raise ArgumentError, "DynamicApi default value must be of #{flag_type} type. Received #{default_value}"
+        end
+
+        string = @flag_repository.flag(name)
+        if string.nil?
+          string = create_method.nil? ? @entities_provider.create_string(default_value, options) : create_method.call(default_value, options)
+          @flag_repository.add_flag(string, name)
         end
 
-        value = variant.internal_value(context, nil_instead_of_default: true)
-        value.nil? ? default_value : value
+        merged_context = MergedContext.new(string.parser&.global_context, context)
+        value = string.internal_value(context, nil_instead_of_default: true)
+        return_value = value.nil? ? normalize_method.call(default_value) : normalize_method.call(value)
+        string.send_impressions(return_value, merged_context)
+        return_value
       end
     end
   end
-end
+end

data/lib/rox/core/client/internal_flags.rb

@@ -3,12 +3,24 @@ require 'rox/core/entities/flag'
 module Rox
   module Core
     class InternalFlags
-      def initialize(experiment_repository, parser)
+      @@defaults_self_managed = {
+        'rox.internal.pushUpdates' => false,
+        'rox.internal.considerThrottleInPush' => false,
+        'rox.internal.throttleFetchInSeconds' => 0
+      }
+
+      def initialize(experiment_repository, parser, rox_options)
         @experiment_repository = experiment_repository
         @parser = parser
+        @rox_options = rox_options
       end
 
       def enabled?(flag_name)
+        if @rox_options.self_managed?
+          value = @@defaults_self_managed[flag_name]
+          return value unless value.nil?
+        end
+
         internal_experiment = @experiment_repository.experiment_by_flag(flag_name)
         return false if internal_experiment.nil?
 
@@ -17,4 +29,4 @@ module Rox
       end
     end
   end
-end
+end

data/lib/rox/core/client/sdk_settings.rb

@@ -2,4 +2,4 @@ module Rox
   module Core
     SdkSettings = Struct.new(:api_key, :dev_mode_secret)
   end
-end
+end

data/lib/rox/core/configuration/configuration.rb

@@ -2,4 +2,4 @@ module Rox
   module Core
     Configuration = Struct.new(:experiments, :target_groups, :signature_date)
   end
-end
+end

data/lib/rox/core/configuration/configuration_fetched_args.rb

@@ -14,10 +14,10 @@ module Rox
       end
 
       def self.error(error_details)
-        args = ConfigurationFetchedArgs.new(FetcherStatus::ERROR_FETCHED_FAILED, nil, false )
+        args = ConfigurationFetchedArgs.new(FetcherStatus::ERROR_FETCHED_FAILED, nil, false)
         args.error_details = error_details
         args
       end
     end
   end
-end
+end

data/lib/rox/core/configuration/configuration_fetched_invoker.rb

@@ -3,9 +3,10 @@ require 'rox/core/configuration/configuration_fetched_args'
 module Rox
   module Core
     class ConfigurationFetchedInvoker
-      def initialize
+      def initialize(user_unhandled_error_invoker)
         @fetched_handlers = []
         @mutex = Mutex.new
+        @user_unhandled_error_invoker = user_unhandled_error_invoker
       end
 
       def invoke(fetcher_status, creation_date, has_changes)
@@ -29,9 +30,13 @@ module Rox
         end
 
         handlers.each do |handler|
-          handler.call(args)
+          begin
+            handler.call(args)
+          rescue StandardError => e
+            user_unhandled_error_invoker.invoke(handler, Rox::Core::CONFIGURATION_FETCHED_HANDLER, e)
+          end
         end
       end
     end
   end
-end
+end

data/lib/rox/core/configuration/configuration_parser.rb

@@ -17,50 +17,51 @@ module Rox
       end
 
       def parse(fetch_result, sdk_settings)
-        begin
-          if fetch_result.nil? || fetch_result.data.nil? || fetch_result.data.empty?
-            @configuration_fetched_invoker.invoke_error(FetcherError::EMPTY_JSON)
-            @error_reporter.report('Failed to parse JSON configuration - Null Or Empty', ArgumentError.new('data'))
-            return nil
-          end
-
-          begin
-            json_obj = JSON.parse(fetch_result.data)
-          rescue StandardError => ex
-            @configuration_fetched_invoker.invoke_error(FetcherError::CORRUPTED_JSON)
-            @error_reporter.report('Failed to parse JSON configuration', ex)
-            return nil
-          end
-
-          if fetch_result.source != ConfigurationSource::ROXY && !@signature_verifier.verify(json_obj['data'], json_obj['signature_v0'])
-            @configuration_fetched_invoker.invoke_error(FetcherError::SIGNATURE_VERIFICATION_ERROR)
-            @error_reporter.report('Failed to validate signature', StandardError.new("Data : #{json_obj['data']} Signature : #{json_obj['signature_v0']}"))
-            return nil
-          end
+        if fetch_result.nil? || fetch_result.data.nil? || fetch_result.data.empty?
+          @configuration_fetched_invoker.invoke_error(FetcherError::EMPTY_JSON)
+          @error_reporter.report('Failed to parse JSON configuration - Null Or Empty', ArgumentError.new('data'))
+          return nil
+        end
 
-          signature_date = DateTime.rfc3339(json_obj['signed_date']).to_time
-          internal_data_string = json_obj['data']
-          internal_data_object = JSON.parse(internal_data_string)
+        begin
+          json_obj = JSON.parse(fetch_result.data)
+        rescue StandardError => e
+          @configuration_fetched_invoker.invoke_error(FetcherError::CORRUPTED_JSON)
+          @error_reporter.report('Failed to parse JSON configuration', e)
+          return nil
+        end
 
-          if fetch_result.source != ConfigurationSource::ROXY && internal_data_object['application'] != sdk_settings.api_key
-            @configuration_fetched_invoker.invoke_error(FetcherError::MISMATCH_APP_KEY)
-            @error_reporter.report('Failed to parse JSON configuration - ', StandardError.new("Internal Data: #{internal_data_object['application']} SdkSettings: #{sdk_settings.api_key}"))
-            return nil
-          end
+        if fetch_result.source != ConfigurationSource::ROXY && !@signature_verifier.verify(json_obj['data'],
+                                                                                           json_obj['signature_v0'])
+          @configuration_fetched_invoker.invoke_error(FetcherError::SIGNATURE_VERIFICATION_ERROR)
+          @error_reporter.report('Failed to validate signature',
+                                 StandardError.new("Data : #{json_obj['data']} Signature : #{json_obj['signature_v0']}"))
+          return nil
+        end
 
-          experiments = parse_experiments(internal_data_object)
-          target_groups = parse_target_groups(internal_data_object)
+        signature_date = DateTime.rfc3339(json_obj['signed_date']).to_time
+        internal_data_string = json_obj['data']
+        internal_data_object = JSON.parse(internal_data_string)
 
-          Configuration.new(experiments, target_groups, signature_date)
-        rescue StandardError => ex
-          Logging.logger.error('Failed to parse configurations', ex)
-          @configuration_fetched_invoker.invoke_error(FetcherError::UNKNOWN)
+        if fetch_result.source != ConfigurationSource::ROXY && internal_data_object['application'] != sdk_settings.api_key
+          @configuration_fetched_invoker.invoke_error(FetcherError::MISMATCH_APP_KEY)
+          @error_reporter.report('Failed to parse JSON configuration - ',
+                                 StandardError.new("Internal Data: #{internal_data_object['application']} SdkSettings: #{sdk_settings.api_key}"))
           return nil
         end
+
+        experiments = parse_experiments(internal_data_object)
+        target_groups = parse_target_groups(internal_data_object)
+
+        Configuration.new(experiments, target_groups, signature_date)
+      rescue StandardError => e
+        Logging.logger.error('Failed to parse configurations', e)
+        @configuration_fetched_invoker.invoke_error(FetcherError::UNKNOWN)
+        nil
       end
 
       def parse_experiments(data)
-        data['experiments'].map { |e| parse_experiment(e)}
+        data['experiments'].map { |e| parse_experiment(e) }
       end
 
       def parse_experiment(data)
@@ -69,12 +70,12 @@ module Rox
         name = data['name']
         id = data['_id']
         labels = data['labels'] || []
-        flags = data['featureFlags'].map {|f| f['name']}
+        flags = data['featureFlags'].map { |f| f['name'] }
         ExperimentModel.new(id, name, condition, is_archived, flags, labels)
       end
 
       def parse_target_groups(data)
-        data['targetGroups'].map { |g| parse_target_group(g)}
+        data['targetGroups'].map { |g| parse_target_group(g) }
       end
 
       def parse_target_group(data)