splitclient-rb 1.0.2.wip → 8.11.1.pre.rc1-java

data/lib/splitclient-rb/engine/common/impressions_manager.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Common
+      class ImpressionManager
+        def initialize(config,
+                       impressions_repository,
+                       impression_counter,
+                       telemetry_runtime_producer,
+                       impression_observer,
+                       unique_keys_tracker)
+          @config = config
+          @impressions_repository = impressions_repository
+          @impression_counter = impression_counter
+          @impression_observer = impression_observer
+          @telemetry_runtime_producer = telemetry_runtime_producer
+          @unique_keys_tracker = unique_keys_tracker
+        end
+
+        def build_impression(matching_key, bucketing_key, split_name, treatment_data, impressions_disabled, params = {},
+                             evaluation_options = nil)
+          properties = get_properties(evaluation_options)
+          impression_data = impression_data(matching_key, bucketing_key, split_name, treatment_data, params[:time], properties)
+          return impression(impression_data, params[:attributes]) if check_return_conditions(properties)
+
+          begin
+            if check_none_mode(impressions_disabled)
+              @impression_counter.inc(split_name, impression_data[:m])
+              @unique_keys_tracker.track(split_name, matching_key)
+            end
+            if check_observe_impressions
+              # In DEBUG mode we should calculate the pt only.
+              impression_data[:pt] = @impression_observer.test_and_set(impression_data)
+            end
+            if check_impression_counter(impression_data)
+              # In OPTIMIZED mode we should track the total amount of evaluations and deduplicate the impressions.
+              @impression_counter.inc(split_name, impression_data[:m])
+            end
+          rescue StandardError => e
+            @config.log_found_exception(__method__.to_s, e)
+          end
+
+          impression(impression_data, params[:attributes])
+        end
+
+        def track(impressions_decorator)
+          return if impressions_decorator.empty?
+
+          impressions_decorator.each do |impression_decorator|
+            impression_router.add_bulk([impression_decorator[:impression]])
+            stats = { dropped: 0, queued: 0, dedupe: 0 }
+            begin
+              next if @config.impressions_mode == :none || impression_decorator[:disabled]
+
+              if @config.impressions_mode == :debug
+                track_debug_mode([impression_decorator[:impression]], stats)
+              else
+                track_optimized_mode([impression_decorator[:impression]], stats)
+              end
+            rescue StandardError => e
+              @config.log_found_exception(__method__.to_s, e)
+            ensure
+              record_stats(stats)
+            end
+          end
+        end
+
+        private
+
+        def check_return_conditions(properties)
+          return (@config.impressions_mode == :debug || @config.impressions_mode == :optimized) && !properties.nil?
+        end
+
+        def check_none_mode(impressions_disabled)
+          return @config.impressions_mode == :none || impressions_disabled
+        end
+
+        def check_observe_impressions
+          return @config.impressions_mode == :debug || @config.impressions_mode == :optimized
+        end
+
+        def check_impression_counter(impression_data)
+          return @config.impressions_mode == :optimized && !impression_data[:pt].nil?
+        end
+
+        def get_properties(evaluation_options)
+          return evaluation_options.nil? ? nil : evaluation_options.properties
+        end
+
+        def impression_router
+          @impression_router ||= SplitIoClient::ImpressionRouter.new(@config)
+        rescue StandardError => e
+          @config.log_found_exception(__method__.to_s, e)
+        end
+
+        def record_stats(stats)
+          return if redis?
+
+          imp_queued = Telemetry::Domain::Constants::IMPRESSIONS_QUEUED
+          imp_dropped = Telemetry::Domain::Constants::IMPRESSIONS_DROPPED
+          imp_dedupe = Telemetry::Domain::Constants::IMPRESSIONS_DEDUPE
+          @telemetry_runtime_producer.record_impressions_stats(imp_queued, stats[:queued]) unless stats[:queued].zero?
+          @telemetry_runtime_producer.record_impressions_stats(imp_dropped, stats[:dropped]) unless stats[:dropped].zero?
+          @telemetry_runtime_producer.record_impressions_stats(imp_dedupe, stats[:dedupe]) unless stats[:dedupe].zero?
+        end
+
+        # added param time for test
+        def impression_data(matching_key, bucketing_key, split_name, treatment, time = nil,
+                            properties = nil)
+          {
+            k: matching_key,
+            b: bucketing_key,
+            f: split_name,
+            t: treatment[:treatment],
+            r: applied_rule(treatment[:label]),
+            c: treatment[:change_number],
+            m: time || (Time.now.to_f * 1000.0).to_i,
+            pt: nil,
+            properties: properties
+          }
+        end
+
+        def metadata
+          {
+            s: "#{@config.language}-#{@config.version}",
+            i: @config.machine_ip,
+            n: @config.machine_name
+          }
+        end
+
+        def applied_rule(label)
+          @config.labels_enabled ? label : nil
+        end
+
+        def should_queue_impression?(impression)
+          impression[:pt].nil? ||
+            (ImpressionCounter.truncate_time_frame(impression[:pt]) != ImpressionCounter.truncate_time_frame(impression[:m]))
+        end
+
+        def impression(impression_data, attributes)
+          { m: metadata, i: impression_data, attributes: attributes }
+        end
+
+        def redis?
+          @config.impressions_adapter.class.to_s == 'SplitIoClient::Cache::Adapters::RedisAdapter'
+        end
+
+        def track_debug_mode(impressions, stats)
+          stats[:dropped] = @impressions_repository.add_bulk(impressions)
+          stats[:queued] = impressions.length - stats[:dropped]
+        end
+
+        def track_optimized_mode(impressions, stats)
+          optimized_impressions = impressions.select { |imp| should_queue_impression?(imp[:i]) }
+          stats[:dedupe] = impressions.length - optimized_impressions.length
+          return if optimized_impressions.empty?
+
+          stats[:dropped] = @impressions_repository.add_bulk(optimized_impressions)
+          stats[:queued] = optimized_impressions.length - stats[:dropped]
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/common/noop_impressions_counter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module SplitIoClient
+  module Engine
+    module Common
+      class NoopImpressionCounter
+        def inc(split_name, time_frame)
+          # no-op
+        end
+
+        def pop_all
+          # no-op
+        end
+
+        def make_key(split_name, time_frame)
+          # no-op
+        end
+
+        def self.truncate_time_frame(timestamp_ms)
+          # no-op
+        end
+      end
+    end
+  end
+end

