rox-rollout 5.0.3 → 5.1.1

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

@@ -0,0 +1,74 @@
+require 'forwardable'
+require 'rox/core/analytics/logging'
+
+module Rox
+  module Core
+    class Analytics
+      # A batch of `Message`s to be sent to the API
+      class MessageBatch
+        class JSONGenerationError < StandardError; end
+
+        extend Forwardable
+        include Rox::Core::Analytics::Logging
+        include Rox::Core::Analytics::Defaults::MessageBatch
+
+        def initialize(max_message_count)
+          @messages = []
+          @max_message_count = max_message_count
+          @json_size = 0
+        end
+
+        def <<(message)
+          begin
+            message_json = message.to_json
+          rescue StandardError => e
+            raise JSONGenerationError, "Serialization error: #{e}"
+          end
+
+          message_json_size = message_json.bytesize
+          if message_too_big?(message_json_size)
+            logger.error('a message exceeded the maximum allowed size')
+          else
+            @messages << message
+            @json_size += message_json_size + 1 # One byte for the comma
+          end
+        end
+
+        def full?
+          item_count_exhausted? || size_exhausted?
+        end
+
+        def clear
+          @messages.clear
+          @json_size = 0
+        end
+
+        def_delegators :@messages, :to_json
+        def_delegators :@messages, :empty?
+        def_delegators :@messages, :length
+
+        private
+
+        def item_count_exhausted?
+          @messages.length >= @max_message_count
+        end
+
+        def message_too_big?(message_json_size)
+          message_json_size > Defaults::Message::MAX_BYTES
+        end
+
+        # We consider the max size here as just enough to leave room for one more
+        # message of the largest size possible. This is a shortcut that allows us
+        # to use a native Ruby `Queue` that doesn't allow peeking. The tradeoff
+        # here is that we might fit in less messages than possible into a batch.
+        #
+        # The alternative is to use our own `Queue` implementation that allows
+        # peeking, and to consider the next message size when calculating whether
+        # the message can be accomodated in this batch.
+        def size_exhausted?
+          @json_size >= (MAX_BYTES - Defaults::Message::MAX_BYTES)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Rox
+  module Core
+    class Analytics
+      class Response
+        attr_reader :status, :error
+
+        # public: Simple class to wrap responses from the API
+        #
+        #
+        def initialize(status = 200, error = nil)
+          @status = status
+          @error = error
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Rox
+  module Core
+    class Analytics
+      class TestQueue
+        attr_reader :messages
+
+        def initialize
+          reset!
+        end
+
+        def [](key)
+          all[key]
+        end
+
+        def count
+          all.count
+        end
+
+        def <<(message)
+          all << message
+          send(message[:type]) << message
+        end
+
+        def alias
+          messages[:alias] ||= []
+        end
+
+        def all
+          messages[:all] ||= []
+        end
+
+        def group
+          messages[:group] ||= []
+        end
+
+        def identify
+          messages[:identify] ||= []
+        end
+
+        def page
+          messages[:page] ||= []
+        end
+
+        def screen
+          messages[:screen] ||= []
+        end
+
+        def track
+          messages[:track] ||= []
+        end
+
+        def reset!
+          @messages = {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+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)
+          logger.debug("Using Analytics url #{uri}")
+          @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/consts/environment.rb

@@ -1,77 +1,85 @@
 module Rox
   module Core
     module Environment
+      def self.reset(rox_options = nil)
+        @roxy_internal_path = 'device/request_configuration'
+        if !rox_options&.network_configurations_options.nil?
+            @cdn_path = rox_options&.network_configurations_options&.get_config_cloud_endpoint
+            @api_path = rox_options&.network_configurations_options&.get_config_api_endpoint
+            @state_cdn_path = rox_options&.network_configurations_options&.send_state_cloud_endpoint
+            @state_api_path = rox_options&.network_configurations_options&.send_state_api_endpoint
+            @analytics_path = rox_options&.network_configurations_options&.analytics_endpoint
+            @notifications_path = rox_options&.network_configurations_options&.push_notification_endpoint
+        else
+          case ENV['ROLLOUT_MODE']
+          when 'QA'
+            setQA
+          when 'LOCAL'
+            setLOCAL
+          else
+            setDefault(rox_options)
+          end
+        end
+      end
+
       def self.roxy_internal_path
-        'device/request_configuration'
+        @roxy_internal_path
       end
 
       def self.cdn_path
-        case ENV['ROLLOUT_MODE']
-        when 'QA'
-          'https://qa-conf.rollout.io'
-        when 'LOCAL'
-          'https://development-conf.rollout.io'
-        else
-          'https://conf.rollout.io'
-        end
+        @cdn_path
       end
 
-      def self.api_path(api_url = nil)
-        case ENV['ROLLOUT_MODE']
-        when 'QA'
-          'https://qa-api.rollout.io/device/get_configuration'
-        when 'LOCAL'
-          'http://127.0.0.1:8557/device/get_configuration'
-        else
-          api_url ||= 'https://x-api.rollout.io'
-          "#{api_url}/device/get_configuration"
-        end
+      def self.api_path
+        @api_path
       end
 
       def self.state_cdn_path
