rox-rollout 5.0.3 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d30a63b44e459ce5e10a2b64ce89e3ee59b59ceea67969fda6a1f5b962e43e4
-  data.tar.gz: 2bc7318f4e7476830c09fc4c9cf3fbcb9b8e21c0ad6bfdc34ed4e74d321eb8a6
+  metadata.gz: ae34336f9f49d2ba7a2f77003d3f537eb53bbf4cde40fff04846a4c71d9fe177
+  data.tar.gz: d168174f3d6b72a482b89868d950e4bd8c30c908c0df6d0c11d276aceb8c229d
 SHA512:
-  metadata.gz: 2323d41086d92479bdafae351c9aabce8ad99ec4b870b30fb72ada7a8783bf211dbe6380fe80590d79fdd90d077e935d8961dea30436f3211c37cf2a52bb8da6
-  data.tar.gz: e3c8ff2bb1018d0d2db497fdbd307a4cac69edee35823f8b35adf47168bfa3339f3ef03401f864f4b918ee83c823e423aa472b44da67ca918f78fcdee02eca53
+  metadata.gz: be4f8985f0289f5becb88a46f13578d83982ad0b5d471c3241dd8127493cdca9d1479eae63bc87e6c13c81092a37ae63e48bedaa40b806020a497a091e0996f2
+  data.tar.gz: f5c134a9692176e0495bbb3805799a439c14a08b5c160a61148c4affdb7e39f2699d1586e7f853e6bdd7fc43103bd9a66d17fc61b93a9b228627a92a7a6217ba

data/.github/workflows/e2e_tests.yaml

@@ -0,0 +1,52 @@
+name: E2E tests
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          path: rox-ruby
+      - name: Checkout e2e tests
+        uses: actions/checkout@v3
+        with:
+          repository: rollout/sdk-end-2-end-tests
+          ref: master
+          token: ${{ secrets.E2E_PAT }}
+          path: sdk-end-2-end-tests
+      - name: link driver
+        working-directory: ./sdk-end-2-end-tests/drivers
+        run: ln -s $GITHUB_WORKSPACE/rox-ruby/e2e-server ruby
+      - name: build e2e node driver
+        working-directory: ./sdk-end-2-end-tests/drivers/nodejs
+        run: |
+          yarn install --frozen-lockfile
+      - name: build and run e2e
+        working-directory: ./sdk-end-2-end-tests
+        run: |
+          yarn install --frozen-lockfile
+          QA_E2E_BEARER=$QA_E2E_BEARER API_HOST=https://api.test.rollout.io CD_API_ENDPOINT=https://api.test.rollout.io/device/get_configuration CD_S3_ENDPOINT=https://rox-conf.test.rollout.io/ SS_API_ENDPOINT=https://api.test.rollout.io/device/update_state_store/ SS_S3_ENDPOINT=https://rox-state.test.rollout.io/ CLIENT_DATA_CACHE_KEY=client_data ANALYTICS_ENDPOINT=https://analytic.test.rollout.io/ NOTIFICATIONS_ENDPOINT=https://push.test.rollout.io/sse SDK_LANG=ruby NODE_ENV=container yarn test:env
+        env:
+          QA_E2E_BEARER: ${{ secrets.QA_E2E_BEARER }}
+      - name: Show e2e server driver logs
+        if: ${{ always() }}
+        run: cat ./sdk-end-2-end-tests/drivers/ruby/log_1234.out || echo "no log file"
+      - name: Show e2e server sync driver logs
+        if: ${{ always() }}
+        run: cat ./sdk-end-2-end-tests/drivers/nodejs/log_1233.out || echo "no log file"
+      - name: Show e2e server init ClientData driver logs
+        if: ${{ always() }}
+        run: cat ./sdk-end-2-end-tests/drivers/ruby/log_2234.out || echo "no log file"
+      - name: Show e2e server init ClientData sync driver logs
+        if: ${{ always() }}
+        run: cat ./sdk-end-2-end-tests/drivers/nodejs/log_2233.out || echo "no log file"

