rox-rollout 5.0.3 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d30a63b44e459ce5e10a2b64ce89e3ee59b59ceea67969fda6a1f5b962e43e4
-  data.tar.gz: 2bc7318f4e7476830c09fc4c9cf3fbcb9b8e21c0ad6bfdc34ed4e74d321eb8a6
+  metadata.gz: 17c6afc3c1c54a584ecec20f9213d1bf3d90fa603e4d3f378fd4014fafe7fbbe
+  data.tar.gz: cc43890c658daf69fa6e3307ea00a78a6e6d16d94e7f1efc1f7aa8ede5466b2b
 SHA512:
-  metadata.gz: 2323d41086d92479bdafae351c9aabce8ad99ec4b870b30fb72ada7a8783bf211dbe6380fe80590d79fdd90d077e935d8961dea30436f3211c37cf2a52bb8da6
-  data.tar.gz: e3c8ff2bb1018d0d2db497fdbd307a4cac69edee35823f8b35adf47168bfa3339f3ef03401f864f4b918ee83c823e423aa472b44da67ca918f78fcdee02eca53
+  metadata.gz: 715c0071fb927d9f8947e47135e1c60036a19ac88ead19d2d8c482821291e04acb4c0adc57027b5e7a6ec305718c68ef64ffe2a5238835045855daf48d1a3075
+  data.tar.gz: 2c56942cdf66b5a809970fa9ebabaa20b09e0fedf4a42f824234af9618eab0dd41be7b3c557fe3c597fa3175b35b29440cd74a4f8261d0ef0ffa91d1af651aee

data/.gitignore

@@ -1,3 +1,4 @@
+/.idea/
 /.bundle/
 /.yardoc
 /_yardoc/

data/e2e/rox_e2e_test.rb

@@ -1,6 +1,7 @@
 require 'minitest/autorun'
 require 'rox/server/rox_options'
 require 'rox/server/rox_server'
+require 'rox/server/logging/server_logger'
 require_relative 'container'
 require_relative 'custom_props'
 require_relative 'test_vars'
@@ -23,30 +24,58 @@ module E2E
   class RoxE2ETest < Minitest::Test
     ENV['ROLLOUT_MODE'] = 'QA'
 
-    configuration_fetched_handler = proc do |e|
-      if !e.nil? && e.fetcher_status == Rox::Core::FetcherStatus::APPLIED_FROM_NETWORK
-        TestVars.configuration_fetched_count += 1
+    @@setupComplete = false
+    @@testsRun = 0
+
+    def setup
+      @@testsRun += 1
+      if !@@setupComplete
+
+        configuration_fetched_handler = proc do |e|
+          if !e.nil? && e.fetcher_status == Rox::Core::FetcherStatus::APPLIED_FROM_NETWORK
+            TestVars.configuration_fetched_count += 1
+          end
+        end
+
+        impression_handler = proc do |e|
+          puts "targeting: #{e.reporting_value.targeting}"
+          if e.reporting_value.targeting
+            puts "#{Time.now}: flag #{e.reporting_value.name} value is #{e.reporting_value.value}"
+          else
+            puts "#{Time.now}: flag #{e.reporting_value.name} has no conditions, or targeting is off. default value #{!!e.reporting_value.value == e.reporting_value.value ? (e.reporting_value.value ? 'true' : 'false') : e.reporting_value.value} was used"
+          end
+          if !e.nil? && !e.reporting_value.nil? && (e.reporting_value.name == 'flag_for_impression')
+            TestVars.is_impression_raised = true
+            TestVars.impression_raised_times += 1
+          end
+          TestVars.impression_returned_args = e
+        end
+
+        option = Rox::Server::RoxOptions.new(
+          configuration_fetched_handler: configuration_fetched_handler,
+          impression_handler: impression_handler,
+          dev_mode_key: '67e39e708444aa953414e444',
+          logger: Rox::Server::ServerLogger.new
+        )
+
+        @@container = Container.new
+        Rox::Server::RoxServer.register(@@container)
+        CustomProps.create_custom_props
+        Rox::Server::RoxServer.setup('5b82864ebc3aec37aff1fdd5', option).join
+        @@setupComplete = true
       end
     end
 
