rox-rollout 5.0.0 → 5.1.0

data/lib/rox/core/analytics/transport.rb

@@ -0,0 +1,143 @@
+require 'rox/core/analytics/defaults'
+require 'rox/core/analytics/utils'
+require 'rox/core/analytics/response'
+require 'rox/core/analytics/logging'
+require 'rox/core/analytics/backoff_policy'
+require 'net/http'
+require 'net/https'
+require 'json'
+
+module Rox
+  module Core
+    class Analytics
+      class Transport
+        include Rox::Core::Analytics::Defaults::Request
+        include Rox::Core::Analytics::Utils
+        include Rox::Core::Analytics::Logging
+
+        def initialize(device_properties)
+          @device_properties = device_properties
+          uri = URI.parse(Rox::Core::Environment.analytics_path)
+          @headers = {
+            'Accept' => 'application/json',
+            'Content-Type' => 'application/json',
+            'User-Agent' => "ruby/#{device_properties.lib_version}"
+          }
+          @path = uri.path + '/impression/' + device_properties.rollout_key
+          @retries = RETRIES
+          @backoff_policy = Rox::Core::Analytics::BackoffPolicy.new
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == 'https'
+          http.read_timeout = 8
+          http.open_timeout = 4
+
+          @http = http
+        end
+
+        # Sends a batch of messages to the API
+        #
+        # @return [Response] API response
+        def send(batch)
+          logger.debug("Sending request for #{batch.length} items")
+
+          last_response, exception = retry_with_backoff(@retries) do
+            status_code, body = send_request(batch)
+            should_retry = should_retry_request?(status_code, body)
+            logger.debug("Response status code: #{status_code}")
+            logger.debug("Response error: #{body}") if status_code != 200
+
+            [Response.new(status_code, body), should_retry]
+          end
+
+          if exception
+            logger.error(exception.message)
+            exception.backtrace.each { |line| logger.error(line) }
+            Response.new(-1, exception.to_s)
+          else
+            last_response
+          end
+        end
+
+        # Closes a persistent connection if it exists
+        def shutdown
+          @http.finish if @http.started?
+        end
+
+        private
+
+        def should_retry_request?(status_code, body)
+          if status_code >= 500
+            true # Server error
+          elsif status_code == 429
+            true # Rate limited
+          elsif status_code >= 400
+            logger.error(body)
+            false # Client error. Do not retry, but log
+          else
+            false
+          end
+        end
+
+        # Takes a block that returns [result, should_retry].
+        #
+        # Retries upto `retries_remaining` times, if `should_retry` is false or
+        # an exception is raised. `@backoff_policy` is used to determine the
+        # duration to sleep between attempts
+        #
+        # Returns [last_result, raised_exception]
+        def retry_with_backoff(retries_remaining, &block)
+          result, caught_exception = nil
+          should_retry = false
+
+          begin
+            result, should_retry = yield
+            return [result, nil] unless should_retry
+          rescue StandardError => e
+            should_retry = true
+            caught_exception = e
+          end
+
+          if should_retry && (retries_remaining > 1)
+            logger.debug("Retrying request, #{retries_remaining} retries left")
+            sleep(@backoff_policy.next_interval.to_f / 1000)
+            retry_with_backoff(retries_remaining - 1, &block)
+          else
+            [result, caught_exception]
+          end
+        end
+
+        # Sends a request for the batch, returns [status_code, body]
+        def send_request(batch)
+          payload = JSON.generate(
+            :analyticsVersion => '1.0.0',
+            :sdkVersion => @device_properties.lib_version,
+            :time => DateTime.now.strftime('%Q').to_i,
+            :platform => @device_properties.all_properties[PropertyType::PLATFORM.name],
+            :rolloutKey => @device_properties.rollout_key,
+            :events => batch
+          )
+          request = Net::HTTP::Post.new(@path, @headers)
+
+          if self.class.stub
+            logger.debug "stubbed request to #{@path}: #{JSON.generate(batch)}"
+
+            [200, '{}']
+          else
+            @http.start unless @http.started? # Maintain a persistent connection
+            response = @http.request(request, payload)
+            [response.code.to_i, response.body]
+          end
+        end
+
+        class << self
+          attr_writer :stub
+
+          def stub
+            @stub || ENV['STUB']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rox/core/analytics/utils.rb