data/.github/workflows/{ruby.yml → unit_tests.yaml}

@@ -1,4 +1,4 @@
-name: Ruby
+name: Unit Tests
 
 on: [push]
 
@@ -8,14 +8,13 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        ruby: [2.4, 2.5, 2.6, 2.7, '3.0', 3.1]
+        ruby: [2.6, 2.7, '3.0', 3.1, 3.2]
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
-        bundler: 2.3.3
+        bundler: 2.4.6
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically
     - run: bundle exec rake test
-    - run: bundle exec rake e2e

data/.gitignore

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

data/Rakefile

@@ -8,12 +8,6 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-Rake::TestTask.new(:e2e) do |t|
-  t.libs << 'lib'
-  t.libs << 'e2e'
-  t.test_files = FileList['e2e/**/*_test.rb']
-end
-
 RuboCop::RakeTask.new(:lint)
 
 task default: :test

data/e2e-server/.gitignore

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

data/e2e-server/run_server.sh

@@ -2,9 +2,13 @@
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 cd -P "$DIR"
 DIR=`pwd`
-gem install sinatra
-gem install sinatra-contrib
-gem install json
+
+# --conservative will save us some time (hopefully gem install just once)
+gem install sinatra --conservative
+gem install sinatra-contrib --conservative
+gem install json --conservative
+gem install em-eventsource --conservative
+
 nohup ruby ./server.rb $1 1>"$DIR"/log_"$1".out 2>&1 &
 while true ; do
   curl -p http://127.0.0.1:$1/status-check && exit 

data/e2e-server/server.rb

@@ -1,18 +1,20 @@
+# comment the following line and install a rox-ruby gem to test a released version
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+
 require 'sinatra'
 require 'sinatra/namespace'
 require 'json'
 require 'rox/server/flags/rox_flag'
 require 'rox/server/rox_server'
 require 'rox/server/rox_options'
+require 'rox/server/network_configurations_options'
 
 class Container
-  attr_accessor :first_flag
-  attr_reader :bool_default_false, :bool_default_true
+  attr_reader :boolDefaultFalse, :boolDefaultTrue
 
   def initialize
-    @bool_default_false = Rox::Server::RoxFlag.new(false)
-    @bool_default_true = Rox::Server::RoxFlag.new(true)
-    @first_flag = Rox::Server::RoxFlag.new(true)
+    @boolDefaultFalse = Rox::Server::RoxFlag.new(false)
+    @boolDefaultTrue = Rox::Server::RoxFlag.new(true)
   end
 end
 
@@ -58,95 +60,63 @@ namespace '/' do
     [200, '']
   end
 
-  get 'api/values/:id' do |id|
-    if container.first_flag.enabled?
-      [200, JSON.generate({ value: id })]
-    else
-      [200, 'Eladddddd']
-    end
-  end
-
-  put 'api/values/:id' do
-    [200, '']
-  end
-
-  delete 'api/values/:id' do
-    [200, '']
-  end
-
   post '' do
     data = JSON.parse(request.body.read)
     action = data['action']
     payload = data['payload']
-    puts data
-
+    puts "data => #{data}"
     case action
     when 'staticFlagIsEnabled'
       flag = payload['flag']
       result = container.send(flag.to_sym).enabled?(payload['context'])
       [200, JSON.generate({ result: result })]
     when 'registerStaticContainers'
-      Rox::Server::RoxServer.register(container)
+      Rox::Server::RoxServer.register_with_namespace('namespace', container)
       [200, JSON.generate({ result: 'done' })]
     when 'setCustomPropertyToThrow'
       def raise_(ex)
         raise ex
       end
