splitclient-rb 6.3.0 → 8.11.0

data/lib/splitclient-rb/engine/auth_api_client.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'jwt'
+require 'cgi'
+
+module SplitIoClient
+  module Engine
+    class AuthApiClient
+      def initialize(config, telemetry_runtime_producer)
+        @config = config
+        @api_client = SplitIoClient::Api::Client.new(@config)
+        @telemetry_runtime_producer = telemetry_runtime_producer
+      end
+
+      def authenticate(api_key)
+        start = Time.now
+        response = @api_client.get_api("#{@config.auth_service_url}?s=#{SplitIoClient::Spec::FeatureFlags::SPEC_VERSION}", api_key)
+
+        return process_success(response, start) if response.success?
+
+        return process_error(response) if response.status >= 400 && response.status < 500
+
+        @telemetry_runtime_producer.record_sync_error(Telemetry::Domain::Constants::TOKEN_SYNC, response.status.to_i)
+        @config.logger.debug("Error connecting to: #{@config.auth_service_url}. Response status: #{response.status}") if @config.debug_enabled
+        { push_enabled: false, retry: true }
+      rescue StandardError => e
+        @config.logger.debug("AuthApiClient error: #{e.inspect}.") if @config.debug_enabled
+        { push_enabled: false, retry: false }
+      end
+
+      private
+
+      def expiration(token_decoded)
+        exp = token_decoded[0]['exp']
+        issued_at = token_decoded[0]['iat']
+
+        exp - issued_at - SplitIoClient::Constants::EXPIRATION_RATE
+      end
+
+      def channels(token_decoded)
+        capability = token_decoded[0]['x-ably-capability']
+        channels_hash = JSON.parse(capability)
+        channels_string = channels_hash.keys.join(',')
+        channels_string = control_channels(channels_string)
+        @config.logger.debug("Channels #{channels_string}") if @config.debug_enabled
+        CGI.escape(channels_string)
+      end
+
+      def decode_token(token)
+        JWT.decode token, nil, false
+      end
+
+      def process_error(response)
+        @config.logger.debug("Error connecting to: #{@config.auth_service_url}. Response status: #{response.status}") if @config.debug_enabled
+        @telemetry_runtime_producer.record_auth_rejections if response.status == 401
+
+        { push_enabled: false, retry: false }
+      end
+
+      def process_success(response, start)
+        @config.logger.debug("Success connection to: #{@config.auth_service_url}") if @config.debug_enabled
+        record_telemetry(start)
+
+        body_json = JSON.parse(response.body, symbolize_names: true)
+        push_enabled = body_json[:pushEnabled]
+        token = body_json[:token]
+
+        if push_enabled
+          decoded_token = decode_token(token)
+          channels = channels(decoded_token)
+          exp = expiration(decoded_token)
+
+          @telemetry_runtime_producer.record_token_refreshes
+        end
+
+        { push_enabled: push_enabled, token: token, channels: channels, exp: exp, retry: true }
+      end
+
+      def control_channels(channels_string)
+        prefix = SplitIoClient::Constants::OCCUPANCY_CHANNEL_PREFIX
+        control_pri = SplitIoClient::Constants::CONTROL_PRI
+        control_sec = SplitIoClient::Constants::CONTROL_SEC
+        channels_string = channels_string.gsub(control_pri, "#{prefix}#{control_pri}")
+
+        channels_string.gsub(control_sec, "#{prefix}#{control_sec}")
+      end
+
+      def record_telemetry(start)
+        bucket = BinarySearchLatencyTracker.get_bucket((Time.now - start) * 1000.0)
+        @telemetry_runtime_producer.record_sync_latency(Telemetry::Domain::Constants::TOKEN_SYNC, bucket)
+        timestamp = (Time.now.to_f * 1000.0).to_i
+        @telemetry_runtime_producer.record_successful_sync(Telemetry::Domain::Constants::TOKEN_SYNC, timestamp)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/engine/back_off.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module Engine
+    BACKOFF_MAX_ALLOWED = 1800
+    class BackOff
+      def initialize(back_off_base, attempt = 0, max_allowed = BACKOFF_MAX_ALLOWED)
+        @attempt = attempt
+        @back_off_base = back_off_base
+        @max_allowed = max_allowed
+      end
+
+      def interval
+        interval = 0
+        interval = (@back_off_base * (2**@attempt)) if @attempt.positive?
+        @attempt += 1
+
+        interval >= @max_allowed ? @max_allowed : interval
+      end
+
+      def reset
+        @attempt = 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module SplitIoClient
+  module Engine
+    module Common
+      TIME_INTERVAL_MS = 3600 * 1000
+
+      class ImpressionCounter
+        DEFAULT_AMOUNT = 1
+
+        def initialize
+          @cache = Concurrent::Hash.new
+        end
+
+        def inc(split_name, time_frame)
+          key = make_key(split_name, time_frame)
+
+          current_amount = @cache[key]
+          @cache[key] = current_amount.nil? ? DEFAULT_AMOUNT : (current_amount + DEFAULT_AMOUNT)
+        end
+
+        def pop_all
+          to_return = Concurrent::Hash.new
+
+          @cache.each do |key, value|
+            to_return[key] = value
+          end
+          @cache.clear
+
+          to_return
+        end
+
+        def make_key(split_name, time_frame)
+          "#{split_name}::#{ImpressionCounter.truncate_time_frame(time_frame)}"
+        end
+
+        def self.truncate_time_frame(timestamp_ms)
+          timestamp_ms - (timestamp_ms % TIME_INTERVAL_MS)
+        end
+      end
+    end
+  end
+end

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-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 == SplitIoClient::Engine::Models::SdkEvent::SDK_READY && event_already_triggered(sdk_event)
+              @active_subscriptions[sdk_event] = SplitIoClient::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] = SplitIoClient::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 == SplitIoClient::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 = SplitIoClient::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 = SplitIoClient::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 = SplitIoClient::Engine::Models::ValidSdkEvent.new(nil, false)
+          @manager_config.require_any.each do |name, val|
+            if val.include?(sdk_internal_event)
+              valid_sdk_event = SplitIoClient::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