rox-rollout 6.0.1 → 6.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73d64c9e8123a69712c15cada3f6c9b2642c12953a8c25250eb9963d845dae41
-  data.tar.gz: 1e14bc76699a72e0f34dc3a5039025ab184049807b930a2c0fa407915c5380b1
+  metadata.gz: bffb064d1154d2a9a765e1cd7592cabaf2433c385945694f7373a62ddf6b052f
+  data.tar.gz: 682bc11092f95c2a1ac04a4daac434316f8cbf93ee897f60738117d2d5a932a3
 SHA512:
-  metadata.gz: a615f9162c302b51d2359d0bc645fa1965a0d28c556678ee7e8a471cc7d1e5cbfef1ca73b06aaaaa91335665c30309286747c31e3930ad4d09fb4547936f1e53
-  data.tar.gz: c92c4de2381d270ab77dfc543efe00eaa0182d217a0e1e792a5934c58d8cf1c9f0e8d22138839dfd3d63c0ca434835cb8eabe28fdc76a3335bb4e7867da09a44
+  metadata.gz: 772253981c9790addeb0995d564053493c70db175a8404c9e7200a2521206f801e11c1c44327b6cd2d03cf4db4d7e84007d10139ff57893b17a8bbcf50ce621b
+  data.tar.gz: b9941e8442d8d66bd91373d5f076a24a92da617798af776d46c99e11f000d338fef6186bcbc642107af80e59d88c47e094053bf191912e9a06ff6938c0220f16

data/e2e-server/run_server.sh

@@ -7,7 +7,7 @@ DIR=`pwd`
 gem install sinatra --conservative
 gem install sinatra-contrib --conservative
 gem install json --conservative
-gem install em-eventsource --conservative
+gem install server_sent_events --conservative
 gem install rackup
 gem install webrick
 

data/lib/rox/core/core.rb

@@ -201,7 +201,8 @@ module Rox
       def start_or_stop_push_updated_listener
         if @internal_flags.enabled?('rox.internal.pushUpdates')
           if @push_updates_listener.nil?
-            @push_updates_listener = NotificationListener.new(Environment.notifications_path, @sdk_settings.api_key)
+            logger = @rox_options&.logger
+            @push_updates_listener = NotificationListener.new(Environment.notifications_path, @sdk_settings.api_key, logger: logger)
             @push_updates_listener.on 'changed' do |_data|
               fetch
             end

data/lib/rox/core/notifications/notification_listener.rb

@@ -1,12 +1,61 @@
-require 'em-eventsource'
+require 'server_sent_events'
+require 'net/http'
+require 'uri'
 
 module Rox
   module Core
     class NotificationListener
-      def initialize(listen_url, app_key)
+      # Initial reconnection delay in seconds (SSE spec recommends "a few seconds")
+      INITIAL_RECONNECT_DELAY = 3
+      # Maximum reconnection delay in seconds
+      MAX_RECONNECT_DELAY = 60
+      # Reconnection backoff multiplier
+      RECONNECT_MULTIPLIER = 2
+      # Jitter percentage to prevent thundering herd (±20%)
+      JITTER_FACTOR = 0.2
+
+      # Extended SSE Client that adds proper headers and timeout configuration
+      # The base ServerSentEvents::Client lacks these features
+      class SSEClient < ServerSentEvents::Client
+        def initialize(address, parser, open_timeout: 10, read_timeout: nil)
+          super(address, parser)
+          @open_timeout = open_timeout
+          @read_timeout = read_timeout
+        end
+
+        def listen(&block)
+          Net::HTTP.start(
+            @address.host,
+            @address.port,
+            use_ssl: @address.scheme == 'https',
+            open_timeout: @open_timeout,
+            read_timeout: @read_timeout
+          ) do |http|
+            request = Net::HTTP::Get.new(@address)
+            request['Accept'] = 'text/event-stream'
+            request['Cache-Control'] = 'no-cache'
+
+            http.request(request) do |response|
+              unless response.code == '200'
+                raise "HTTP #{response.code}: #{response.message}"
+              end
+
+              response.read_body do |chunk|
+                @parser.push(chunk).each { |event| block.call(event) }
+              end
+            end
+          end
+        end
+      end
+
+      def initialize(listen_url, app_key, logger: nil)
         @listen_url = listen_url
         @app_key = app_key
         @handlers = {}
+        @logger = logger
+        @thread = nil
+        @running = false
+        @reconnect_delay = INITIAL_RECONNECT_DELAY
       end
 
       def on(event_name, &handler)
@@ -15,31 +64,113 @@ module Rox
       end
 
       def start