-        case ENV['ROLLOUT_MODE']
-        when 'QA'
-          'https://qa-statestore.rollout.io'
-        when 'LOCAL'
-          'https://development-statestore.rollout.io'
-        else
-          'https://statestore.rollout.io'
-        end
+        @state_cdn_path
       end
 
-      def self.state_api_path(api_url = nil)
-        case ENV['ROLLOUT_MODE']
-        when 'QA'
-          'https://qa-api.rollout.io/device/update_state_store'
-        when 'LOCAL'
-          'http://127.0.0.1:8557/device/update_state_store'
-        else
-          api_url ||= 'https://x-api.rollout.io'
-          "#{api_url}/device/update_state_store"
-        end
+      def self.state_api_path
+        @state_api_path
       end
 
-      def self.analytics_path(analytics_url = 'https://analytic.rollout.io')
-        case ENV['ROLLOUT_MODE']
-        when 'QA'
-          'https://qaanalytic.rollout.io'
-        when 'LOCAL'
-          'http://127.0.0.1:8787'
-        else
-          analytics_url
-        end
+      def self.analytics_path
+        @analytics_path
       end
 
       def self.notifications_path
-        case ENV['ROLLOUT_MODE']
-        when 'QA'
-          'https://qax-push.rollout.io/sse'
-        when 'LOCAL'
-          'http://127.0.0.1:8887/sse'
-        else
-          'https://push.rollout.io/sse'
-        end
+        @notifications_path
+      end
+
+      private
+      def self.setQA()
+        @cdn_path = 'https://qa-conf.rollout.io'
+        @api_path = 'https://qa-api.rollout.io/device/get_configuration'
+        @state_cdn_path = 'https://qa-statestore.rollout.io'
+        @state_api_path = 'https://qa-api.rollout.io/device/update_state_store'
+        @analytics_path = 'https://qaanalytic.rollout.io'
+        @notifications_path = 'https://qax-push.rollout.io/sse'
+      end
+
+      def self.setLOCAL()
+        @cdn_path = 'https://development-conf.rollout.io'
+        @api_path = 'http://127.0.0.1:8557/device/get_configuration'
+        @state_cdn_path = 'https://development-statestore.rollout.io'
+        @state_api_path = 'http://127.0.0.1:8557/device/update_state_store'
+        @analytics_path = 'http://127.0.0.1:8787'
+        @notifications_path = 'http://127.0.0.1:8887/sse'
+      end
+
+      def self.setDefault(rox_options)
+        @cdn_path = 'https://conf.rollout.io'
+        @state_cdn_path = 'https://statestore.rollout.io'
+        alternative_api_url = rox_options&.self_managed_options&.server_url || 'https://x-api.rollout.io'
+        @api_path = "#{alternative_api_url}/device/get_configuration"
+        @state_api_path = "#{alternative_api_url}/device/update_state_store"
+        @analytics_path = rox_options&.self_managed_options&.analytics_url ||'https://analytic.rollout.io'
+        @notifications_path = 'https://push.rollout.io/sse'
       end
     end
   end
 end
+
+Rox::Core::Environment.reset

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'
@@ -48,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)
@@ -57,6 +59,7 @@ module Rox
       def setup(sdk_settings, device_properties)
         @sdk_settings = sdk_settings
         @rox_options = device_properties.rox_options
+        Rox::Core::Environment.reset(@rox_options)
 
         experiments_extensions = ExperimentsExtensions.new(@parser, @target_group_repository, @flag_repository,
                                                            @experiment_repository)
@@ -68,12 +71,14 @@ module Rox
 
         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, @rox_options)
 
-        # TODO: impressionInvoker = new ImpressionInvoker(internalFlags, customPropertyRepository, deviceProperties, Analytics.Analytics.Client, roxyPath != null);
+        if roxy_path.nil?
+          @analytics_client = create_analytics_client(device_properties)
+        end
+
         @impression_invoker = ImpressionInvoker.new(@internal_flags, @custom_property_repository, device_properties,
-                                                    nil, !roxy_path.nil?, @user_unhandled_error_invoker)
+                                                    @analytics_client, !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)
 
@@ -103,14 +108,13 @@ module Rox
                                                                 @configuration_fetched_invoker)
         end
 
-        configuration_fetched_handler = nil
-        configuration_fetched_handler = @rox_options.configuration_fetched_handler unless @rox_options.nil?
-
         @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)
+        if !@rox_options.nil? && !@rox_options.configuration_fetched_handler.nil?
+          @configuration_fetched_invoker.register_fetched_handler(&@rox_options.configuration_fetched_handler)
+        end
 
         @thread = Thread.new do
           Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception)
@@ -138,9 +142,9 @@ module Rox
           @push_updates_listener = nil
         end
 
-        #return if @analytics_client.nil?
+        return if @analytics_client.nil?
 
-        #@analytics_client.flush
+        @analytics_client.flush
       end
 
       def fetch
@@ -224,6 +228,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 = Rox::Server::NormalizeFlagType.normalize_float(internal_value(context, false, Float))
+        send_impressions(return_value, context)
+        return_value
       end
     end
   end