splitclient-rb 7.0.4.pre.rc3 → 7.1.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eafdd083c1f0790ba57e473a7b6fad62f9e142ecfbf7ec07f83a000ab9323756
-  data.tar.gz: d25fdfe6d2b57d85f3b0a6fd9886fd72c3fe4695193a378c17116a5e26d79eae
+  metadata.gz: faa0e8b87fc65523dcfa6611ddb9e672fbd213487aea472455435aa080c29f60
+  data.tar.gz: 69b8a67b002dadd9b92e20d04bf18f4a05756ded1822039c48e47ff12a4e20e8
 SHA512:
-  metadata.gz: f8e1ac7930d9afc93715329075c4853c5949b8f7cfcaeefb72658b5e02c3c89fdf46ebcde689d7b8071daeb25e5dd9939d7e457c7587f18c8e9f2c1185b342d0
-  data.tar.gz: 6c9f61e424c8aba6b9c2da31ee7df64fb64b0cb7ad99ff9c4e5c84b9ccaa57e040aa644e1c680a6720247236f3fdf96c6584100f928262ed9ea96d46cb571910
+  metadata.gz: b95e354b732d3377dc4d4bd5daf1b20d05b31e68478cb9e045f9f89b60a04c6834995a1522e7db43e450beeeec0bfb96547408f4f82032c80ad9117b7ac911be
+  data.tar.gz: 573ac96c29360b36f0091992604e3acd970732ca609377f1895776b1750dfc59d5627025c10ad8472c066a5b551fae0df87ff0db17ed3afe817bdfb12f1d42b7

data/.rubocop.yml

@@ -2,16 +2,16 @@ Documentation:
     Enabled: false
 
 Metrics/AbcSize:
-  Max: 25
+  Max: 26
 
 Metrics/MethodLength:
   Max: 20
 
 Metrics/ClassLength:
-  Max: 120
+  Max: 140
 
 Metrics/LineLength:
-  Max: 121
+  Max: 130
   Exclude:
     - spec/sse/**/*
 

data/lib/splitclient-rb/cache/fetchers/segment_fetcher.rb

@@ -40,6 +40,10 @@ module SplitIoClient
           @config.log_found_exception(__method__.to_s, error)
         end
 
+        def stop_segments_thread
+          SplitIoClient::Helpers::ThreadHelper.stop(:segment_fetcher, @config)
+        end
+
         private
 
         def segments_thread

data/lib/splitclient-rb/cache/fetchers/split_fetcher.rb

@@ -39,11 +39,14 @@ module SplitIoClient
           @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
 
           @sdk_blocker.splits_ready!
-
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
         end
 
+        def stop_splits_thread
+          SplitIoClient::Helpers::ThreadHelper.stop(:split_fetcher, @config)
+        end
+
         private
 
         def splits_thread

data/lib/splitclient-rb/cache/repositories/splits_repository.rb

@@ -133,7 +133,7 @@ module SplitIoClient
 
           return if split.nil?
 
-          split[:label] = Engine::Models::Label::KILLED
+          split[:killed] = true
           split[:defaultTreatment] = default_treatment
           split[:changeNumber] = change_number
 

data/lib/splitclient-rb/clients/split_client.rb

@@ -9,8 +9,9 @@ module SplitIoClient
     # @param api_key [String] the API key for your split account
     #
     # @return [SplitIoClient] split.io client instance
-    def initialize(api_key, adapter = nil, splits_repository, segments_repository, impressions_repository, metrics_repository, events_repository, sdk_blocker, config, sse_handler)
+    def initialize(api_key, metrics, splits_repository, segments_repository, impressions_repository, metrics_repository, events_repository, sdk_blocker, config)
       @api_key = api_key
+      @metrics = metrics
       @splits_repository = splits_repository
       @segments_repository = segments_repository
       @impressions_repository = impressions_repository
@@ -19,8 +20,6 @@ module SplitIoClient
       @sdk_blocker = sdk_blocker
       @destroyed = false
       @config = config