@@ -0,0 +1,89 @@
+require 'securerandom'
+
+module Rox
+  module Core
+    class Analytics
+      module Utils
+        extend self
+
+        # public: Return a new hash with keys converted from strings to symbols
+        #
+        def symbolize_keys(hash)
+          hash.each_with_object({}) do |(k, v), memo|
+            memo[k.to_sym] = v
+          end
+        end
+
+        # public: Convert hash keys from strings to symbols in place
+        #
+        def symbolize_keys!(hash)
+          hash.replace symbolize_keys hash
+        end
+
+        # public: Return a new hash with keys as strings
+        #
+        def stringify_keys(hash)
+          hash.each_with_object({}) do |(k, v), memo|
+            memo[k.to_s] = v
+          end
+        end
+
+        # public: Returns a new hash with all the date values in the into iso8601
+        #         strings
+        #
+        def isoify_dates(hash)
+          hash.each_with_object({}) do |(k, v), memo|
+            memo[k] = datetime_in_iso8601(v)
+          end
+        end
+
+        # public: Converts all the date values in the into iso8601 strings in place
+        #
+        def isoify_dates!(hash)
+          hash.replace isoify_dates hash
+        end
+
+        # public: Returns a uid string
+        #
+        def uid
+          arr = SecureRandom.random_bytes(16).unpack('NnnnnN')
+          arr[2] = (arr[2] & 0x0fff) | 0x4000
+          arr[3] = (arr[3] & 0x3fff) | 0x8000
+          '%08x-%04x-%04x-%04x-%04x%08x' % arr
+        end
+
+        def datetime_in_iso8601(datetime)
+          case datetime
+          when Time
+            time_in_iso8601 datetime
+          when DateTime
+            time_in_iso8601 datetime.to_time
+          when Date
+            date_in_iso8601 datetime
+          else
+            datetime
+          end
+        end
+
+        def time_in_iso8601(time)
+          "#{time.strftime('%Y-%m-%dT%H:%M:%S.%6N')}#{formatted_offset(time, true, 'Z')}"
+        end
+
+        def date_in_iso8601(date)
+          date.strftime('%F')
+        end
+
+        def formatted_offset(time, colon = true, alternate_utc_string = nil)
+          time.utc? && alternate_utc_string || seconds_to_utc_offset(time.utc_offset, colon)
+        end
+
+        def seconds_to_utc_offset(seconds, colon = true)
+          (colon ? UTC_OFFSET_WITH_COLON : UTC_OFFSET_WITHOUT_COLON) % [(seconds < 0 ? '-' : '+'), (seconds.abs / 3600), ((seconds.abs % 3600) / 60)]
+        end
+
+        UTC_OFFSET_WITH_COLON = '%s%02d:%02d'
+        UTC_OFFSET_WITHOUT_COLON = UTC_OFFSET_WITH_COLON.sub(':', '')
+      end
+    end
+  end
+end

data/lib/rox/core/analytics/worker.rb