data/lib/{splitclient-engine → splitclient-rb/engine}/evaluator/splitter.rb

@@ -4,21 +4,25 @@ module SplitIoClient
   # based on provided key
   #
   class Splitter < NoMethodError
-
+    def initialize
+      @murmur_hash = case RUBY_PLATFORM
+      when 'java' 
+        Proc.new { |key, seed| Java::MurmurHash3.murmurhash3_x86_32(key, seed) }
+      else
+        Proc.new { |key, seed| Digest::MurmurHashMRI3_x86_32.rawdigest(key, [seed].pack('L')) }
+      end
+    end
+    
     #
     # Checks if the partiotion size is 100%
     #
     # @param partitions [object] array of partitions
     #
     # @return [boolean] true if partition is 100% false otherwise
-    def self.hundred_percent_one_treatment?(partitions)
-      if partitions.size != 1
-        return false
-      end
-      return (partitions.first).size == 100
+    def hundred_percent_one_treatment?(partitions)
+      (partitions.size != 1) ? false : (partitions.first.size == 100)
     end
 
-
     #
     # gets the appropriate treatment based on id, seed and partition value
     #
@@ -27,30 +31,41 @@ module SplitIoClient
     # @param partitions [object] array of partitions
     #
     # @return traetment [object] treatment value
-    def self.get_treatment(id, seed, partitions)
+    def get_treatment(id, seed, partitions, legacy_algo)
+      legacy = [1, nil].include?(legacy_algo)
+
       if partitions.empty?
-        return Treatments::CONTROL
+        return SplitIoClient::Engine::Models::Treatment::CONTROL
       end
 
       if hundred_percent_one_treatment?(partitions)
         return (partitions.first).treatment
       end
 
-      return get_treatment_for_key(bucket(hash(id, seed)), partitions)
+      return get_treatment_for_key(bucket(count_hash(id, seed, legacy)), partitions)
     end
 
+    # returns a hash value for the give key, seed pair
     #
-    # returns a hash value for the give key, sedd pair
-    #
-    # @param key [string] user key
-    # @param seed [number] seed for the user key
+    # @param key [String] user key
+    # @param seed [Fixnum] seed for the user key
     #