+        return if @running
+
+        @running = true
         sse_url = "#{@listen_url.chomp('/')}/#{@app_key}"
+
         @thread = Thread.new do
-          EM.run do
-            source = EventMachine::EventSource.new(sse_url)
-            @handlers.each do |event_name, event_handlers|
-              event_handlers.each do |handler|
-                source.on event_name do |data|
-                  # Start new thread to allow the handler to stop the Listener (terminate the current thread)
-                  # and continue handler code execution without interruption
-                  handler_thread = Thread.new do
-                    handler.call(data)
-                  end
-                  handler_thread.join
-                end
-              end
-            end
-            source.start
-          end
+          connect_with_retry(sse_url)
         end
       end
 
       def stop
+        @running = false
         @thread&.terminate
         @thread = nil
       end
+
+      private
+
+      def calculate_reconnect_delay
+        # Use current delay, capped at maximum
+        base_delay = [@reconnect_delay, MAX_RECONNECT_DELAY].min
+
+        # Add jitter: ±20% randomness to prevent thundering herd
+        # Example: 3s becomes 2.4s - 3.6s
+        # This spreads out reconnection attempts across clients
+        jitter = rand(-JITTER_FACTOR..JITTER_FACTOR) * base_delay
+        final_delay = base_delay + jitter
+
+        # Never less than 1 second
+        [final_delay, 1.0].max
+      end
+
+      def connect_with_retry(sse_url)
+        while @running
+          begin
+            log_info("Connecting to SSE endpoint: #{sse_url}")
+            connect_to_sse(sse_url)
+
+            # Connection closed normally - reset to initial delay
+            break unless @running
+            @reconnect_delay = INITIAL_RECONNECT_DELAY
+
+          rescue => e
+            break unless @running
+            log_error("SSE connection error: #{e.class} - #{e.message}")
+
+            # On error, use exponential backoff for next attempt
+            @reconnect_delay = [@reconnect_delay * RECONNECT_MULTIPLIER, MAX_RECONNECT_DELAY].min
+          end
+
+          # ALWAYS delay before reconnecting (both normal close and error cases)
+          # This matches em-eventsource behavior which waits ~3s regardless of close reason
+          delay = calculate_reconnect_delay
+          log_info("Reconnecting in #{delay.round(1)} seconds...")
+          sleep(delay)
+        end
+      end
+
+      def connect_to_sse(sse_url)
+        uri = URI(sse_url)
+
+        # Create SSE client using the library's client with our extensions
+        client = SSEClient.new(
+          uri,
+          ServerSentEvents::Parser.new,
+          open_timeout: 10,      # 10 seconds to establish connection
+          read_timeout: nil      # No timeout for reading (SSE is long-lived)
+        )
+
+        log_info("Connected to SSE endpoint")
+        @reconnect_delay = INITIAL_RECONNECT_DELAY
+
+        # Use the library's listen method to handle connection and parsing
+        client.listen do |event|
+          break unless @running
+          handle_event(event)
+        end
+      end
+
+      def handle_event(event)
+        # Get event type (default to 'message' if not specified)
+        event_type = event.event || 'message'
+
+        # Call registered handlers for this event type
+        handlers = @handlers[event_type]
+        return unless handlers
+
+        handlers.each do |handler|
+          begin
+            # Execute handler in a new thread to allow it to call stop() without blocking
+            handler_thread = Thread.new do
+              handler.call(event.data)
+            end
+            handler_thread.join
+          rescue => e
+            log_error("Error in event handler: #{e.class} - #{e.message}")
+          end
+        end
+      end
+
+      def log_info(message)
+        @logger&.info("[NotificationListener] #{message}")
+      end
+
+      def log_error(message)
+        @logger&.error("[NotificationListener] #{message}")
+      end
     end
   end
 end

data/lib/rox/version.rb

@@ -1,3 +1,3 @@
 module Rox
-  VERSION = '6.0.1'.freeze
+  VERSION = '6.0.2'.freeze
 end

data/rox.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.5'
 
-  spec.add_runtime_dependency 'em-eventsource', '~> 0.3.2'
+  spec.add_runtime_dependency 'server_sent_events', '~> 0.1.3'
 
   spec.add_development_dependency 'bundler', '~> 2.4'
   spec.add_development_dependency 'minitest', '~> 5.20'

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rox-rollout
 version: !ruby/object:Gem::Version
-  version: 6.0.1
+  version: 6.0.2
 platform: ruby
 authors:
 - CloudBees
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-27 00:00:00.000000000 Z
+date: 2026-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: em-eventsource
+  name: server_sent_events
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.1.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement