splitclient-rb 7.3.3.pre.rc18 → 7.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 463a9d41ab4651544984dc087f5800d6e86566a694c8ca0929c224c145bed839
-  data.tar.gz: e8a870ca9198ff396ca9d5f621d86623acb08cc081ea145623c27f0b8571565d
+  metadata.gz: 23b9c717284c495997eb1a3808850bd25816c29a447f13147f51a0c60138187e
+  data.tar.gz: 5b438d7782da8fb3e67689161d5fb53083665a5e4703f1b5fe628718e3cde81d
 SHA512:
-  metadata.gz: 17fcb827a161a709cc2b6cbda87ed645d076eae3cb77a004ca9044f951adbd6ad040b0452c2f9eedf986e35ed2107a5d5b6d89e498303d2301c3356ff2acdb38
-  data.tar.gz: 106f1726837501774021c23cb5136354dd17ef7ed134eba49840c60d3a6f065f4d7d7243048f4a0ede51a98b98e79a63845267d4d656f5132a5d398295e70c25
+  metadata.gz: 8dfa68a91b4e0cff3090d96640494f8755515499699c882b073ebe292f6920386e39b1c0be1b24a52b581f74d7092faa3c9ad5bf33bdf8565e7576d3f2ff2669
+  data.tar.gz: 76c004e32ac5e215b7e45690a96e9f0b9a2735f1212004f76c4402e3fabcbab2891ad22aa4caba3b6fb8aa5270b9a397589851a4d576254e7b0d70d01e78b6b7

data/.github/workflows/update-license-year.yml

@@ -0,0 +1,45 @@
+name: Update License Year
+
+on:
+  schedule:
+    - cron: "0 3 1 1 *" # 03:00 AM on January 1
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      
+      - name: Set Current year
+        run: "echo CURRENT=$(date +%Y) >> $GITHUB_ENV"
+      
+      - name: Set Previous Year
+        run: "echo PREVIOUS=$(($CURRENT-1)) >> $GITHUB_ENV"
+
+      - name: Update LICENSE
+        uses: jacobtomlinson/gha-find-replace@v2
+        with:
+          find: ${{ env.PREVIOUS }}
+          replace: ${{ env.CURRENT }}
+          include: "LICENSE"
+          regex: false
+
+      - name: Commit files
+        run: |
+          git config user.name 'github-actions[bot]'
+          git config user.email 'github-actions[bot]@users.noreply.github.com'
+          git commit -m "Updated License Year" -a
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v3
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          title: Update License Year
+          branch: update-license

data/.rubocop.yml

@@ -10,6 +10,7 @@ Metrics/MethodLength:
   Max: 20
   Exclude:
     - lib/splitclient-rb/telemetry/memory/memory_synchronizer.rb
+    - lib/splitclient-rb/engine/sync_manager.rb
 
 Metrics/ClassLength:
   Max: 150
@@ -17,9 +18,10 @@ Metrics/ClassLength:
     - lib/splitclient-rb/telemetry/memory/memory_synchronizer.rb
 
 Metrics/CyclomaticComplexity:
-  Max: 8
+  Max: 11
 
 Metrics/ParameterLists:
+  Max: 8
   Exclude:
     - lib/splitclient-rb/engine/sync_manager.rb
 
@@ -32,6 +34,7 @@ Metrics/LineLength:
     - spec/engine/auth_api_client_spec.rb
     - spec/telemetry/synchronizer_spec.rb
     - spec/splitclient/split_config_spec.rb
+    - spec/engine/push_manager_spec.rb
 
 Style/BracesAroundHashParameters:
   Exclude:
@@ -65,3 +68,4 @@ AllCops:
     - spec/telemetry/synchronizer_spec.rb
     - lib/splitclient-rb/engine/synchronizer.rb
     - tmp/**/*
+    - lib/splitclient-rb/sse/event_source/client.rb

data/CHANGES.txt

@@ -1,5 +1,19 @@
 CHANGES
 