@@ -0,0 +1,67 @@
+require 'rox/core/analytics/defaults'
+require 'rox/core/analytics/message_batch'
+require 'rox/core/analytics/transport'
+require 'rox/core/analytics/utils'
+
+module Rox
+  module Core
+    class Analytics
+      class Worker
+        include Rox::Core::Analytics::Utils
+        include Rox::Core::Analytics::Defaults
+        include Rox::Core::Analytics::Logging
+
+        # public: Creates a new worker
+        #
+        # The worker continuously takes messages off the queue
+        # and makes requests to the segment.io api
+        #
+        # queue   - Queue synchronized between client and worker
+        # @param [Rox::Core::DeviceProperties] device_properties
+        #
+        def initialize(queue, device_properties)
+          @queue = queue
+          @device_properties = device_properties
+          @on_error = proc { |status, error| }
+          batch_size = Defaults::MessageBatch::MAX_SIZE
+          @batch = MessageBatch.new(batch_size)
+          @lock = Mutex.new
+          @transport = Transport.new(device_properties)
+        end
+
+        # public: Continuously runs the loop to check for new events
+        #
+        def run
+          until Thread.current[:should_exit]
+            return if @queue.empty?
+
+            @lock.synchronize do
+              consume_message_from_queue! until @batch.full? || @queue.empty?
+            end
+
+            res = @transport.send @batch
+            @on_error.call(res.status, res.error) unless res.status == 200
+
+            @lock.synchronize { @batch.clear }
+          end
+        ensure
+          @transport.shutdown
+        end
+
+        # public: Check whether we have outstanding requests.
+        #
+        def is_requesting?
+          @lock.synchronize { !@batch.empty? }
+        end
+
+        private
+
+        def consume_message_from_queue!
+          @batch << @queue.pop
+        rescue MessageBatch::JSONGenerationError => e
+          @on_error.call(-1, e.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require 'rox/core/configuration/configuration_fetched_args'
+require 'rox/core/error_handling/exception_trigger'
 
 module Rox
   module Core
@@ -6,6 +7,7 @@ module Rox
       def initialize(user_unhandled_error_invoker)
         @fetched_handlers = []
         @mutex = Mutex.new
+        @internal_handler = nil
         @user_unhandled_error_invoker = user_unhandled_error_invoker
       end
 
@@ -17,6 +19,10 @@ module Rox
         raise_fetched_event(Rox::Core::ConfigurationFetchedArgs.error(error_details))
       end
 
+      def register_start_stop_push(block)
+        @internal_handler = block
+      end
+
       def register_fetched_handler(&block)
         @mutex.synchronize do
           @fetched_handlers << block
@@ -24,6 +30,9 @@ module Rox
       end
 
       def raise_fetched_event(args)
+        unless @internal_handler.nil?
+          @internal_handler.call(args)
+        end
         handlers = []
         @mutex.synchronize do
           handlers = @fetched_handlers.clone
@@ -33,7 +42,7 @@ module Rox
           begin
             handler.call(args)
           rescue StandardError => e
-            user_unhandled_error_invoker.invoke(handler, Rox::Core::CONFIGURATION_FETCHED_HANDLER, e)
+            @user_unhandled_error_invoker.invoke(handler, ExceptionTrigger::CONFIGURATION_FETCHED_HANDLER, e)
           end
         end
       end

data/lib/rox/core/core.rb

@@ -1,3 +1,4 @@
+require 'rox/core/analytics/client'
 require 'rox/core/repositories/flag_repository'
 require 'rox/core/repositories/custom_property_repository'
 require 'rox/core/repositories/target_group_repository'
@@ -24,7 +25,6 @@ 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/analytics'
 require 'rox/core/error_handling/userspace_unhandled_error_invoker'
 
 module Rox
@@ -49,6 +49,7 @@ module Rox
         @last_configurations = nil
         @internal_flags = nil
         @push_updates_listener = nil
+        @analytics_client = nil
       end
 
       def userspace_unhandled_error_handler=(handler)
@@ -72,7 +73,10 @@ module Rox
         # TODO: Analytics.Analytics.Initialize(deviceProperties.RolloutKey, deviceProperties)
         @internal_flags = InternalFlags.new(@experiment_repository, @parser, @rox_options)
 
-        @analytics_client = Analytics.new(sdk_settings.api_key).client
+        if !@rox_options.self_managed? && roxy_path.nil?
+          @analytics_client = create_analytics_client(device_properties)
+        end
+
         # TODO: impressionInvoker = new ImpressionInvoker(internalFlags, customPropertyRepository, deviceProperties, Analytics.Analytics.Client, roxyPath != null);
         @impression_invoker = ImpressionInvoker.new(@internal_flags, @custom_property_repository, device_properties,
                                                     @analytics_client, !roxy_path.nil?, @user_unhandled_error_invoker)
@@ -108,7 +112,11 @@ module Rox
         configuration_fetched_handler = nil
         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 = Thread.new do
           Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception)