-      Rox::Server::RoxServer.set_custom_string_property(payload['key'], raise_(Exception('error')))
+      Rox::Server::RoxServer.set_custom_string_property(payload['key']) do |_context|
+        raise_(StandardError.new "custom property generator error")
+      end
       [200, JSON.generate({ result: 'done' })]
     when 'setCustomStringProperty'
       Rox::Server::RoxServer.set_custom_string_property(payload['key'], payload['value'])
       [200, JSON.generate({ result: 'done' })]
     when 'dynamicFlagValue'
-      if payload['context']
-        puts "There is a payload[context] => #{payload['context']}"
-        payload['context'].each do |context|
-          key = context[0]
-          value = context[1]
-          Rox::Server::RoxServer.set_custom_string_property(key, value) if value.instance_of? String
-          if value.instance_of? TrueClass
-            Rox::Server::RoxServer.set_custom_boolean_property(key, value)
-          elsif value.instance_of? FalseClass
-            Rox::Server::RoxServer.set_custom_boolean_property(key, value)
-          end
-          Rox::Server::RoxServer.set_custom_int_property(key, value) if value.instance_of? Integer
-          Rox::Server::RoxServer.set_custom_float_property(key, value) if value.instance_of? Float
-        end
-      end
-      result = Rox::Server::RoxServer.dynamic_api.value(payload['flag'], payload['defaultValue'], payload['context'],
-                                                        [])
+      result = Rox::Server::RoxServer.dynamic_api.value(payload['flag'], payload['defaultValue'], payload['context'], [])
       [200, JSON.generate({ result: result })]
     when 'dynamicFlagIsEnabled'
-      payload['context']&.each do |context|
-        key = context[0]
-        value = context[1]
-        Rox::Server::RoxServer.set_custom_string_property(key, value) if value.instance_of? String
-        if value.instance_of? TrueClass
-          Rox::Server::RoxServer.set_custom_boolean_property(key, value)
-        elsif value.instance_of? FalseClass
-          Rox::Server::RoxServer.set_custom_boolean_property(key, value)
-        end
-        Rox::Server::RoxServer.set_custom_int_property(key, value) if value.instance_of? Integer
-        Rox::Server::RoxServer.set_custom_float_property(key, value) if value.instance_of? Float
-      end
       result = Rox::Server::RoxServer.dynamic_api.enabled?(payload['flag'], payload['defaultValue'], payload['context'])
       [200, JSON.generate({ result: result })]
     when 'setupAndAwait'
       env = 'stam'
+      fetch_interval = nil
       if payload['options']
         options = payload['options']
+        env = options['env']
+        fetch_interval = options['fetchInterval']
         if options['configuration']
           configuration = options['configuration']
-          env = configuration['env']
         end
       end
+      network_config = nil
       case env
+      when 'container'
+        network_config = Rox::Server::NetworkConfigurationsOptions.new(
+          get_config_api_endpoint:    configuration['CD_API_ENDPOINT']&.chomp('/'),
+          get_config_cloud_endpoint:  configuration['CD_S3_ENDPOINT']&.chomp('/'),
+          send_state_api_endpoint:    configuration['SS_API_ENDPOINT']&.chomp('/'),
+          send_state_cloud_endpoint:  configuration['SS_S3_ENDPOINT']&.chomp('/'),
+          analytics_endpoint:         configuration['ANALYTICS_ENDPOINT']&.chomp('/'),
+          push_notification_endpoint: configuration['NOTIFICATIONS_ENDPOINT']&.chomp('/'))
       when 'qa'
         ENV['ROLLOUT_MODE'] = 'QA'
       when 'localhost'
         ENV['ROLLOUT_MODE'] = 'LOCAL'
       end
-      options = Rox::Server::RoxOptions.new(logger: ServerLogger.new)
+      options = Rox::Server::RoxOptions.new(fetch_interval: fetch_interval,logger: ServerLogger.new, network_configurations_options: network_config)
       puts "options => #{options}"
       Rox::Server::RoxServer.setup(payload['key'], options).value
       [200, JSON.generate({ result: 'done' })]

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