-    impression_handler = proc do |e|
-      if !e.nil? && !e.reporting_value.nil? && (e.reporting_value.name == 'flag_for_impression')
-        TestVars.is_impression_raised = true
+    def teardown
+      if @@testsRun == RoxE2ETest.runnable_methods.length
+        Rox::Server::RoxServer.shutdown
       end
-      TestVars.impression_returned_args = e
     end
 
-    option = Rox::Server::RoxOptions.new(
-      configuration_fetched_handler: configuration_fetched_handler,
-      impression_handler: impression_handler,
-      dev_mode_key: '67e39e708444aa953414e444',
-      logger: Logger.new
-    )
-
-    @@container = Container.new
-    Rox::Server::RoxServer.register(@@container)
-    CustomProps.create_custom_props
-    Rox::Server::RoxServer.setup('5b82864ebc3aec37aff1fdd5', option).join
+    def before_setup
+      TestVars.is_impression_raised = false
+      TestVars.impression_raised_times = 0
+    end
 
     def test_simple_flag
       assert_equal true, @@container.simple_flag.enabled?
@@ -135,6 +164,22 @@ module E2E
       assert_equal 'val', TestVars.impression_returned_args.context['var']
     end
 
+    def test_static_flag_impression_raised_once
+      assert_equal false, TestVars.is_impression_raised
+      assert_equal 0, TestVars.impression_raised_times
+      @@container.flag_for_impression.enabled?
+      assert_equal true, TestVars.is_impression_raised
+      assert_equal 1, TestVars.impression_raised_times
+    end
+
+    def test_dynamic_flag_impression_raised_once
+      assert_equal false, TestVars.is_impression_raised
+      assert_equal 0, TestVars.impression_raised_times
+      Rox::Server::RoxServer::dynamic_api.enabled?('flag_for_impression', true)
+      assert_equal true, TestVars.is_impression_raised
+      assert_equal 1, TestVars.impression_raised_times
+    end
+
     def test_flag_dependency
       TestVars.is_prop_for_target_group_for_dependency = true
       assert_equal true, @@container.flag_for_dependency.enabled?

data/e2e/test_vars.rb

@@ -2,7 +2,7 @@ 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, :target_group1, :target_group2, :is_impression_raised, :is_prop_for_target_group_for_dependency, :configuration_fetched_count, :impression_returned_args
+                    :is_computed_float_prop_called, :is_computed_semver_prop_called, :target_group1, :target_group2, :is_impression_raised, :impression_raised_times, :is_prop_for_target_group_for_dependency, :configuration_fetched_count, :impression_returned_args
     end
 
     @is_computed_boolean_prop_called = false
@@ -13,6 +13,7 @@ module E2E
     @target_group1 = false
     @target_group2 = false
     @is_impression_raised = false
+    @impression_raised_times = 0
     @is_prop_for_target_group_for_dependency = false
 
     @configuration_fetched_count = 0

data/e2e-server/.gitignore

@@ -0,0 +1 @@
+*.out

data/example/local.rb

@@ -4,8 +4,8 @@ require 'rox/server/rox_server'
 require 'rox/server/rox_options'
 
 API_HOST = 'http://localhost:8557'.freeze
-APP_KEY = '611e70975d05440313ccda68'.freeze
-#DEV_MODE_SECRET = 'e56cda16749d8d0a9b91d34c'.freeze
+APP_KEY = '600571e330819d4842999e4f'.freeze
+DEV_MODE_SECRET = 'e56cda16749d8d0a9b91d34c'.freeze
 
 class Flags
   attr_accessor :boolean_flag, :string_flag, :int_flag, :double_flag