@@ -189,13 +197,6 @@ 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)
-        end
-      end
-
       def start_or_stop_push_updated_listener
         if @internal_flags.enabled?('rox.internal.pushUpdates')
           if @push_updates_listener.nil?
@@ -229,6 +230,12 @@ module Rox
           raise ArgumentError, 'Illegal Rollout api key'
         end
       end
+
+      private
+
+      def create_analytics_client(device_properties)
+        Rox::Core::Analytics::Client.new(device_properties)
+      end
     end
   end
 end

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

@@ -26,7 +26,9 @@ module Rox
 
       def value(context = nil)
         merged_context = MergedContext.new(@parser&.global_context, context)
-        internal_value(merged_context, false)
+        return_value = internal_value(merged_context, false)
+        send_impressions(return_value, merged_context)
+        return_value
       end
 
       def internal_enabled?(context, nil_instead_of_default = false)

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

@@ -4,7 +4,9 @@ module Rox
   module Core
     class RoxDouble < RoxString
       def value(context = nil)
-        internal_value(context, false, Float)
+        return_value = internal_value(context, false, Float)
+        send_impressions(return_value, context)
+        return_value
       end
     end
   end

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

@@ -4,7 +4,9 @@ module Rox
   module Core
     class RoxInt < RoxString
       def value(context = nil)
-        internal_value(context, false, Integer)
+        return_value = internal_value(context, false, Integer)
+        send_impressions(return_value, context)
+        return_value
       end
     end
   end

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

@@ -43,7 +43,9 @@ module Rox
       end
 
       def value(context = nil)
-        internal_value(context, false)
+        return_value = internal_value(context, false)
+        send_impressions(return_value, context)
+        return_value
       end
 
       def internal_value(context, nil_instead_of_default, evaluated_type = String)
@@ -59,7 +61,6 @@ module Rox
           end
         end
 
-        send_impressions(return_value, merged_context)
         return_value
       end
     end

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

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

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

@@ -18,7 +18,7 @@ module Rox
         @mutex = Mutex.new
       end
 
-      def invoke(reporting_value, stickiness_property, context)
+      def call_analytics_gateway(reporting_value, stickiness_property, context)
         begin
           analytics_enabled = @internal_flags.enabled?('rox.internal.analytics')
           if analytics_enabled && !@is_roxy
@@ -29,9 +29,9 @@ module Rox
               distinct_id = prop_value if prop_value.instance_of?(String)
             end
 
-            event_time = (Time.now.to_f * 1000.0).to_i
+            event_time = DateTime.now.strftime('%Q').to_i
             begin
-              event_time = ENV['rox.analytics.ms'].to_i
+              event_time = ENV['rox.analytics.ms'].to_i if ENV['rox.analytics.ms']
             rescue StandardError
             end
 
@@ -39,7 +39,6 @@ module Rox
                                       flag: reporting_value.name,
                                       value: reporting_value.value,
                                       distinctId: distinct_id,
-                                      experimentVersion: '0',
                                       type: 'IMPRESSION',
                                       time: event_time
                                     })
@@ -47,7 +46,10 @@ module Rox
         rescue StandardError => ex
           Logging.logger.error('Failed to send analytics', ex)
         end
+      end
 
+      def invoke(reporting_value, stickiness_property, context)
+        call_analytics_gateway(reporting_value, stickiness_property, context)
         raise_impression_event(ImpressionArgs.new(reporting_value, context))
       end
 
@@ -63,11 +65,13 @@ module Rox
           handlers = @impression_handlers.clone
         end
 
-        begin
-          handlers.each { |handler| handler.call(args) }
-        rescue StandardError => e
-          user_unhandled_error_invoker.invoke(handler, ExceptionTrigger::IMPRESSION_HANDLER, e)
-          Logging.logger.error('Impresssion handler exception', ex)
+        handlers.each do |handler|
+          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

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