+7.3.4 (Feb 21, 2022)
+- Updated streaming events architecture with a new queue logic.
+- Fixed redis integration Pipelining command deprecation warning.
+
+7.3.3 (Jan 28, 2022)
+- Fixed edge cases where the sdk lost streaming connection.
+- Updated default auth service url to https://auth.split.io/api/v2/auth
+- Updated dependencies:
+  - faraday to  >= 0.8, < 2.0
+  - net-http-persistent to >= 2.9, < 5.0
+  - redis to >= 4.0.0, < 5.0
+  - socketry to >= 0.4, < 1.0
+  - thread_safe to ~> 0.3
+
 7.3.2 (Dec 10, 2021)
 - Updated the readiness flow to be more consistent with the other sdks and improve the readiness time.
 - Updated the name of telemety key latencies in Redis.

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright © 2021 Split Software, Inc.
+Copyright © 2022 Split Software, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/lib/splitclient-rb/cache/adapters/redis_adapter.rb

@@ -160,7 +160,7 @@ module SplitIoClient
         end
 
         def pipelined
-          @redis.pipelined do
+          @redis.pipelined do |pipeline|
             yield
           end
         end

data/lib/splitclient-rb/constants.rb

@@ -12,4 +12,5 @@ class SplitIoClient::Constants
   PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN'
   PUSH_SUBSYSTEM_READY = 'PUSH_SUBSYSTEM_READY'
   PUSH_SUBSYSTEM_OFF = 'PUSH_SUBSYSTEM_OFF'
+  PUSH_FORCED_STOP = 'PUSH_FORCED_STOP'
 end

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

@@ -6,35 +6,23 @@ module SplitIoClient
       SYNC_MODE_STREAMING = 0
       SYNC_MODE_POLLING = 1
 
-      def initialize(
-        repositories,
-        api_key,
-        config,
-        synchronizer,
-        telemetry_runtime_producer,
-        telemetry_synchronizer,
-        status_manager
-      )
-        @synchronizer = synchronizer
-        notification_manager_keeper = SSE::NotificationManagerKeeper.new(config, telemetry_runtime_producer) do |manager|
-          manager.on_action { |action| process_action(action) }
-        end
-        @sse_handler = SSE::SSEHandler.new(
-          { config: config, api_key: api_key },
-          @synchronizer,
-          repositories,
-          notification_manager_keeper,
-          telemetry_runtime_producer
-        ) do |handler|
-          handler.on_action { |action| process_action(action) }
-        end
-
-        @push_manager = PushManager.new(config, @sse_handler, api_key, telemetry_runtime_producer)
-        @sse_connected = Concurrent::AtomicBoolean.new(false)
+      def initialize(config,
+                     synchronizer,
+                     telemetry_runtime_producer,
+                     telemetry_synchronizer,
+                     status_manager,
+                     sse_handler,
+                     push_manager,
+                     status_queue)
         @config = config
+        @synchronizer = synchronizer
         @telemetry_runtime_producer = telemetry_runtime_producer
         @telemetry_synchronizer = telemetry_synchronizer
         @status_manager = status_manager
+        @sse_handler = sse_handler
+        @push_manager = push_manager
+        @status_queue = status_queue
+        @sse_connected = Concurrent::AtomicBoolean.new(false)
       end
 
       def start
@@ -55,6 +43,7 @@ module SplitIoClient
 
           if @config.streaming_enabled
             @config.logger.debug('Starting Straming mode ...')
+            start_push_status_monitor
             connected = @push_manager.start_sse
           end
 
@@ -66,27 +55,6 @@ module SplitIoClient
         end
       end
 
-      def process_action(action)
-        case action
-        when Constants::PUSH_CONNECTED
-          process_connected
-        when Constants::PUSH_RETRYABLE_ERROR
-          process_disconnect(true)
-        when Constants::PUSH_NONRETRYABLE_ERROR
-          process_disconnect(false)
-        when Constants::PUSH_SUBSYSTEM_DOWN
-          process_subsystem_down
-        when Constants::PUSH_SUBSYSTEM_READY
-          process_subsystem_ready
-        when Constants::PUSH_SUBSYSTEM_OFF
-          process_push_shutdown
-        else
-          @config.logger.debug('Incorrect action type.')
-        end
-      rescue StandardError => e
-        @config.logger.error("process_action error: #{e.inspect}")
-      end
-
       def process_subsystem_ready
         @synchronizer.stop_periodic_fetch
         @synchronizer.sync_all
