rox-rollout 0.1.3

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

@@ -0,0 +1,16 @@
+module Rox
+  module Core
+    class Response
+      attr_accessor :status_code, :text
+
+      def initialize(status_code, text)
+        @status_code = status_code
+        @text = text
+      end
+
+      def success_status_code?
+        @status_code >= 200 && @status_code < 300
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Rox
+  module Core
+    class CustomProperty
+      attr_accessor :name, :type
+
+      def initialize(name, type, value = nil, &block)
+        @name = name
+        @type = type
+        @value = value
+        @block = block
+      end
+
+      def value(context)
+        @block.nil? ? @value : @block.call(context)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Rox
+  module Core
+    class CustomPropertyType
+      attr_accessor :type, :external_type
+
+      def initialize(type, external_type)
+        @type = type
+        @external_type = external_type
+      end
+
+      STRING = CustomPropertyType.new('string', 'String')
+      BOOL = CustomPropertyType.new('bool', 'Boolean')
+      INT = CustomPropertyType.new('int', 'Number')
+      FLOAT = CustomPropertyType.new('double', 'Number')
+      SEMVER = CustomPropertyType.new('semver', 'Semver')
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'rox/core/properties/custom_property'
+
+module Rox
+  module Core
+    class DeviceProperty < CustomProperty
+      def initialize(name, type, value = nil)
+        super('rox.' + name, type, value)
+      end
+    end
+  end
+end

data/lib/rox/core/register/registerer.rb

@@ -0,0 +1,35 @@
+module Rox
+  module Core
+    class Registerer
+      def initialize(flag_repository)
+        @flag_repository = flag_repository
+        @namespaces = []
+        @mutex = Mutex.new
+      end
+
+      def register_instance(container, ns)
+        raise ArgumentError, 'A namespace cannot be null' if ns.nil?
+
+        @mutex.synchronize do
+          raise ArgumentError, "A container with the given namespace (#{ns}) has already been registered" if @namespaces.include?(ns)
+        end
+
+        @namespaces << ns
+
+        container.methods.each do |method_name|
+          method = container.method(method_name)
+          next unless method.arity.zero?
+
+          begin
+            value = method.call
+            if value.is_a?(Variant)
+              @flag_repository.add_flag(value, ns == '' ? method_name.to_s : "#{ns}.#{method_name}")
+            end
+          rescue StandardError
+            next
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rox/core/reporting/error_reporter.rb