-    # @return hash [string] hash value
-    def self.hash(key, seed)
+    # @return hash [String] hash value
+    def count_hash(key, seed, legacy)
+      legacy ? legacy_hash(key, seed) : murmur_hash(key, seed)
+    end
+
+    def murmur_hash(key, seed)
+      @murmur_hash.call(key, seed)
+    end
+
+    def legacy_hash(key, seed)
       h = 0
+
       for i in 0..key.length-1
         h = to_int32(31 * h + key[i].ord)
       end
+
       h^seed
     end
 
@@ -60,7 +75,7 @@ module SplitIoClient
     # @param number [number] ruby number value
     #
     # @return [int] returns the int 32 value of the provided number
-    def self.to_int32(number)
+    def to_int32(number)
       begin
         sign = number < 0 ? -1 : 1
         abs = number.abs
@@ -83,7 +98,7 @@ module SplitIoClient
     # @param parittions [object] array of partitions
     #
     # @return treatment [treatment] treatment value for this bucket and partitions
-    def self.get_treatment_for_key(bucket, partitions)
+    def get_treatment_for_key(bucket, partitions)
       buckets_covered_thus_far = 0
       partitions.each do |p|
         unless p.is_empty?
@@ -92,7 +107,7 @@ module SplitIoClient
         end
       end
 
-      return Treatments::CONTROL
+      return SplitIoClient::Engine::Models::Treatment::CONTROL
     end
 
     #
@@ -101,10 +116,8 @@ module SplitIoClient
     # @param hash_value [string] hash value
     #
     # @return bucket [number] bucket number
-    def self.bucket(hash_value)
+    def bucket(hash_value)
       (hash_value.abs % 100) + 1
     end
-
   end
-
 end