-      @adapter = adapter
-      @sse_handler = sse_handler
     end
 
     def get_treatment(
@@ -62,8 +61,6 @@ module SplitIoClient
         thread.join
       end
 
-      @sse_handler.sse_client.close if @config.push_notification_enabled
-
       @config.threads.values.each { |thread| Thread.kill(thread) }
 
       @splits_repository.clear
@@ -252,7 +249,7 @@ module SplitIoClient
         end
       latency = (Time.now - start) * 1000.0
       # Measure
-      @adapter.metrics.time('sdk.' + calling_method, latency)
+      @metrics.time('sdk.' + calling_method, latency)
 
       treatments_for_impressions = get_treatment_for_impressions(treatments_labels_change_numbers)
 
@@ -336,7 +333,7 @@ module SplitIoClient
         store_impression(split_name, matching_key, bucketing_key, treatment_data, attributes) if store_impressions
 
         # Measure
-        @adapter.metrics.time('sdk.' + calling_method, latency) unless multiple
+        @metrics.time('sdk.' + calling_method, latency) unless multiple
       rescue StandardError => error
         @config.log_found_exception(__method__.to_s, error)
 

data/lib/splitclient-rb/constants.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class SplitIoClient::Constants
+  EXPIRATION_RATE = 600
+  CONTROL_PRI = 'control_pri'
+  CONTROL_SEC = 'control_sec'
+  OCCUPANCY_CHANNEL_PREFIX = '[?occupancy=metrics.publishers]'
+end
+  

data/lib/splitclient-rb/engine/api/splits.rb

@@ -16,7 +16,6 @@ module SplitIoClient
         start = Time.now
 
         response = get_api("#{@config.base_uri}/splitChanges", @api_key, since: since)
-
         if response.success?
           result = splits_with_segment_names(response.body)
 

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'jwt'
+require 'cgi'
+
+module SplitIoClient
+  module Engine
+    class AuthApiClient
+      def initialize(config)
+        @config = config
+        @api_client = SplitIoClient::Api::Client.new(@config)
+      end
+
+      def authenticate(api_key)
+        response = @api_client.get_api(@config.auth_service_url, api_key)
+
+        return process_success(response) if response.success?
+
+        if response.status >= 400 && response.status < 500
+          @config.logger.debug("Problem to connect to: #{@config.auth_service_url}. Response status: #{response.status}")
+
+          return { push_enabled: false, retry: false }
+        end
+
+        @config.logger.debug("Problem to connect to: #{@config.auth_service_url}. Response status: #{response.status}")
+        { push_enabled: false, retry: true }
+      end
+
+      private
+
+      def expiration(token_decoded)
+        exp = token_decoded[0]['exp']
+
+        (exp - SplitIoClient::Constants::EXPIRATION_RATE) - Time.now.getutc.to_i unless exp.nil?
+      rescue StandardError => e
+        @config.logger.error("Error getting token expiration: #{e.inspect}")
+      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}")
+        CGI.escape(channels_string)
+      end
+
+      def decode_token(token)
+        JWT.decode token, nil, false
+      end
+
+      def process_success(response)
+        @config.logger.debug("Success connection to: #{@config.auth_service_url}")
+
+        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)
+        end
+
+        { push_enabled: push_enabled, token: token, channels: channels, exp: exp, retry: false }
+      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 = channels_string.gsub(control_sec, "#{prefix}#{control_sec}")
+        channels_string
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class PushManager
+      def initialize(config, sse_handler, api_key)
+        @config = config
+        @sse_handler = sse_handler
+        @auth_api_client = AuthApiClient.new(@config)
+        @api_key = api_key
+        @back_off = SplitIoClient::SSE::EventSource::BackOff.new(@config.auth_retry_back_off_base)
+      end
+
+      def start_sse
+        response = @auth_api_client.authenticate(@api_key)
+
+        if response[:push_enabled]
+          @sse_handler.start(response[:token], response[:channels])
+          schedule_next_token_refresh(response[:exp])
+          @back_off.reset
+        else
+          stop_sse
+        end
+
+        schedule_next_token_refresh(@back_off.interval) if response[:retry]
+      rescue StandardError => e
+        @config.logger.error("start_sse: #{e.inspect}")
+      end
+
+      def stop_sse
+        @sse_handler.process_disconnect if @sse_handler.sse_client.nil?
+        @sse_handler.stop
+      end
+
+      private
+
+      def schedule_next_token_refresh(time)
+        @config.threads[:schedule_next_token_refresh] = Thread.new do
+          sleep(time)
+          stop_sse
+          start_sse
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class SyncManager
+      include SplitIoClient::Cache::Fetchers
+
+      def initialize(
+        repositories,
+        api_key,
+        config,
+        sdk_blocker,
+        metrics
+      )
+        split_fetcher = SplitFetcher.new(repositories[:splits], api_key, metrics, config, sdk_blocker)
+        segment_fetcher = SegmentFetcher.new(repositories[:segments], api_key, metrics, config, sdk_blocker)
+        sync_params = { split_fetcher: split_fetcher, segment_fetcher: segment_fetcher }
+
+        @synchronizer = Synchronizer.new(repositories, api_key, config, sdk_blocker, sync_params)
+        notification_manager_keeper = SplitIoClient::SSE::NotificationManagerKeeper.new(config) do |manager|
+          manager.on_occupancy { |publisher_available| process_occupancy(publisher_available) }
+        end
+        @sse_handler = SplitIoClient::SSE::SSEHandler.new(
+          config,
+          @synchronizer,
+          repositories[:splits],
+          repositories[:segments],
+          notification_manager_keeper
+        ) do |handler|
+          handler.on_connected { process_connected }
+          handler.on_disconnect { process_disconnect }
+        end
+
+        @push_manager = PushManager.new(config, @sse_handler, api_key)
+        @config = config
+      end
+
+      def start
+        if @config.streaming_enabled
+          start_stream
+        elsif @config.standalone?
+          start_poll
+        end
+      end
+
+      private
+
+      # Starts tasks if stream is enabled.
+      def start_stream
+        stream_start_thread
+        stream_start_thread_forked if defined?(PhusionPassenger)
+
+        stream_start_sse_thread
+        stream_start_sse_thread_forked if defined?(PhusionPassenger)
+      end
+
+      def start_poll
+        @synchronizer.start_periodic_fetch
+        @synchronizer.start_periodic_data_recording
+      rescue StandardError => error
+        @config.logger.error(error)
+      end
+
+      # Starts thread which fetch splits and segments once and trigger task to periodic data recording.
+      def stream_start_thread
+        @config.threads[:sync_manager_start_stream] = Thread.new do
+          begin
+            @synchronizer.sync_all
+            @synchronizer.start_periodic_data_recording
+          rescue StandardError => error
+            @config.logger.error(error)
+          end
+        end
+      end
+
+      # Starts thread which connect to sse and after that fetch splits and segments once.
+      def stream_start_sse_thread
+        @config.threads[:sync_manager_start_sse] = Thread.new do
+          begin
+            @push_manager.start_sse
+          rescue StandardError => error
+            @config.logger.error(error)
+          end
+        end
+      end
+
+      def stream_start_thread_forked
+        PhusionPassenger.on_event(:starting_worker_process) { |forked| stream_start_thread if forked }
+      end
+
+      def stream_start_sse_thread_forked
+        PhusionPassenger.on_event(:starting_worker_process) { |forked| stream_start_sse_thread if forked }
+      end
+
+      def process_connected
+        @synchronizer.stop_periodic_fetch
+        @synchronizer.sync_all
+        @sse_handler.start_workers
+      end
+
+      def process_disconnect
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+      end
+
+      def process_occupancy(publisher_available)
+        process_disconnect unless publisher_available
+        process_connected if publisher_available
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Engine
+    class Synchronizer
+      include SplitIoClient::Cache::Fetchers
+      include SplitIoClient::Cache::Senders
+
+      def initialize(
+        repositories,
+        api_key,
+        config,
+        sdk_blocker,
+        params
+      )
+        @splits_repository = repositories[:splits]
+        @segments_repository = repositories[:segments]
+        @impressions_repository = repositories[:impressions]
+        @metrics_repository = repositories[:metrics]
+        @events_repository = repositories[:events]
+        @api_key = api_key
+        @config = config
+        @sdk_blocker = sdk_blocker
+        @split_fetcher = params[:split_fetcher]
+        @segment_fetcher = params[:segment_fetcher]
+      end
+
+      def sync_all
+        @config.logger.debug('Synchronizing Splits and Segments ...')
+        fetch_splits
+        fetch_segments
+      end
+
+      def start_periodic_data_recording
+        @metrics_sender = metrics_sender
+        @impressions_sender = impressions_sender
+        @events_sender = events_sender
+      end
+
+      def start_periodic_fetch
+        @split_fetcher.call
+        @segment_fetcher.call
+      end
+
+      def stop_periodic_fetch
+        @split_fetcher.stop_splits_thread
+        @segment_fetcher.stop_segments_thread
+      end
+
+      def fetch_splits
+        @split_fetcher.fetch_splits
+      end
+
+      def fetch_segment(name)
+        @segment_fetcher.fetch_segment(name)
+      end
+
+      private
+
+      def fetch_segments
+        @segment_fetcher.fetch_segments
+      end
+
+      # Starts thread which loops constantly and sends impressions to the Split API
+      def impressions_sender
+        ImpressionsSender.new(@impressions_repository, @api_key, @config).call
+      end
+
+      # Starts thread which loops constantly and sends metrics to the Split API
+      def metrics_sender
+        MetricsSender.new(@metrics_repository, @api_key, @config).call
+      end
+
+      # Starts thread which loops constantly and sends events to the Split API
+      def events_sender
+        EventsSender.new(@events_repository, @config).call
+      end
+    end
+  end
+end