@@ -124,6 +92,19 @@ module SplitIoClient
         @config.logger.error("process_connected error: #{e.inspect}")
       end
 
+      def process_forced_stop
+        unless @sse_connected.value
+          @config.logger.debug('Streaming already disconnected.')
+          return
+        end
+
+        @sse_connected.make_false
+        @synchronizer.start_periodic_fetch
+        record_telemetry(Telemetry::Domain::Constants::SYNC_MODE, SYNC_MODE_POLLING)
+      rescue StandardError => e
+        @config.logger.error("process_connected error: #{e.inspect}")
+      end
+
       def process_disconnect(reconnect)
         unless @sse_connected.value
           @config.logger.debug('Streaming already disconnected.')
@@ -147,6 +128,40 @@ module SplitIoClient
       def record_telemetry(type, data)
         @telemetry_runtime_producer.record_streaming_event(type, data)
       end
+
+      def start_push_status_monitor
+        @config.threads[:push_status_handler] = Thread.new do
+          @config.logger.debug('Starting push status handler ...') if @config.debug_enabled
+          incoming_push_status_handler
+        end
+      end
+
+      def incoming_push_status_handler
+        while (status = @status_queue.pop)
+          @config.logger.debug("Push status handler dequeue #{status}") if @config.debug_enabled
+
+          case status
+          when Constants::PUSH_CONNECTED
+            process_connected
+          when Constants::PUSH_RETRYABLE_ERROR
+            process_disconnect(true)
+          when Constants::PUSH_FORCED_STOP
+            process_forced_stop
+          when Constants::PUSH_NONRETRYABLE_ERROR
+            process_disconnect(false)
+          when Constants::PUSH_SUBSYSTEM_DOWN
+            process_subsystem_down
+          when Constants::PUSH_SUBSYSTEM_READY
+            process_subsystem_ready
+          when Constants::PUSH_SUBSYSTEM_OFF
+            process_push_shutdown
+          else
+            @config.logger.debug('Incorrect push status type.')
+          end
+        end
+      rescue StandardError => e
+        @config.logger.error("Push status handler error: #{e.inspect}")
+      end
     end
   end
 end

data/lib/splitclient-rb/split_factory.rb

@@ -33,15 +33,10 @@ module SplitIoClient
       register_factory
 
       build_telemetry_components
+      build_repositories
+      build_impressions_components
+      build_telemetry_synchronizer
 
-      @splits_repository = SplitsRepository.new(@config)
-      @segments_repository = SegmentsRepository.new(@config)
-      @impressions_repository = ImpressionsRepository.new(@config)
-      @events_repository = EventsRepository.new(@config, @api_key, @runtime_producer)
-      @impression_counter = SplitIoClient::Engine::Common::ImpressionCounter.new
-      @impressions_manager = SplitIoClient::Engine::Common::ImpressionManager.new(@config, @impressions_repository, @impression_counter, @runtime_producer)
-      @telemetry_api = SplitIoClient::Api::TelemetryApi.new(@config, @api_key, @runtime_producer)
-      @telemetry_synchronizer = Telemetry::Synchronizer.new(@config, @telemetry_consumers, @init_producer, repositories, @telemetry_api)
       @status_manager = Engine::StatusManager.new(@config)
 
       start!
@@ -59,18 +54,12 @@ module SplitIoClient
         return
       end
       
-      split_fetcher = SplitFetcher.new(@splits_repository, @api_key, config, @runtime_producer)
-      segment_fetcher = SegmentFetcher.new(@segments_repository, @api_key, config, @runtime_producer)
-      params = {
-        split_fetcher: split_fetcher,
-        segment_fetcher: segment_fetcher,
-        imp_counter: @impression_counter,
-        telemetry_runtime_producer: @runtime_producer,
-        telemetry_synchronizer: @telemetry_synchronizer
-      }
+      build_fetchers
+      build_synchronizer
+      build_streaming_components
+      build_sync_manager
 
-      synchronizer = SplitIoClient::Engine::Synchronizer.new(repositories, @api_key, @config, params)
-      SplitIoClient::Engine::SyncManager.new(repositories, @api_key, @config, synchronizer, @runtime_producer, @telemetry_synchronizer, @status_manager).start
+      @sync_manager.start
     end
 
     def stop!