data/lib/splitclient-rb/engine/events/events_delivery.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Events
+      class EventsDelivery
+        def initialize(config)
+          @config = config
+        end
+
+        def deliver(sdk_event, event_metadata, event_handler)
+          event_handler.call(event_metadata)
+        rescue StandardError => e
+          @config.logger.error("Exception when calling handler for Sdk Event #{sdk_event}")
+          @config.log_found_exception(__method__.to_s, e)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/events/events_manager.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Events
+      class EventsManager
+        def initialize(events_manager_config, events_delivery, config)
+          @manager_config = events_manager_config
+          @events_delivery = events_delivery
+          @active_subscriptions = {}
+          @internal_events_status = {}
+          @mutex = Mutex.new
+          @config = config
+        end
+
+        def register(sdk_event, event_handler)
+          return if @active_subscriptions.key?(sdk_event) && !get_event_handler(sdk_event).nil?
+
+          @mutex.synchronize do
+            # SDK ready already fired
+            if sdk_event == Engine::Models::SdkEvent::SDK_READY && event_already_triggered(sdk_event)
+              @active_subscriptions[sdk_event] = Engine::Models::EventActiveSubscriptions.new(true, event_handler)
+              @config.logger.debug('EventsManager: Firing SDK_READY event for new subscription') if @config.debug_enabled
+              fire_sdk_event(sdk_event, nil)
+              return
+            end
+
+            @config.logger.debug("EventsManager: Register event: #{sdk_event}") if @config.debug_enabled
+            @active_subscriptions[sdk_event] = Engine::Models::EventActiveSubscriptions.new(false, event_handler)
+          end
+        end
+
+        def unregister(sdk_event)
+          return unless @active_subscriptions.key?(sdk_event)
+
+          @mutex.synchronize do
+            @active_subscriptions.delete(sdk_event)
+          end
+        end
+
+        def notify_internal_event(sdk_internal_event, event_metadata)
+          @mutex.synchronize do
+            update_internal_event_status(sdk_internal_event, true)
+            @manager_config.evaluation_order.each do |sorted_event|
+              if get_sdk_event_if_applicable(sdk_internal_event).include?(sorted_event) &&
+                 !get_event_handler(sorted_event).nil?
+                fire_sdk_event(sorted_event, event_metadata)
+              end
+
+              # if client is not subscribed to SDK_READY
+              if check_if_register_needed(sorted_event)
+                @config.logger.debug('EventsManager: Registering SDK_READY event as fired') if @config.debug_enabled
+                @active_subscriptions[Engine::Models::SdkEvent::SDK_READY] = Engine::Models::EventActiveSubscriptions.new(true, nil)
+              end
+            end
+          end
+        end
+
+        def destroy
+          @mutex.synchronize do
+            @active_subscriptions = {}
+            @internal_events_status = {}
+          end
+        end
+
+        private
+
+        def check_if_register_needed(sorted_event)
+          sorted_event == Engine::Models::SdkEvent::SDK_READY &&
+            get_event_handler(sorted_event).nil? &&
+            !@active_subscriptions.include?(sorted_event)
+        end
+
+        def fire_sdk_event(sdk_event, event_metadata)
+          @config.logger.debug("EventsManager: Firing Sdk event: #{sdk_event}") if @config.debug_enabled
+          @config.threads[:sdk_event_notify] = Thread.new do
+            @events_delivery.deliver(sdk_event, event_metadata, get_event_handler(sdk_event))
+          end
+          sdk_event_triggered(sdk_event)
+        end
+
+        def event_already_triggered(sdk_event)
+          return @active_subscriptions[sdk_event].triggered if @active_subscriptions.key?(sdk_event)
+
+          false
+        end
+
+        def get_internal_event_status(sdk_internal_event)
+          return @internal_events_status[sdk_internal_event] if @internal_events_status.key?(sdk_internal_event)
+
+          false
+        end
+
+        def update_internal_event_status(sdk_internal_event, status)
+          @internal_events_status[sdk_internal_event] = status
+        end
+
+        def sdk_event_triggered(sdk_event)
+          return unless @active_subscriptions.key?(sdk_event)
+
+          return if @active_subscriptions[sdk_event].triggered
+
+          @active_subscriptions[sdk_event].triggered = true
+        end
+
+        def get_event_handler(sdk_event)
+          return nil unless @active_subscriptions.key?(sdk_event)
+
+          @active_subscriptions[sdk_event].handler
+        end
+
+        def get_sdk_event_if_applicable(sdk_internal_event)
+          final_sdk_event = Engine::Models::ValidSdkEvent.new(nil, false)
+
+          events_to_fire = []
+          require_any_sdk_event = check_require_any(sdk_internal_event)
+          if require_any_sdk_event.valid
+            if (!event_already_triggered(require_any_sdk_event.sdk_event) &&
+               execution_limit(require_any_sdk_event.sdk_event) == 1) ||
+               execution_limit(require_any_sdk_event.sdk_event) == -1
+              final_sdk_event = Engine::Models::ValidSdkEvent.new(
+                require_any_sdk_event.sdk_event,
+                check_prerequisites(require_any_sdk_event.sdk_event) &&
+                check_suppressed_by(require_any_sdk_event.sdk_event)
+              )
+            end
+            events_to_fire.push(final_sdk_event.sdk_event) if final_sdk_event.valid
+          end
+          check_require_all.each { |sdk_event| events_to_fire.push(sdk_event) }
+
+          events_to_fire
+        end
+
+        def check_require_all
+          events = []
+          @manager_config.require_all.each do |require_name, require_value|
+            final_status = true
+            require_value.each { |val| final_status &= get_internal_event_status(val) }
+            events.push(require_name) if check_event_eligible_conditions(final_status, require_name, require_value)
+          end
+
+          events
+        end
+
+        def check_event_eligible_conditions(final_status, require_name, require_value)
+          final_status &&
+            check_prerequisites(require_name) &&
+            ((!event_already_triggered(require_name) &&
+            execution_limit(require_name) == 1) ||
+            execution_limit(require_name) == -1) &&
+            require_value.length.positive?
+        end
+
+        def check_prerequisites(sdk_event)
+          @manager_config.prerequisites.each do |name, value|
+            value.each do |val|
+              return false if name == sdk_event && !event_already_triggered(val)
+            end
+          end
+
+          true
+        end
+
+        def check_suppressed_by(sdk_event)
+          @manager_config.suppressed_by.each do |name, value|
+            value.each do |val|
+              return false if name == sdk_event && event_already_triggered(val)
+            end
+          end
+
+          true
+        end
+
+        def execution_limit(sdk_event)
+          return -1 unless @manager_config.execution_limits.key?(sdk_event)
+
+          @manager_config.execution_limits[sdk_event]
+        end
+
+        def check_require_any(sdk_internal_event)
+          valid_sdk_event = Engine::Models::ValidSdkEvent.new(nil, false)
+          @manager_config.require_any.each do |name, val|
+            if val.include?(sdk_internal_event)
+              valid_sdk_event = Engine::Models::ValidSdkEvent.new(name, true)
+              return valid_sdk_event
+            end
+          end
+
+          valid_sdk_event
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/events/events_manager_config.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Events
+      class EventsManagerConfig
+        attr_accessor :require_all, :prerequisites, :require_any, :suppressed_by, :execution_limits, :evaluation_order
+
+        def initialize
+          @require_all = construct_require_all
+          @prerequisites = construct_prerequisites
+          @require_any = construct_require_any
+          @suppressed_by = construct_suppressed_by
+          @execution_limits = construct_execution_limits
+          @evaluation_order = construct_sorted_events
+        end
+
+        private
+
+        def construct_require_all
+          {
+            SplitIoClient::Engine::Models::SdkEvent::SDK_READY => Set.new([SplitIoClient::Engine::Models::SdkInternalEvent::SDK_READY])
+          }
+        end
+
+        def construct_prerequisites
+          {
+            SplitIoClient::Engine::Models::SdkEvent::SDK_UPDATE => Set.new([SplitIoClient::Engine::Models::SdkEvent::SDK_READY])
+          }
+        end
+
+        def construct_require_any
+          {
+            SplitIoClient::Engine::Models::SdkEvent::SDK_UPDATE => Set.new(
+              [
+                SplitIoClient::Engine::Models::SdkInternalEvent::FLAG_KILLED_NOTIFICATION,
+                SplitIoClient::Engine::Models::SdkInternalEvent::FLAGS_UPDATED,
+                SplitIoClient::Engine::Models::SdkInternalEvent::RB_SEGMENTS_UPDATED,
+                SplitIoClient::Engine::Models::SdkInternalEvent::SEGMENTS_UPDATED
+              ]
+            )
+          }
+        end
+
+        def construct_suppressed_by
+          {}
+        end
+
+        def construct_execution_limits
+          {
+            SplitIoClient::Engine::Models::SdkEvent::SDK_READY => 1,
+            SplitIoClient::Engine::Models::SdkEvent::SDK_UPDATE => -1
+          }
+        end
+
+        def construct_sorted_events
+          sorted_events = []
+          [SplitIoClient::Engine::Models::SdkEvent::SDK_READY, SplitIoClient::Engine::Models::SdkEvent::SDK_UPDATE].each do |sdk_event|
+            sorted_events = dfs_recursive(sdk_event, sorted_events)
+          end
+
+          sorted_events
+        end
+
+        def dfs_recursive(sdk_event, added)
+          return added if added.include?(sdk_event)
+
+          get_dependencies(sdk_event).each do |dependent_event|
+            added = dfs_recursive(dependent_event, added)
+          end
+
+          added.push(sdk_event)
+
+          added
+        end
+
+        def get_dependencies(sdk_event)
+          dependencies = Set.new
+          @prerequisites.each do |prerequisites_event_name, prerequisites_event_value|
+            next unless prerequisites_event_name == sdk_event
+
+            prerequisites_event_value.each do |prereq_event|
+              dependencies.add(prereq_event)
+            end
+          end
+
+          @suppressed_by.each do |suppressed_event_name, suppressed_event_value|
+            dependencies.add(suppressed_event_name) if suppressed_event_value.include?(sdk_event)
+          end
+
+          dependencies
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/events/events_task.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Events
+      class EventsTask
+        attr_accessor :running
+
+        def initialize(notify_internal_events, internal_events_queue, config)
+          @notify_internal_events = notify_internal_events
+          @internal_events_queue = internal_events_queue
+          @config = config
+          @running = false
+        end
+
+        def start
+          return if @running
+
+          @config.logger.info('Starting Internal Events Task.')
+          @running = true
+          @config.threads[:internal_events_task] = Thread.new do
+            worker_thread
+          end
+        end
+
+        def stop
+          return unless @running
+
+          @config.logger.info('Stopping Internal Events Task.')
+          @running = false
+        end
+
+        private
+
+        def worker_thread
+          while (event = @internal_events_queue.pop)
+            break unless @running
+
+            @config.logger.debug("Processing sdk internal event: #{event.internal_event}") if @config.debug_enabled
+            begin
+              @notify_internal_events.call(event.internal_event, event.metadata)
+            rescue StandardError => e
+              @config.log_found_exception(__method__.to_s, e)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/events/noop_events_queue.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    module Events
+      class NoOpEventsQueue
+        def push(sdk_event)
+          # do nothing
+        end
+      end
+    end
+  end
+end