@@ -0,0 +1,152 @@
+require 'rox/core/logging/logging'
+
+module Rox
+  module Core
+    class ErrorReporter
+      BUGSNAG_NOTIFY_URL = 'https://notify.bugsnag.com'.freeze
+
+      def initialize(request, device_properties, buid)
+        @request = request
+        @device_properties = device_properties
+        @buid = buid
+      end
+
+      def report(message, ex)
+        return if @device_properties.rollout_environment == 'LOCAL'
+
+        Logging.logger.error("Error report: #{message}", ex)
+
+        begin
+          stack_trace = ex.nil? ? caller : ex.backtrace
+          stack = parse_stack_trace(stack_trace)
+          payload = create_payload(message, ex, stack)
+        rescue StandardError => e
+          Logging.logger.error('failed to create bugsnag json payload of the error', e)
+        else
+          Thread.new { send_error(payload) }
+        end
+      end
+
+      def send_error(payload)
+        Logging.logger.debug('Sending bugsnag error report...')
+
+        begin
+          @request.send_post(ErrorReporter::BUGSNAG_NOTIFY_URL, payload)
+          Logging.logger.debug('Bugsnag error report was sent')
+        rescue StandardError => ex
+          Logging.logger.error('Failed to send bugsnag error ', ex)
+        end
+      end
+
+      def create_payload(message, ex, stack)
+        payload = {}
+        add_api_key(payload)
+        add_notifier(payload)
+        add_events(message, ex, stack, payload)
+
+        payload
+      end
+
+      def add_metadata(message, ev)
+        inner_data = {
+            'message' => message,
+            'deviceId' => @device_properties.distinct_id,
+            'buid' => @buid.to_s
+        }
+
+        metadata = {
+            'data' => inner_data
+        }
+
+        ev['metaData'] = metadata
+      end
+
+      def add_api_key(payload)
+        payload['apiKey'] = '9569ec14f61546c6aa2a97856492bf4d'
+      end
+
+      def add_events(message, ex, stack, payload)
+        evs = []
+        add_event(message, ex, stack, evs)
+        payload['events'] = evs
+      end
+
+      def add_event(message, ex, stack, events)
+        ev = {}
+        add_payload_version(ev)
+        add_exceptions(message, ex, stack, ev)
+        add_user('id', @device_properties.rollout_key, ev)
+        add_metadata(message, ev)
+        add_app(ev)
+
+        events << ev
+      end
+
+      def add_payload_version(ev)
+        ev['payloadVersion'] = 2
+      end
+
+      def add_notifier(payload)
+        notifier = {
+            'name' => 'Rollout Ruby SDK',
+            'version' => @device_properties.lib_version
+        }
+        payload['notifier'] = notifier
+      end
+
+      def add_user(id, rollout_key, ev)
+        user = {
+            id => rollout_key
+        }
+        ev['user'] = user
+      end
+
+      def add_exceptions(message, ex, stack, ev)
+        exceptions = []
+        exception = {}
+
+        if ex.nil?
+          exception['errorClass'] = message
+          exception['message'] = message
+          exception['stacktrace'] = []
+        else
+          exception['errorClass'] = ex.message
+          exception['message'] = ex.message
+          exception['stacktrace'] = stack
+        end
+
+        exceptions.append(exception)
+        ev['exceptions'] = exceptions
+      end
+
+      def add_app(ev)
+        app = {
+            'releaseStage' => @device_properties.rollout_environment,
+            'version' => @device_properties.lib_version
+        }
+        ev['app'] = app
+      end
+
+      STACK_TRACE_LINE_REGEX = /^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$/
+
+      def parse_stack_trace(stack_trace)
+        stack = []
+        stack_trace.each do |line|
+          match = line.match(STACK_TRACE_LINE_REGEX)
+          next if match.nil?
+
+          file = match[1]
+          line_str = match[2]
+          func = match[3]
+          stack << {
+            'file' => file,
+            'method' => func,
+            'lineNumber' => line_str.to_i,
+            'columnNumber' => 0
+          }
+        end
+        stack
+      end
+    end
+  end
+end

data/lib/rox/core/repositories/custom_property_repository.rb

@@ -0,0 +1,61 @@
+module Rox
+  module Core
+    class CustomPropertyRepository
+      def initialize
+        @custom_properties = {}
+        @property_added_handlers = []
+        @mutex = Mutex.new
+        @handlers_mutex = Mutex.new
+      end
+
+      def add_custom_property(custom_property)
+        return if custom_property.name.nil? || custom_property.name.empty?
+
+        @mutex.synchronize do
+          @custom_properties[custom_property.name] = custom_property
+        end
+
+        raise_property_added_event(custom_property)
+      end
+
+      def add_custom_property_if_not_exists(custom_property)
+        return if custom_property.name.nil? || custom_property.name.empty?
+
+        @mutex.synchronize do
+          return if @custom_properties.include?(custom_property.name)
+        end
+
+        add_custom_property(custom_property)
+      end
+
+      def custom_property(name)
+        @mutex.synchronize do
+          return @custom_properties[name]
+        end
+      end
+
+      def all_custom_properties
+        @mutex.synchronize do
+          return @custom_properties.values
+        end
+      end
+
+      def register_property_added_handler(&block)
+        @handlers_mutex.synchronize do
+          @property_added_handlers << block
+        end
+      end
+
+      def raise_property_added_event(custom_property)
+        handlers = []
+        @handlers_mutex.synchronize do
+          handlers = @property_added_handlers.clone
+        end
+
+        handlers.each do |handler|
+          handler.call(custom_property)
+        end
+      end
+    end
+  end
+end

data/lib/rox/core/repositories/experiment_repository.rb

@@ -0,0 +1,21 @@
+module Rox
+  module Core
+    class ExperimentRepository
+      def initialize
+        @experiments = []
+      end
+
+      def experiments=(experiments)
+        @experiments = experiments
+      end
+
+      def experiment_by_flag(flag_name)
+        @experiments.detect { |e| e.flags.include?(flag_name) }
+      end
+
+      def all_experiments
+        @experiments
+      end
+    end
+  end
+end