@@ -23,11 +23,11 @@ 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
+  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)

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

@@ -0,0 +1,51 @@
+require 'rox/core/analytics/defaults'
+
+module Rox
+  module Core
+    class Analytics
+      class BackoffPolicy
+        include Rox::Core::Analytics::Defaults::BackoffPolicy
+
+        # @param [Hash] opts
+        # @option opts [Numeric] :min_timeout_ms The minimum backoff timeout
+        # @option opts [Numeric] :max_timeout_ms The maximum backoff timeout
+        # @option opts [Numeric] :multiplier The value to multiply the current
+        #   interval with for each retry attempt
+        # @option opts [Numeric] :randomization_factor The randomization factor
+        #   to use to create a range around the retry interval
+        def initialize(opts = {})
+          @min_timeout_ms = opts[:min_timeout_ms] || MIN_TIMEOUT_MS
+          @max_timeout_ms = opts[:max_timeout_ms] || MAX_TIMEOUT_MS
+          @multiplier = opts[:multiplier] || MULTIPLIER
+          @randomization_factor = opts[:randomization_factor] || RANDOMIZATION_FACTOR
+
+          @attempts = 0
+        end
+
+        # @return [Numeric] the next backoff interval, in milliseconds.
+        def next_interval
+          interval = @min_timeout_ms * (@multiplier ** @attempts)
+          interval = add_jitter(interval, @randomization_factor)
+
+          @attempts += 1
+
+          [interval, @max_timeout_ms].min
+        end
+
+        private
+
+        def add_jitter(base, randomization_factor)
+          random_number = rand
+          max_deviation = base * randomization_factor
+          deviation = random_number * max_deviation
+
+          if random_number < 0.5
+            base - deviation
+          else
+            base + deviation
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+require 'thread'
+require 'time'
+require 'uri'
+
+require 'rox/core/analytics/defaults'
+require 'rox/core/analytics/logging'
+require 'rox/core/analytics/utils'
+require 'rox/core/analytics/worker'
+
+module Rox
+  module Core
+    class Analytics
+      class Client
+        include Rox::Core::Analytics::Utils
+        include Rox::Core::Analytics::Logging
+
+        # @param [Rox::Core::DeviceProperties] device_properties
+        def initialize(device_properties)
+          @queue = Queue.new
+          @max_queue_size = Defaults::Queue::MAX_SIZE
+          @worker_mutex = Mutex.new
+          @worker = Worker.new(@queue, device_properties)
+          @worker_thread = nil
+
+          at_exit { @worker_thread && @worker_thread[:should_exit] = true }
+        end
+
+        # Synchronously waits until the worker has flushed the queue.
+        #
+        # Use only for scripts which are not long-running, and will specifically
+        # exit
+        def flush
+          while !@queue.empty? || @worker.is_requesting?
+            ensure_worker_running
+            sleep(0.1)
+          end
+        end
+
+        # @!macro common_attrs
+        #   @option attrs [String] :anonymous_id ID for a user when you don't know
+        #     who they are yet. (optional but you must provide either an
+        #     `anonymous_id` or `user_id`)
+        #   @option attrs [Hash] :context ({})
+        #   @option attrs [Hash] :integrations What integrations this event
+        #     goes to (optional)
+        #   @option attrs [String] :message_id ID that uniquely
+        #     identifies a message across the API. (optional)
+        #   @option attrs [Time] :timestamp When the event occurred (optional)
+        #   @option attrs [String] :user_id The ID for this user in your database
+        #     (optional but you must provide either an `anonymous_id` or `user_id`)
+        #   @option attrs [Hash] :options Options such as user traits (optional)
+
+        # Tracks an event
+        #
+        # @see https://segment.com/docs/sources/server/ruby/#track
+        #
+        # @param [Hash] attrs
+        #
+        # @option attrs [String] :event Event name
+        # @option attrs [Hash] :properties Event properties (optional)
+        # @macro common_attrs
+        def track(attrs)
+          symbolize_keys! attrs
+          enqueue(attrs)
+        end
+
+        # Identifies a user
+        #
+        # @see https://segment.com/docs/sources/server/ruby/#identify
+        #
+        # @param [Hash] attrs
+        #
+        # @option attrs [Hash] :traits User traits (optional)
+        # @macro common_attrs
+        def identify(attrs)
+          symbolize_keys! attrs
+          enqueue(FieldParser.parse_for_identify(attrs))
+        end
+
+        # Aliases a user from one id to another
+        #
+        # @see https://segment.com/docs/sources/server/ruby/#alias
+        #
+        # @param [Hash] attrs
+        #
+        # @option attrs [String] :previous_id The ID to alias from
+        # @macro common_attrs
+        def alias(attrs)
+          symbolize_keys! attrs
+          enqueue(FieldParser.parse_for_alias(attrs))
+        end
+
+        # Associates a user identity with a group.
+        #
+        # @see https://segment.com/docs/sources/server/ruby/#group
+        #
+        # @param [Hash] attrs
+        #
+        # @option attrs [String] :group_id The ID of the group
+        # @option attrs [Hash] :traits User traits (optional)
+        # @macro common_attrs
+        def group(attrs)
+          symbolize_keys! attrs
+          enqueue(FieldParser.parse_for_group(attrs))
+        end
+
+        # Records a page view
+        #
+        # @see https://segment.com/docs/sources/server/ruby/#page
+        #
+        # @param [Hash] attrs
+        #
+        # @option attrs [String] :name Name of the page
+        # @option attrs [Hash] :properties Page properties (optional)
+        # @macro common_attrs
+        def page(attrs)
+          symbolize_keys! attrs
+          enqueue(FieldParser.parse_for_page(attrs))
+        end
+
+        # Records a screen view (for a mobile app)
+        #
+        # @param [Hash] attrs
+        #
+        # @option attrs [String] :name Name of the screen
+        # @option attrs [Hash] :properties Screen properties (optional)
+        # @option attrs [String] :category The screen category (optional)
+        # @macro common_attrs
+        def screen(attrs)
+          symbolize_keys! attrs
+          enqueue(FieldParser.parse_for_screen(attrs))
+        end
+
+        # @return [Fixnum] number of messages in the queue
+        def queued_messages
+          @queue.length
+        end
+
+        def test_queue
+          unless @test
+            raise 'Test queue only available when setting :test to true.'
+          end
+
+          @test_queue ||= TestQueue.new
+        end
+
+        private
+
+        # private: Enqueues the action.
+        #
+        # returns Boolean of whether the item was added to the queue.
+        def enqueue(action)
+
+          if @test
+            test_queue << action
+            return true
+          end
+
+          while @queue.length >= @max_queue_size
+            # remove the oldest impression,
+            # and then add the new one (otherwise it just rejects the newer one)
+            @queue.pop
+          end
+
+          @queue << action
+          ensure_worker_running
+
+          true
+        end
+
+        def ensure_worker_running
+          return if worker_running?
+          @worker_mutex.synchronize do
+            return if worker_running?
+            @worker_thread = Thread.new do
+              @worker.run
+            end
+          end
+        end
+
+        def worker_running?
+          @worker_thread && @worker_thread.alive?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Rox
+  module Core
+    class Analytics
+      module Defaults
+        module Request
+          RETRIES = 10
+        end
+
+        module Queue
+          MAX_SIZE = 10000
+        end
+
+        module Message
+          MAX_BYTES = 32768 # 32Kb
+        end
+
+        module MessageBatch
+          MAX_BYTES = 512_000 # 500Kb
+          MAX_SIZE = 100
+        end
+
+        module BackoffPolicy
+          MIN_TIMEOUT_MS = 100
+          MAX_TIMEOUT_MS = 10000
+          MULTIPLIER = 1.5
+          RANDOMIZATION_FACTOR = 0.5
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'logger'
+
+module Rox
+  module Core
+    class Analytics
+      # Wraps an existing logger and adds a prefix to all messages
+      class PrefixedLogger
+        def initialize(logger, prefix)
+          @logger = logger
+          @prefix = prefix
+        end
+
+        def debug(msg)
+          @logger.debug("#{@prefix} #{msg}")
+        end
+
+        def info(msg)
+          @logger.info("#{@prefix} #{msg}")
+        end
+
+        def warn(msg)
+          @logger.warn("#{@prefix} #{msg}")
+        end
+
+        def error(msg)
+          @logger.error("#{@prefix} #{msg}")
+        end
+      end
+
+      module Logging
+        class << self
+          def logger
+            return @logger if @logger
+
+            base_logger = if defined?(Rails)
+                            Rails.logger
+                          else
+                            logger = Logger.new STDOUT
+                            logger.progname = 'Rox::Core::Analytics'
+                            logger
+                          end
+            @logger = PrefixedLogger.new(base_logger, '[analytics-ruby]')
+          end
+
+          attr_writer :logger
+        end
+
+        def self.included(base)
+          class << base
+            def logger
+              Logging.logger
+            end
+          end
+        end
+
+        def logger
+          Logging.logger
+        end
+      end
+    end
+  end
+end

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,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/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)
@@ -71,9 +73,13 @@ module Rox
         # TODO: Analytics.Analytics.Initialize(deviceProperties.RolloutKey, deviceProperties)
         @internal_flags = InternalFlags.new(@experiment_repository, @parser, @rox_options)
 