data/lib/splitclient-rb/exceptions.rb

@@ -4,4 +4,12 @@ module SplitIoClient
   class SDKShutdownException < SplitIoError; end
 
   class SDKBlockerTimeoutExpiredException < SplitIoError; end
+
+  class SSEClientException < SplitIoError
+    attr_reader :event
+
+    def initialize(event)
+      @event = event
+    end
+  end
 end

data/lib/splitclient-rb/helpers/thread_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module Helpers
+    class ThreadHelper
+      def self.stop(thread_sym, config)
+        thread = config.threads[thread_sym]
+
+        unless thread.nil?
+          config.logger.debug("Stopping #{thread_sym} ...")
+          sleep(0.1) while thread.status == 'run'
+          Thread.kill(thread)
+        end
+      rescue StandardError => error
+        config.logger.error(error.inspect)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/split_config.rb

@@ -102,7 +102,11 @@ module SplitIoClient
       @split_validator = SplitIoClient::Validators.new(self)
       @localhost_mode = opts[:localhost_mode]
 
-      @push_notification_enabled = opts[:push_notification_enabled].nil? ? true : false
+      @streaming_enabled = consumer? ? false : (opts[:streaming_enabled].nil? ? SplitConfig.default_streaming_enabled : opts[:streaming_enabled])
+      @streaming_service_url = opts[:streaming_service_url] || SplitConfig.default_streaming_service_url
+      @auth_service_url = opts[:auth_service_url] || SplitConfig.default_auth_service_url
+      @auth_retry_back_off_base = SplitConfig.init_auth_retry_back_off(opts[:auth_retry_back_off_base] || SplitConfig.default_auth_retry_back_off_base)
+      @streaming_reconnect_back_off_base = SplitConfig.init_streaming_reconnect_back_off(opts[:streaming_reconnect_back_off_base] || SplitConfig.default_streaming_reconnect_back_off_base)
 
       startup_log
     end
