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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd87f938e0d74bb4faf177feb49849972889e5d6
-  data.tar.gz: 9688664e2908e4da58b18e0b7be14df1f195e423
+  metadata.gz: 17ccf70cef8223ac14aa96da12031c3205aa0f97
+  data.tar.gz: bd6561b5b2ffaec5d86054096ed8a39c4de0e9e3
 SHA512:
-  metadata.gz: 7d332075f3806c6bcca59202d28bcaa6ed371ee91f4822dd3d5ea7aae189e1c486d9a0ffc3b5b41842705e91c744fb02fa617be26715e6b0b9795e9e31461cf7
-  data.tar.gz: 0b97cedea81959f33eeb41f84a4ac9fcdfce37228a67e98a449f460e4d0b5cdec2b360cf8eb907df08f73de0b6c8fceb44d7f8873064152187e8be1ddd4a1056
+  metadata.gz: 630a6b415a70618e1fddafbcfac110c942249e69787c65418bf2d7f545b591809c235e002a68e682c37b27042af10d6d8cf920fe00858a79b22224c117ad7ae9
+  data.tar.gz: 86f6adf182a94bdd00e9459f3d46cae7d1943320851d0e9a2cc437e454bfb5259184af34b6f73861670888220299a8c4c0c8cebc7b33391155a2763d8c0182e9

data/.rubocop.yml

@@ -2,18 +2,25 @@ Documentation:
     Enabled: false
 
 Metrics/AbcSize:
-  Max: 25
+  Max: 26
 
 Metrics/MethodLength:
   Max: 20
 
 Metrics/ClassLength:
-  Max: 120
+  Max: 150
 
 Metrics/LineLength:
-  Max: 121
+  Max: 130
   Exclude:
     - spec/sse/**/*
+    - spec/integrations/**/*
+    - spec/engine/sync_manager_spec.rb
+
+Style/BracesAroundHashParameters:
+  Exclude:
+    - spec/integrations/push_client_spec.rb
+    - spec/engine/synchronizer_spec.rb
 
 Metrics/BlockLength:
   Exclude:

data/CHANGES.txt

@@ -1,3 +1,6 @@
+7.1.0 (Apr 30, 2020)
+- Added support for the new Split streaming architecture. When enabled, the SDK will not poll for updates but instead receive notifications every time there's a change in your environments, allowing to process those much quicker. If disabled (default) or in the event of an issue, the SDK will fallback to the known polling mechanism to provide a seamless experience.
+
 7.0.3 (Jan 20, 2020)
 - Added integration tests.
 - Fixed impressions labels.

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

@@ -10,6 +10,7 @@ module SplitIoClient
           @metrics = metrics
           @config = config
           @sdk_blocker = sdk_blocker
+          @semaphore = Mutex.new
         end
 
         def call
@@ -27,24 +28,34 @@ module SplitIoClient
         end
 
         def fetch_segment(name)
-          segments_api.fetch_segments_by_names([name])
+          @semaphore.synchronize do
+            segments_api.fetch_segments_by_names([name])
+            true
+          end
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
+          false
         end
 
         def fetch_segments
-          segments_api.fetch_segments_by_names(@segments_repository.used_segment_names)
+          @semaphore.synchronize do
+            segments_api.fetch_segments_by_names(@segments_repository.used_segment_names)
 
-          @sdk_blocker.segments_ready!
+            @sdk_blocker.segments_ready!
+          end
         rescue StandardError => error
           @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
           @config.threads[:segment_fetcher] = Thread.new do
-            @config.logger.info('Starting segments fetcher service')
+            @config.logger.info('Starting segments fetcher service') if @config.debug_enabled
 
             loop do
               next unless @sdk_blocker.splits_repository.ready?
@@ -52,8 +63,8 @@ module SplitIoClient
               fetch_segments
               @config.logger.debug("Segment names: #{@segments_repository.used_segment_names.to_a}") if @config.debug_enabled
 
-              sleep_for = StoreUtils.random_interval(@config.segments_refresh_rate)
-              @config.logger.debug("Segments store is sleeping for: #{sleep_for} seconds") if @config.debug_enabled
+              sleep_for = SplitIoClient::Cache::Stores::StoreUtils.random_interval(@config.segments_refresh_rate)
+              @config.logger.debug("Segments fetcher is sleeping for: #{sleep_for} seconds") if @config.debug_enabled
               sleep(sleep_for)
             end
           end

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

@@ -10,6 +10,7 @@ module SplitIoClient
           @metrics = metrics
           @config = config
           @sdk_blocker = sdk_blocker
+          @semaphore = Mutex.new
         end
 
         def call
@@ -27,32 +28,41 @@ module SplitIoClient
         end
 
         def fetch_splits
-          data = splits_since(@splits_repository.get_change_number)
+          @semaphore.synchronize do
+            data = splits_since(@splits_repository.get_change_number)
 
-          data[:splits] && data[:splits].each do |split|
-            add_split_unless_archived(split)
-          end
-
-          @splits_repository.set_segment_names(data[:segment_names])
-          @splits_repository.set_change_number(data[:till])
+            data[:splits] && data[:splits].each do |split|
+              add_split_unless_archived(split)
+            end
 
-          @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
+            @splits_repository.set_segment_names(data[:segment_names])
+            @splits_repository.set_change_number(data[:till])
 
-          @sdk_blocker.splits_ready!
+            @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
 
+            @sdk_blocker.splits_ready!
+            true
+          end
         rescue StandardError => error
           @config.log_found_exception(__method__.to_s, error)