@@ -83,9 +83,10 @@ module Rox
 
       def self.state_payload(seralized_flag_repository, serialized_custom_property_repository, device_properties, dev_mode_secret)
         values = {}
+        # be careful adding here properties, md5 signature uses all props
+        # to add more payload data, please change the md5_signature to use only the relevant properties (the current ones creating the payload)
         values[PropertyType::APP_KEY.name] = device_properties.all_properties[PropertyType::APP_KEY.name]
         values[PropertyType::PLATFORM.name] = device_properties.all_properties[PropertyType::PLATFORM.name]
-        values.merge!(device_properties.all_properties)
         values.merge!({ feature_flags: seralized_flag_repository })
         values.merge!({ custom_properties: serialized_custom_property_repository })
         values['devModeSecret'] = dev_mode_secret

data/lib/rox/core/properties/custom_property.rb

@@ -1,7 +1,7 @@
 module Rox
   module Core
     class CustomProperty
-      attr_accessor :name, :type
+      attr_accessor :name, :type, :block
 
       def initialize(name, type, value = nil, &block)
         @name = name

data/lib/rox/core/repositories/roxx/properties_extensions.rb

@@ -38,13 +38,13 @@ module Rox
       def get_value_from_dynamic_property_rule_handler(prop_name, context)
         @dynamic_property_rule_handler.call(prop_name, context)
       rescue StandardError => e
-        raise Rox::Core::UserspaceHandlerException, handler, ExceptionTrigger::DYNAMIC_PROPERTIES_RULE, e
+        raise Rox::Core::UserspaceHandlerException.new(@dynamic_property_rule_handler, ExceptionTrigger::DYNAMIC_PROPERTIES_RULE, e)
       end
 
       def get_value_from_property(property, context)
         property.value(context)
       rescue StandardError => e
-        raise Rox::Core::UserspaceHandlerException, handler, ExceptionTrigger::CUSTOM_PROPERTY_GENERATOR, e
+        raise Rox::Core::UserspaceHandlerException.new(property.block, ExceptionTrigger::CUSTOM_PROPERTY_GENERATOR, e)
       end
     end
   end

data/lib/rox/core/roxx/parser.rb

@@ -50,7 +50,7 @@ module Rox
 
           EvaluationResult.new(result)
         rescue Rox::Core::UserspaceHandlerException => e
-          @user_unhandled_error_invoker.invoke(e.exception_source, e.exception_trigger, e.exception)
+          @user_unhandled_error_invoker.invoke(e.exception_source, e.exception_trigger, e.original_exception)
           Logging.logger.warn("Roxx Exception: Failed evaluate expression, user unhandled expression: #{e}")
           EvaluationResult.new(nil)
         rescue StandardError => e

data/lib/rox/server/rox_server.rb

@@ -45,6 +45,10 @@ module Rox
           @core.register(rox_container)
         end
 
+        def register_with_namespace(namespace, rox_container)
+          @core.register_with_namespace(namespace, rox_container)
+        end
+
         def use_userspace_unhandled_error_handler(&handler)
           @core.userspace_unhandled_error_handler = handler
         end

data/lib/rox/version.rb

@@ -1,3 +1,3 @@
 module Rox
-  VERSION = '5.0.0'.freeze
+  VERSION = '5.1.0'.freeze
 end

data/rox.gemspec

@@ -23,10 +23,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.3'
 
   spec.add_runtime_dependency 'em-eventsource', '~> 0.3.2'
-  spec.add_runtime_dependency 'analytics-ruby', '~> 2.0.0'
 
-
-  spec.add_development_dependency 'bundler', '~> 2.2.3'
+  spec.add_development_dependency 'bundler', '~> 2.3.3'
   spec.add_development_dependency 'minitest', '~> 5.11'
   spec.add_development_dependency 'pry-byebug', '~> 3.7.0'
   spec.add_development_dependency 'rake', '~> 12.3'