data/lib/rox/core/repositories/flag_repository.rb

@@ -0,0 +1,49 @@
+module Rox
+  module Core
+    class FlagRepository
+      def initialize
+        @variants = {}
+        @flag_added_handlers = []
+        @mutex = Mutex.new
+        @handlers_mutex = Mutex.new
+      end
+
+      def add_flag(variant, name)
+        variant.name = name if variant.name.nil? || variant.name.empty?
+        @mutex.synchronize do
+          @variants[name] = variant
+        end
+        raise_flag_added_event(variant)
+      end
+
+      def flag(name)
+        @mutex.synchronize do
+          return @variants[name]
+        end
+      end
+
+      def all_flags
+        @mutex.synchronize do
+          return @variants.values
+        end
+      end
+
+      def register_flag_added_handler(&block)
+        @handlers_mutex.synchronize do
+          @flag_added_handlers << block
+        end
+      end
+
+      def raise_flag_added_event(flag)
+        handlers = []
+        @handlers_mutex.synchronize do
+          handlers = @flag_added_handlers.clone
+        end
+
+        handlers.each do |handler|
+          handler.call(flag)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'digest'
+
+module Rox
+  module Core
+    class ExperimentsExtensions
+      def initialize(parser, target_groups_repository, flags_repository, experiment_repository)
+        @parser = parser
+        @target_groups_repository = target_groups_repository
+        @flags_repository = flags_repository
+        @experiment_repository = experiment_repository
+      end
+
+      def extend
+        @parser.add_operator('mergeSeed') do |parser, stack, context|
+          seed1 = stack.pop
+          seed2 = stack.pop
+          stack.push("#{seed1}.#{seed2}")
+        end
+
+        @parser.add_operator('isInPercentage') do |parser, stack, context|
+          percentage = stack.pop
+          seed = stack.pop
+
+          percentage = percentage.is_a?(Numeric) ? percentage : percentage.to_s.to_f
+
+          bucket = bucket(seed)
+          stack.push(bucket <= percentage)
+        end
+
+        @parser.add_operator('isInPercentageRange') do |parser, stack, context|
+          percentage_low = stack.pop
+          percentage_high = stack.pop
+          seed = stack.pop
+
+          percentage_low = percentage_low.is_a?(Numeric) ? percentage_low : percentage_low.to_s.to_f
+          percentage_high = percentage_high.is_a?(Numeric) ? percentage_high : percentage_high.to_s.to_f
+
+          bucket = bucket(seed)
+          stack.push(percentage_low <= bucket && bucket < percentage_high)
+        end
+
+        @parser.add_operator('flagValue') do |parser, stack, context|
+          feature_flag_identifier = stack.pop
+          result = Flag::FLAG_FALSE_VALUE
+          variant = @flags_repository.flag(feature_flag_identifier)
+
+          if !variant.nil?
+            result = variant.value(context)
+          else
+            flags_experiment = @experiment_repository.experiment_by_flag(feature_flag_identifier)
+
+            if !flags_experiment.nil? && !flags_experiment.condition.nil? && !flags_experiment.condition.empty?
+              experiment_eval_result = parser.evaluate_expression(flags_experiment.condition, context).string_value
+              result = experiment_eval_result if !experiment_eval_result.nil? && !experiment_eval_result.empty?
+            end
+          end
+
+          stack.push(result)
+        end
+
+        @parser.add_operator('isInTargetGroup') do |parser, stack, context|
+          target_group_identifier = stack.pop
+          target_group = @target_groups_repository.target_group(target_group_identifier)
+          if target_group.nil?
+            stack.push(false)
+          else
+            stack.push(parser.evaluate_expression(target_group.condition, context).bool_value)
+          end
+        end
+      end
+
+      def bucket(seed)
+        bytes = Digest::MD5.digest(seed).bytes
+        hash = (bytes[0] & 0xFF) | ((bytes[1] & 0xFF) << 8) | ((bytes[2] & 0xFF) << 16) | ((bytes[3] & 0xFF) << 24)
+        hash &= 0xFFFFFFFF
+        bucket = hash * 1.0 / (2**32 - 1)
+
+        bucket == 1 ? 0 : bucket
+      end
+    end
+  end
+end