@@ -256,7 +260,43 @@ module SplitIoClient
 
     attr_accessor :ip_addresses_enabled
 
-    attr_accessor :push_notification_enabled
+    attr_accessor :auth_service_url
+
+    attr_accessor :auth_retry_back_off_base
+
+    attr_accessor :streaming_service_url
+
+    attr_accessor :streaming_reconnect_back_off_base
+
+    attr_accessor :streaming_enabled
+
+    def self.default_streaming_enabled
+      true
+    end
+
+    def self.default_streaming_service_url
+      'https://realtime.ably.io/event-stream'
+    end
+
+    def self.default_auth_service_url
+      'https://auth.split-stage.io/api/auth'
+    end
+
+    def self.default_auth_retry_back_off_base
+      1
+    end
+
+    def self.default_streaming_reconnect_back_off_base
+      1
+    end
+
+    def self.init_auth_retry_back_off(auth_retry_back_off)
+      auth_retry_back_off < 1 ? SplitConfig.default_auth_retry_back_off_base : auth_retry_back_off
+    end
+
+    def self.init_streaming_reconnect_back_off(streaming_reconnect_back_off)
+      streaming_reconnect_back_off < 1 ? SplitConfig.default_streaming_reconnect_back_off_base : streaming_reconnect_back_off
+    end
 
     #
     # The default split client configuration