@@ -166,6 +155,56 @@ module SplitIoClient
       @runtime_producer = Telemetry::RuntimeProducer.new(@config)
 
       @telemetry_consumers = { init: @init_consumer, evaluation: @evaluation_consumer, runtime: @runtime_consumer }
-    end    
+    end
+
+    def build_fetchers
+      @split_fetcher = SplitFetcher.new(@splits_repository, @api_key, @config, @runtime_producer)
+      @segment_fetcher = SegmentFetcher.new(@segments_repository, @api_key, @config, @runtime_producer)
+    end
+
+    def build_synchronizer
+      params = {
+        split_fetcher: @split_fetcher,
+        segment_fetcher: @segment_fetcher,
+        imp_counter: @impression_counter,
+        telemetry_runtime_producer: @runtime_producer,
+        telemetry_synchronizer: @telemetry_synchronizer
+      }
+
+      @synchronizer = Engine::Synchronizer.new(repositories, @api_key, @config, params)
+    end
+
+    def build_streaming_components
+      @push_status_queue = Queue.new
+      splits_worker = SSE::Workers::SplitsWorker.new(@synchronizer, @config, @splits_repository)
+      segments_worker = SSE::Workers::SegmentsWorker.new(@synchronizer, @config, @segments_repository)
+      notification_manager_keeper = SSE::NotificationManagerKeeper.new(@config, @runtime_producer, @push_status_queue)
+      notification_processor = SSE::NotificationProcessor.new(@config, splits_worker, segments_worker)
+      event_parser = SSE::EventSource::EventParser.new(config)      
+      sse_client = SSE::EventSource::Client.new(@config, @api_key, @runtime_producer, event_parser, notification_manager_keeper, notification_processor, @push_status_queue)
+      @sse_handler = SSE::SSEHandler.new(@config, splits_worker, segments_worker, sse_client)
+      @push_manager = Engine::PushManager.new(@config, @sse_handler, @api_key, @runtime_producer)
+    end
+
+    def build_sync_manager
+      @sync_manager = Engine::SyncManager.new(@config, @synchronizer, @runtime_producer, @telemetry_synchronizer, @status_manager, @sse_handler, @push_manager, @push_status_queue)
+    end
+
+    def build_repositories
+      @splits_repository = SplitsRepository.new(@config)
+      @segments_repository = SegmentsRepository.new(@config)
+      @impressions_repository = ImpressionsRepository.new(@config)
+      @events_repository = EventsRepository.new(@config, @api_key, @runtime_producer)
+    end
+
+    def build_telemetry_synchronizer
+      telemetry_api = Api::TelemetryApi.new(@config, @api_key, @runtime_producer)
+      @telemetry_synchronizer = Telemetry::Synchronizer.new(@config, @telemetry_consumers, @init_producer, repositories, telemetry_api)
+    end
+
+    def build_impressions_components
+      @impression_counter = Engine::Common::ImpressionCounter.new
+      @impressions_manager = Engine::Common::ImpressionManager.new(@config, @impressions_repository, @impression_counter, @runtime_producer)
+    end
   end
 end

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

@@ -13,29 +13,28 @@ module SplitIoClient
         KEEP_ALIVE_RESPONSE = "c\r\n:keepalive\n\n\r\n".freeze
         ERROR_EVENT_TYPE = 'error'.freeze
 
-        def initialize(config, api_key, telemetry_runtime_producer, read_timeout: DEFAULT_READ_TIMEOUT)
+        def initialize(config,
+                       api_key,
+                       telemetry_runtime_producer,
+                       event_parser,
+                       notification_manager_keeper,
+                       notification_processor,
+                       status_queue,
+                       read_timeout: DEFAULT_READ_TIMEOUT)
           @config = config
+          @api_key = api_key
+          @telemetry_runtime_producer = telemetry_runtime_producer
+          @event_parser = event_parser
+          @notification_manager_keeper = notification_manager_keeper
+          @notification_processor = notification_processor
+          @status_queue = status_queue
           @read_timeout = read_timeout
           @connected = Concurrent::AtomicBoolean.new(false)
           @first_event = Concurrent::AtomicBoolean.new(true)
           @socket = nil