+        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,
-                                                    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)
 
@@ -138,9 +144,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 +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/impression/impression_invoker.rb

@@ -18,7 +18,6 @@ module Rox
         @mutex = Mutex.new
       end
 
-      # 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')
@@ -30,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
 
@@ -40,7 +39,6 @@ module Rox
                                       flag: reporting_value.name,
                                       value: reporting_value.value,
                                       distinctId: distinct_id,
-                                      experimentVersion: '0',
                                       type: 'IMPRESSION',
                                       time: event_time
                                     })
@@ -49,9 +47,9 @@ module Rox
           Logging.logger.error('Failed to send analytics', ex)
         end
       end
-      
+
       def invoke(reporting_value, stickiness_property, context)
-        #call_analytics_gateway
+        call_analytics_gateway(reporting_value, stickiness_property, context)
         raise_impression_event(ImpressionArgs.new(reporting_value, context))
       end
 

data/lib/rox/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rox-rollout
 version: !ruby/object:Gem::Version
-  version: 5.0.3
+  version: 5.1.0
 platform: ruby
 authors:
 - CloudBees
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-04 00:00:00.000000000 Z
+date: 2022-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-eventsource
@@ -126,6 +126,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- e2e-server/.gitignore
 - e2e-server/run_server.sh
 - e2e-server/server.rb
 - e2e/container.rb
@@ -134,6 +135,16 @@ files:
 - e2e/test_vars.rb
 - example/local.rb
 - lib/rox.rb
+- lib/rox/core/analytics/backoff_policy.rb
+- lib/rox/core/analytics/client.rb
+- lib/rox/core/analytics/defaults.rb
+- lib/rox/core/analytics/logging.rb
+- lib/rox/core/analytics/message_batch.rb
+- lib/rox/core/analytics/response.rb
+- lib/rox/core/analytics/test_queue.rb
+- lib/rox/core/analytics/transport.rb
+- lib/rox/core/analytics/utils.rb
+- lib/rox/core/analytics/worker.rb
 - lib/rox/core/client/buid.rb
 - lib/rox/core/client/device_properties.rb
 - lib/rox/core/client/dynamic_api.rb