@@ -385,8 +425,6 @@ module SplitIoClient
        end
     end
 
-
-
     #
     # The default debug value
     #

data/lib/splitclient-rb/split_factory.rb

@@ -6,6 +6,7 @@ module SplitIoClient
 
     include SplitIoClient::Cache::Repositories
     include SplitIoClient::Cache::Stores
+    include SplitIoClient::Cache::Senders
 
     attr_reader :adapter, :client, :manager, :config
 
@@ -29,16 +30,14 @@ module SplitIoClient
       @splits_repository = SplitsRepository.new(@config)
       @segments_repository = SegmentsRepository.new(@config)
       @impressions_repository = ImpressionsRepository.new(@config)
-      @metrics_repository = MetricsRepository.new(@config)
       @events_repository = EventsRepository.new(@config, @api_key)
-
+      @metrics_repository = MetricsRepository.new(@config)
       @sdk_blocker = SDKBlocker.new(@splits_repository, @segments_repository, @config)
+      @metrics = Metrics.new(100, @metrics_repository)
 
-      @adapter = start!
+      start!
 
-      start_sse!
-
-      @client = SplitClient.new(@api_key, @adapter, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config, @sse_handler)
+      @client = SplitClient.new(@api_key, @metrics, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config)
       @manager = SplitManager.new(@splits_repository, @sdk_blocker, @config)
 
       validate_api_key
@@ -49,7 +48,11 @@ module SplitIoClient
     end
 
     def start!
-      SplitAdapter.new(@api_key, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config)
+      if @config.localhost_mode
+        start_localhost_components
+      else
+        SplitIoClient::Engine::SyncManager.new(repositories, @api_key, @config, @sdk_blocker, @metrics).start
+      end
     end
 
     def stop!
@@ -118,15 +121,22 @@ module SplitIoClient
       end
     end
 
-    def start_sse!
-      if @config.push_notification_enabled
-        @splits_worker = SSE::Workers::SplitsWorker.new(@adapter, @config, @splits_repository)
-        @segments_worker = SSE::Workers::SegmentsWorker.new(@adapter, @config, @segments_repository)
-        @control_worker = SSE::Workers::ControlWorker.new(@adapter, @config)
+    def repositories
+      repos = {}
+      repos[:splits] = @splits_repository
+      repos[:segments] = @segments_repository
+      repos[:impressions] = @impressions_repository
+      repos[:events] = @events_repository
+      repos[:metrics] = @metrics_repository
 
-        options = { channels:  'mauro-c', key: 'fake_key', url_host: 'fake-url' }
-        @sse_handler = SSE::SSEHandler.new(@config, options, @splits_worker, @segments_worker, @control_worker)
-      end
+      repos
+    end
+
+    def start_localhost_components
+      LocalhostSplitStore.new(@splits_repository, @config, @sdk_blocker).call
+
+      # Starts thread which loops constantly and cleans up repositories to avoid memory issues in localhost mode
+      LocalhostRepoCleaner.new(@impressions_repository, @metrics_repository, @events_repository, @config).call
     end
   end
 end

data/lib/splitclient-rb/sse/event_source/back_off.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class BackOff
+        def initialize(back_off_base)
+          @attempt = 0
+          @back_off_base = back_off_base
+        end
+
+        def interval
+          interval = (@back_off_base * (2**@attempt)) if @attempt.positive?
+          @attempt += 1
+
+          interval || 0
+        end
+
+        def reset
+          @attempt = 0
+        end
+      end
+    end
+  end
+end