-          @event_parser = SSE::EventSource::EventParser.new(config)
-          @on = { event: ->(_) {}, action: ->(_) {} }
-          @api_key = api_key
-          @telemetry_runtime_producer = telemetry_runtime_producer
-
-          yield self if block_given?
-        end
-
-        def on_event(&action)
-          @on[:event] = action
-        end
-
-        def on_action(&action)
-          @on[:action] = action
         end
 
-        def close(action = nil)
+        def close(status = nil)
           unless connected?
             @config.logger.error('SSEClient already disconected.') if @config.debug_enabled
             return
@@ -43,7 +42,7 @@ module SplitIoClient
 
           @connected.make_false
           @socket&.close
-          dispatch_action(action) unless action.nil?
+          push_status(status)
         rescue StandardError => e
           @config.logger.error("SSEClient close Error: #{e.inspect}")
         end
@@ -76,8 +75,8 @@ module SplitIoClient
         def connect_thread(latch)
           @config.threads[:connect_stream] = Thread.new do
             @config.logger.info('Starting connect_stream thread ...') if @config.debug_enabled
-            action = connect_stream(latch)
-            dispatch_action(action) unless action.nil?
+            new_status = connect_stream(latch)
+            push_status(new_status)
             @config.logger.info('connect_stream thread finished.') if @config.debug_enabled
           end
         end
@@ -132,7 +131,7 @@ module SplitIoClient
           if response_code == OK_CODE && !error_event
             @connected.make_true
             @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::SSE_CONNECTION_ESTABLISHED, nil)
-            dispatch_action(Constants::PUSH_CONNECTED)
+            push_status(Constants::PUSH_CONNECTED)
           end
 
           latch.count_down
@@ -188,15 +187,18 @@ module SplitIoClient
         end
 
         def dispatch_event(event)
-          @config.logger.debug("Dispatching event: #{event.event_type}, #{event.channel}") if @config.debug_enabled
-          @on[:event].call(event)
+          if event.occupancy?
+            @notification_manager_keeper.handle_incoming_occupancy_event(event)
+          else
+            @notification_processor.process(event)
+          end
         end
 
-        def dispatch_action(action)
-          @config.threads[:dispatch_action] = Thread.new do
-            @config.logger.debug("Dispatching action: #{action}") if @config.debug_enabled
-            @on[:action].call(action)
-          end
+        def push_status(status)
+          return if status.nil?
+          
+          @config.logger.debug("Pushing new sse status: #{status}")
+          @status_queue.push(status)
         end
       end
     end

data/lib/splitclient-rb/sse/notification_manager_keeper.rb

@@ -9,15 +9,13 @@ module SplitIoClient
       ENABLED = 1
       PAUSED = 2
 
-      def initialize(config, telemetry_runtime_producer)
+      def initialize(config, telemetry_runtime_producer, status_queue)
         @config = config
+        @telemetry_runtime_producer = telemetry_runtime_producer
+        @status_queue = status_queue
         @publisher_available = Concurrent::AtomicBoolean.new(true)
         @publishers_pri = Concurrent::AtomicFixnum.new
         @publishers_sec = Concurrent::AtomicFixnum.new
-        @on = { action: ->(_) {} }
-        @telemetry_runtime_producer = telemetry_runtime_producer
-
-        yield self if block_given?
       end
 
       def handle_incoming_occupancy_event(event)
@@ -27,27 +25,22 @@ module SplitIoClient
           process_event_occupancy(event.channel, event.data['metrics']['publishers'])
         end
       rescue StandardError => e
-        p e
         @config.logger.error(e)
       end
 
-      def on_action(&action)
-        @on[:action] = action
-      end
-
       private
 
       def process_event_control(type)
         case type
         when 'STREAMING_PAUSED'
           @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, PAUSED)
-          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
+          push_status(Constants::PUSH_SUBSYSTEM_DOWN)
         when 'STREAMING_RESUMED'
           @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, ENABLED)