+          false
+        end
+
+        def stop_splits_thread
+          SplitIoClient::Helpers::ThreadHelper.stop(:split_fetcher, @config)
         end
 
         private
 
         def splits_thread
           @config.threads[:split_fetcher] = Thread.new do
-            @config.logger.info('Starting splits fetcher service')
+            @config.logger.info('Starting splits fetcher service') if @config.debug_enabled
             loop do
               fetch_splits
 
-              sleep(StoreUtils.random_interval(@config.features_refresh_rate))
+              sleep_for = SplitIoClient::Cache::Stores::StoreUtils.random_interval(@config.features_refresh_rate)
+              @config.logger.debug("Splits fetcher is sleeping for: #{sleep_for} seconds") if @config.debug_enabled
+              sleep(sleep_for)
             end
           end
         end

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,10 @@
+# frozen_string_literal: true
+
+class SplitIoClient::Constants
+  EXPIRATION_RATE = 600
+  CONTROL_PRI = 'control_pri'
+  CONTROL_SEC = 'control_sec'
+  OCCUPANCY_CHANNEL_PREFIX = '[?occupancy=metrics.publishers]'
+  FETCH_BACK_OFF_BASE_RETRIES = 1
+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("Error connecting to: #{@config.auth_service_url}. Response status: #{response.status}")
+
+          return { push_enabled: false, retry: false }
+        end
+
+        @config.logger.debug("Error connecting 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}") if @config.debug_enabled
+        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}") if @config.debug_enabled
+
+        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,53 @@
+# 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, 1)
+      end
+
+      def start_sse
+        response = @auth_api_client.authenticate(@api_key)
+
+        @config.logger.debug("Auth service response push_enabled: #{response[:push_enabled]}") if @config.debug_enabled
+        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
+          begin
+            @config.logger.debug("schedule_next_token_refresh refresh in #{time} seconds.") if @config.debug_enabled
+            sleep(time)
+            @config.logger.debug('schedule_next_token_refresh starting ...') if @config.debug_enabled
+            stop_sse
+            start_sse
+          rescue StandardError => e
+            @config.logger.debug("schedule_next_token_refresh error: #{e.inspect}") if @config.debug_enabled
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# 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) }
+          manager.on_push_shutdown { process_push_shutdown }
+        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
+          start_stream_forked if defined?(PhusionPassenger)
+        elsif @config.standalone?
+          start_poll
+        end
+      end
+
+      private
+
+      # Starts tasks if stream is enabled.
+      def start_stream
+        @config.logger.debug('Starting push mode ...')
+        stream_start_thread
+        @synchronizer.start_periodic_data_recording
+
+        stream_start_sse_thread
+      end
+
+      def start_poll
+        @config.logger.debug('Starting polling mode ...')
+        @synchronizer.start_periodic_fetch
+        @synchronizer.start_periodic_data_recording
+      rescue StandardError => e
+        @config.logger.error("start_poll error : #{e.inspect}")
+      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
+          rescue StandardError => e
+            @config.logger.error("stream_start_thread error : #{e.inspect}")
+          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 => e
+            @config.logger.error("stream_start_sse_thread error : #{e.inspect}")
+          end
+        end
+      end
+
+      def start_stream_forked
+        PhusionPassenger.on_event(:starting_worker_process) { |forked| start_stream if forked }
+      end
+
+      def process_connected
+        @synchronizer.stop_periodic_fetch
+        @synchronizer.sync_all
+        @sse_handler.start_workers
+      rescue StandardError => e
+        @config.logger.error("process_connected error: #{e.inspect}")
+      end
+
+      def process_disconnect
+        @sse_handler.stop_workers
+        @synchronizer.start_periodic_fetch
+      rescue StandardError => e
+        @config.logger.error("process_disconnect error: #{e.inspect}")
+      end
+
+      def process_occupancy(push_enable)
+        process_disconnect unless push_enable
+        process_connected if push_enable
+      rescue StandardError => e
+        @config.logger.error("process_occupancy error: #{e.inspect}")
+      end
+
+      def process_push_shutdown
+        @push_manager.stop_sse
+        process_disconnect
+      rescue StandardError => e
+        @config.logger.error("process_push_shutdown error: #{e.inspect}")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# 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 ...') if @config.debug_enabled
+        fetch_splits
+        fetch_segments
+      end
+
+      def start_periodic_data_recording
+        impressions_sender
+        metrics_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
+        back_off = SplitIoClient::SSE::EventSource::BackOff.new(SplitIoClient::Constants::FETCH_BACK_OFF_BASE_RETRIES, 1)
+        loop do
+          break if @split_fetcher.fetch_splits
+
+          sleep(back_off.interval)
+        end
+      end
+
+      def fetch_segment(name)
+        back_off = SplitIoClient::SSE::EventSource::BackOff.new(SplitIoClient::Constants::FETCH_BACK_OFF_BASE_RETRIES, 1)
+        loop do
+          break if @segment_fetcher.fetch_segment(name)
+
+          sleep(back_off.interval)
+        end
+      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,25 @@
+# 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} thread...") if config.debug_enabled
+          sleep(0.1) while thread.status == 'run'
+          Thread.kill(thread)
+        end
+      rescue StandardError => e
+        config.logger.error(e.inspect)
+      end
+
+      def self.alive?(thread_sym, config)
+        thread = config.threads[thread_sym]
+
+        thread.nil? ? false : thread.alive?
+      end
+    end
+  end
+end