-          dispatch_action(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
+          push_status(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
         when 'STREAMING_DISABLED'
           @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, DISABLED)
-          dispatch_action(Constants::PUSH_SUBSYSTEM_OFF)
+          push_status(Constants::PUSH_SUBSYSTEM_OFF)
         else
           @config.logger.error("Incorrect event type: #{incoming_notification}")
         end
@@ -60,10 +53,10 @@ module SplitIoClient
 
         if !are_publishers_available? && @publisher_available.value
           @publisher_available.make_false
-          dispatch_action(Constants::PUSH_SUBSYSTEM_DOWN)
+          push_status(Constants::PUSH_SUBSYSTEM_DOWN)
         elsif are_publishers_available? && !@publisher_available.value
           @publisher_available.make_true
-          dispatch_action(Constants::PUSH_SUBSYSTEM_READY)
+          push_status(Constants::PUSH_SUBSYSTEM_READY)
         end
       end
 
@@ -81,9 +74,9 @@ module SplitIoClient
         @publishers_pri.value.positive? || @publishers_sec.value.positive?
       end
 
-      def dispatch_action(action)
-        @config.logger.debug("Dispatching action: #{action}")
-        @on[:action].call(action)
+      def push_status(status)
+        @config.logger.debug("Pushing occupancy status: #{status}")
+        @status_queue.push(status)
       end
     end
   end

data/lib/splitclient-rb/sse/sse_handler.rb

@@ -5,33 +5,22 @@ module SplitIoClient
     class SSEHandler
       attr_reader :sse_client
 
-      def initialize(metadata,
-                     synchronizer,
-                     repositories,
-                     notification_manager_keeper,
-                     telemetry_runtime_producer)
-        @config = metadata[:config]
-        @notification_manager_keeper = notification_manager_keeper
-        @splits_worker = SplitIoClient::SSE::Workers::SplitsWorker.new(synchronizer, @config, repositories[:splits])
-        @segments_worker = SplitIoClient::SSE::Workers::SegmentsWorker.new(synchronizer, @config, repositories[:segments])
-        @notification_processor = SplitIoClient::SSE::NotificationProcessor.new(@config, @splits_worker, @segments_worker)
-        @sse_client = SSE::EventSource::Client.new(@config, metadata[:api_key], telemetry_runtime_producer) do |client|
-          client.on_event { |event| handle_incoming_message(event) }
-          client.on_action { |action| process_action(action) }
-        end
-
-        @on = { action: ->(_) {} }
-
-        yield self if block_given?
+      def initialize(config,
+                     splits_worker,
+                     segments_worker,
+                     sse_client)
+        @config = config
+        @splits_worker = splits_worker
+        @segments_worker = segments_worker
+        @sse_client = sse_client
       end
 
       def start(token_jwt, channels)
-        url = "#{@config.streaming_service_url}?channels=#{channels}&v=1.1&accessToken=#{token_jwt}"
-        @sse_client.start(url)
+        @sse_client.start("#{@config.streaming_service_url}?channels=#{channels}&v=1.1&accessToken=#{token_jwt}")
       end
 
       def stop
-        @sse_client.close(Constants::PUSH_NONRETRYABLE_ERROR)
+        @sse_client.close(Constants::PUSH_FORCED_STOP)
         stop_workers
       rescue StandardError => e
         @config.logger.debug("SSEHandler stop error: #{e.inspect}") if @config.debug_enabled
@@ -50,24 +39,6 @@ module SplitIoClient
         @splits_worker.stop
         @segments_worker.stop
       end
-
-      def on_action(&action)
-        @on[:action] = action
-      end
-
-      private
-
-      def process_action(action)
-        @on[:action].call(action)
-      end
-
-      def handle_incoming_message(notification)
-        if notification.occupancy?
-          @notification_manager_keeper.handle_incoming_occupancy_event(notification)
-        else
-          @notification_processor.process(notification)
-        end
-      end
     end
   end
 end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.3.3.pre.rc18'
+  VERSION = '7.3.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: splitclient-rb
 version: !ruby/object:Gem::Version
-  version: 7.3.3.pre.rc18
+  version: 7.3.4
 platform: ruby
 authors:
 - Split Software
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-26 00:00:00.000000000 Z
+date: 2022-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: allocation_stats
@@ -364,6 +364,7 @@ extra_rdoc_files: []
 files:
 - ".github/pull_request_template.md"
 - ".github/workflows/ci.yml"
+- ".github/workflows/update-license-year.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - ".simplecov"
@@ -519,9 +520,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.2.32
 signing_key: