forest_admin_datasource_rpc 1.17.0 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eddd5bbee08cd80c2df623bc125cfd1c93b5995c7cba4f64b0b4a53a93f7708
-  data.tar.gz: 8a57971769da080a8e5a3b030cb7da212665a47054d7fb558d60bf8d0d09b688
+  metadata.gz: 9485d38ceffa876811869166eb3b74209f0c1a9807c4a2b3571b1271a552d428
+  data.tar.gz: 4dff025fcea11c17531f412b37ae13dfa68485484aa74fd7ccfcf5c3b11fc829
 SHA512:
-  metadata.gz: b4b009428c7020b88a55b2673e4f2fc34d11712cb7c710868a3e745f7b1d527d2f2df61e9fbd7a4bf1b70873dc2d5a6358fc85e575f4013f69e9d97b4d3d5ea9
-  data.tar.gz: f5052e0d5d2e38572dc15730404ab4ef6d2bdfa75b8733aadffa77566e3c7585a3ec8e779d077be6aa106c78ab762b65dae2adb7d245cc7d5569b4c580f4c5a0
+  metadata.gz: d0212c1ab3221ddc96ab35dbe789e362108cdb2d48cad36c47b47920545f9d55df998dc55bf94f8f6779f2b8174ca2fcb0e40817d39e7c24f8337ecfc5c9f092
+  data.tar.gz: 20246dff2afeae14a3d2e8b7aed1dc64f5179b1254fb3bfe8f9ea3c5e585b312d82a85b04ccd6ba78ae4486a650be63fb53f12f65c6a83bdf9343f46682f8c3d

data/forest_admin_datasource_rpc.gemspec

@@ -36,7 +36,6 @@ admin work on any Ruby application."
   spec.add_dependency "bigdecimal"
   spec.add_dependency "csv"
   spec.add_dependency "faraday", "~> 2.7"
-  spec.add_dependency "ld-eventsource", "~> 2.2"
   spec.add_dependency "mutex_m"
   spec.add_dependency "ostruct"
   spec.add_dependency "zeitwerk", "~> 2.3"

data/lib/forest_admin_datasource_rpc/Utils/rpc_client.rb

@@ -56,6 +56,8 @@ module ForestAdminDatasourceRpc
 
       # rubocop:disable Metrics/ParameterLists
       def make_request(endpoint, caller: nil, method: :get, payload: nil, symbolize_keys: false, if_none_match: nil)
+        log_request_start(method, endpoint, if_none_match)
+
         client = Faraday.new(url: @api_url) do |faraday|
           faraday.request :json
           faraday.response :json, parser_options: { symbolize_names: symbolize_keys }
@@ -75,7 +77,9 @@ module ForestAdminDatasourceRpc
         headers['forest_caller'] = caller.to_json if caller
         headers['If-None-Match'] = %("#{if_none_match}") if if_none_match
 
-        client.send(method, endpoint, payload, headers)
+        response = client.send(method, endpoint, payload, headers)
+        log_request_complete(response, endpoint)
+        response
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -91,7 +95,14 @@ module ForestAdminDatasourceRpc
       end
 
       def handle_response_with_etag(response)
-        return SchemaResponse.new(response.body, extract_etag(response)) if response.success?
+        if response.success?
+          etag = extract_etag(response)
+          ForestAdminAgent::Facades::Container.logger&.log(
+            'Debug',
+            "[RPC Client] Schema response received (status: #{response.status}, ETag: #{etag || "none"})"
+          )
+          return SchemaResponse.new(response.body, etag)
+        end
         return NotModified if response.status == HTTP_NOT_MODIFIED
 
         raise_appropriate_error(response)
@@ -108,6 +119,11 @@ module ForestAdminDatasourceRpc
         url = response.env.url
         message = error_body[:message] || generate_default_message(status, url)
 
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Error',
+          "[RPC Client] Request failed (status: #{status}, URL: #{url}, message: #{message})"
+        )
+
         exception_class = ERROR_STATUS_MAP[status]
 
         if exception_class
@@ -143,6 +159,21 @@ module ForestAdminDatasourceRpc
           name: hash['name'] || hash[:name]
         }.compact
       end
+
+      def log_request_start(method, endpoint, if_none_match)
+        etag_info = if_none_match ? " (If-None-Match: #{if_none_match})" : ''
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Debug',
+          "[RPC Client] Sending #{method.to_s.upcase} request to #{@api_url}#{endpoint}#{etag_info}"
+        )
+      end
+
+      def log_request_complete(response, endpoint)
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Debug',
+          "[RPC Client] Response received (status: #{response.status}, endpoint: #{endpoint})"
+        )
+      end
     end
   end
 end

data/lib/forest_admin_datasource_rpc/Utils/schema_polling_client.rb

@@ -0,0 +1,219 @@
+require 'openssl'
+require 'json'
+require 'time'
+
+module ForestAdminDatasourceRpc
+  module Utils
+    class SchemaPollingClient
+      attr_reader :closed
+
+      DEFAULT_POLLING_INTERVAL = 600 # seconds (10 minutes)
+      MIN_POLLING_INTERVAL = 1 # seconds (minimum safe interval)
+      MAX_POLLING_INTERVAL = 3600 # seconds (1 hour max)
+
+      def initialize(uri, auth_secret, options = {}, &on_schema_change)
+        @uri = uri
+        @auth_secret = auth_secret
+        @polling_interval = options[:polling_interval] || DEFAULT_POLLING_INTERVAL
+        @on_schema_change = on_schema_change
+        @closed = false
+        @cached_etag = nil
+        @polling_thread = nil
+        @mutex = Mutex.new
+        @connection_attempts = 0
+
+        # Validate polling interval
+        validate_polling_interval!
+
+        # RPC client for schema fetching with ETag support
+        @rpc_client = RpcClient.new(@uri, @auth_secret)
+      end
+
+      def start
+        return if @closed
+
+        @mutex.synchronize do
+          return if @polling_thread&.alive?
+
+          @polling_thread = Thread.new do
+            polling_loop
+          rescue StandardError => e
+            ForestAdminAgent::Facades::Container.logger&.log(
+              'Error',
+              "[Schema Polling] Unexpected error in polling loop: #{e.class} - #{e.message}"
+            )
+          end
+        end
+
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Info',
+          "[Schema Polling] Polling started (interval: #{@polling_interval}s)"
+        )
+      end
+
+      def stop
+        return if @closed
+
+        @closed = true
+        ForestAdminAgent::Facades::Container.logger&.log('Debug', '[Schema Polling] Stopping polling')
+
+        @mutex.synchronize do
+          if @polling_thread&.alive?
+            @polling_thread.kill
+            @polling_thread = nil
+          end
+        end
+
+        ForestAdminAgent::Facades::Container.logger&.log('Debug', '[Schema Polling] Polling stopped')
+      end
+
+      private
+
+      def polling_loop
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Debug',
+          "[Schema Polling] Starting polling loop (interval: #{@polling_interval}s)"
+        )
+
+        loop do
+          break if @closed
+
+          begin
+            check_schema
+          rescue StandardError => e
+            handle_error(e)
+          end
+
+          # Sleep with interrupt check (check every second for early termination)
+          ForestAdminAgent::Facades::Container.logger&.log(
+            'Debug',
+            "[Schema Polling] Waiting #{@polling_interval}s before next check (current ETag: #{@cached_etag || "none"})"
+          )
+          remaining = @polling_interval
+          while remaining.positive? && !@closed
+            sleep([remaining, 1].min)
+            remaining -= 1
+          end
+        end
+      end
+
+      def check_schema
+        @connection_attempts += 1
+        log_checking_schema
+
+        result = @rpc_client.fetch_schema('/forest/rpc-schema', if_none_match: @cached_etag)
+        handle_schema_result(result)
+      rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+        log_connection_error(e)
+      rescue ForestAdminAgent::Http::Exceptions::AuthenticationOpenIdClient => e
+        log_authentication_error(e)
+      rescue StandardError => e
+        log_unexpected_error(e)
+      end
+
+      def handle_error(error)
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Error',
+          "[Schema Polling] Error during schema check: #{error.class} - #{error.message}"
+        )
+      end
+
+      def trigger_schema_change_callback(schema)
+        return unless @on_schema_change
+
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Debug',
+          '[Schema Polling] Invoking schema change callback'
+        )
+        begin
+          @on_schema_change.call(schema)
+          ForestAdminAgent::Facades::Container.logger&.log(
+            'Debug',
+            '[Schema Polling] Schema change callback completed successfully'
+          )
+        rescue StandardError => e
+          error_msg = "[Schema Polling] Error in schema change callback: #{e.class} - #{e.message}"
+          backtrace = "\n#{e.backtrace&.first(5)&.join("\n")}"
+          ForestAdminAgent::Facades::Container.logger&.log('Error', error_msg + backtrace)
+        end
+      end
+
+      def log_checking_schema
+        etag_info = @cached_etag ? "with ETag: #{@cached_etag}" : 'without ETag (initial fetch)'
+        msg = "[Schema Polling] Checking schema from #{@uri}/forest/rpc-schema " \
+              "(attempt ##{@connection_attempts}, #{etag_info})"
+        ForestAdminAgent::Facades::Container.logger&.log('Debug', msg)
+      end
+
+      def handle_schema_result(result)
+        if result == RpcClient::NotModified
+          handle_schema_unchanged
+        else
+          handle_schema_changed(result)
+        end
+      end
+
+      def handle_schema_unchanged
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Debug',
+          "[Schema Polling] Schema unchanged (HTTP 304 Not Modified), ETag still valid: #{@cached_etag}"
+        )
+        @connection_attempts = 0
+      end
+
+      def handle_schema_changed(result)
+        new_etag = result.etag
+        @cached_etag.nil? ? handle_initial_schema(new_etag) : handle_schema_update(result.body, new_etag)
+        @connection_attempts = 0
+      end
+
+      def handle_initial_schema(etag)
+        @cached_etag = etag
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Debug',
+          "[Schema Polling] Initial schema loaded successfully (ETag: #{etag})"
+        )
+      end
+
+      def handle_schema_update(schema, etag)
+        old_etag = @cached_etag
+        @cached_etag = etag
+        msg = "[Schema Polling] Schema changed detected (old ETag: #{old_etag}, new ETag: #{etag}), " \
+              'triggering reload callback'
+        ForestAdminAgent::Facades::Container.logger&.log('Info', msg)
+        trigger_schema_change_callback(schema)
+      end
+
+      def log_connection_error(error)
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Warn',
+          "[Schema Polling] Connection error: #{error.class} - #{error.message}"
+        )
+      end
+
+      def log_authentication_error(error)
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Error',
+          "[Schema Polling] Authentication error: #{error.message}"
+        )
+      end
+
+      def log_unexpected_error(error)
+        ForestAdminAgent::Facades::Container.logger&.log(
+          'Error',
+          "[Schema Polling] Unexpected error: #{error.class} - #{error.message}"
+        )
+      end
+
+      def validate_polling_interval!
+        if @polling_interval < MIN_POLLING_INTERVAL
+          raise ArgumentError,
+                "Schema polling interval too short: #{@polling_interval}s (minimum: #{MIN_POLLING_INTERVAL}s)"
+        elsif @polling_interval > MAX_POLLING_INTERVAL
+          raise ArgumentError,
+                "Schema polling interval too long: #{@polling_interval}s (maximum: #{MAX_POLLING_INTERVAL}s)"
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_rpc/datasource.rb

@@ -2,7 +2,7 @@ module ForestAdminDatasourceRpc
   class Datasource < ForestAdminDatasourceToolkit::Datasource
     include ForestAdminDatasourceRpc::Utils
 
-    def initialize(options, introspection, sse_client = nil)
+    def initialize(options, introspection, schema_polling_client = nil)
       super()
 
       ForestAdminAgent::Facades::Container.logger.log(
@@ -18,7 +18,7 @@ module ForestAdminDatasourceRpc
       @options = options
       @charts = introspection[:charts]
       @rpc_relations = introspection[:rpc_relations]
-      @sse_client = sse_client
+      @schema_polling_client = schema_polling_client
       @cleaned_up = false
 
       native_query_connections = introspection[:native_query_connections] || []
@@ -58,10 +58,10 @@ module ForestAdminDatasourceRpc
 
       @cleaned_up = true
 
-      if @sse_client
-        ForestAdminAgent::Facades::Container.logger&.log('Info', '[RPCDatasource] Closing SSE connection...')
-        @sse_client.close
-        ForestAdminAgent::Facades::Container.logger&.log('Info', '[RPCDatasource] SSE connection closed')
+      if @schema_polling_client
+        ForestAdminAgent::Facades::Container.logger&.log('Info', '[RPCDatasource] Stopping schema polling...')
+        @schema_polling_client.stop
+        ForestAdminAgent::Facades::Container.logger&.log('Info', '[RPCDatasource] Schema polling stopped')
       end
     rescue StandardError => e
       ForestAdminAgent::Facades::Container.logger&.log(

data/lib/forest_admin_datasource_rpc/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceRpc
-  VERSION = "1.17.0"
+  VERSION = "1.18.0"
 end

data/lib/forest_admin_datasource_rpc.rb

@@ -8,20 +8,30 @@ loader.setup
 module ForestAdminDatasourceRpc
   class Error < StandardError; end
 
+  # Build a RPC datasource with schema polling enabled.
+  #
+  # @param options [Hash] Configuration options
+  # @option options [String] :uri The URI of the RPC agent
+  # @option options [String] :auth_secret The authentication secret (optional, will use cache if not provided)
+  # @option options [Integer] :schema_polling_interval Polling interval in seconds (optional)
+  #   - Default: 600 seconds (10 minutes)
+  #   - Can be overridden with ENV['SCHEMA_POLLING_INTERVAL']
+  #   - Valid range: 1-3600 seconds
+  #   - Priority: options[:schema_polling_interval] > ENV['SCHEMA_POLLING_INTERVAL'] > default
+  #   - Example: SCHEMA_POLLING_INTERVAL=30 for development (30 seconds)
+  #
+  # @return [ForestAdminDatasourceRpc::Datasource] The configured datasource with schema polling
   def self.build(options)
     uri = options[:uri]
     auth_secret = options[:auth_secret] || ForestAdminAgent::Facades::Container.cache(:auth_secret)
     ForestAdminAgent::Facades::Container.logger.log('Info', "Getting schema from RPC agent on #{uri}.")
 
     schema = nil
-    cached_etag = nil
 
     begin
       rpc_client = Utils::RpcClient.new(uri, auth_secret)
       response = rpc_client.fetch_schema('/forest/rpc-schema')
       schema = response.body
-      # Use the ETag header for conditional requests
-      cached_etag = response.etag
     rescue Faraday::ConnectionFailed => e
       ForestAdminAgent::Facades::Container.logger.log(
         'Error',
@@ -48,27 +58,31 @@ module ForestAdminDatasourceRpc
       # return empty datasource for not breaking stack
       ForestAdminDatasourceToolkit::Datasource.new
     else
-      sse = Utils::SseClient.new("#{uri}/forest/sse", auth_secret) do
-        ForestAdminAgent::Facades::Container.logger.log('Info', 'RPC server stopped, checking schema...')
+      # Create schema polling client with configurable polling interval
+      # Priority: options[:schema_polling_interval] > ENV['SCHEMA_POLLING_INTERVAL'] > default (600)
+      polling_interval = if options[:schema_polling_interval]
+                           options[:schema_polling_interval]
+                         elsif ENV['SCHEMA_POLLING_INTERVAL']
+                           ENV['SCHEMA_POLLING_INTERVAL'].to_i
+                         else
+                           600 # 10 minutes by default
+                         end
 
-        # Send If-None-Match header to check if schema has changed (304 optimization)
-        result = rpc_client.fetch_schema('/forest/rpc-schema', if_none_match: cached_etag)
+      polling_options = {
+        polling_interval: polling_interval
+      }
 
-        # If we get NotModified, schema hasn't changed
-        if result == Utils::RpcClient::NotModified
-          ForestAdminAgent::Facades::Container.logger.log('Debug', '[RPCDatasource] Schema has not changed (304)')
-        else
-          # Schema has changed, update the cached ETag and schema, then reload
-          cached_etag = result.etag
-          ForestAdminAgent::Facades::Container.logger.log('Info', '[RPCDatasource] Schema changed, reloading agent...')
-          ForestAdminAgent::Builder::AgentFactory.instance.reload!
-        end
+      schema_polling = Utils::SchemaPollingClient.new(uri, auth_secret, polling_options) do
+        # Callback when schema change is detected
+        logger = ForestAdminAgent::Facades::Container.logger
+        logger.log('Info', '[RPCDatasource] Schema change detected, reloading agent...')
+        ForestAdminAgent::Builder::AgentFactory.instance.reload!
       end
-      sse.start
+      schema_polling.start
 
-      datasource = ForestAdminDatasourceRpc::Datasource.new(options, schema, sse)
+      datasource = ForestAdminDatasourceRpc::Datasource.new(options, schema, schema_polling)
 
-      # Setup cleanup hooks for proper SSE client shutdown
+      # Setup cleanup hooks for proper schema polling client shutdown
       setup_cleanup_hooks(datasource)
 
       datasource

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_rpc
 version: !ruby/object:Gem::Version
-  version: 1.17.0
+  version: 1.18.0
 platform: ruby
 authors:
 - Matthieu
@@ -67,20 +67,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.7'
-- !ruby/object:Gem::Dependency
-  name: ld-eventsource
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: mutex_m
   requirement: !ruby/object:Gem::Requirement
@@ -139,7 +125,7 @@ files:
 - forest_admin_datasource_rpc.gemspec
 - lib/forest_admin_datasource_rpc.rb
 - lib/forest_admin_datasource_rpc/Utils/rpc_client.rb
-- lib/forest_admin_datasource_rpc/Utils/sse_client.rb
+- lib/forest_admin_datasource_rpc/Utils/schema_polling_client.rb
 - lib/forest_admin_datasource_rpc/collection.rb
 - lib/forest_admin_datasource_rpc/datasource.rb
 - lib/forest_admin_datasource_rpc/version.rb

data/lib/forest_admin_datasource_rpc/Utils/sse_client.rb

@@ -1,212 +0,0 @@
-require 'openssl'
-require 'json'
-require 'time'
-require 'ld-eventsource'
-
-module ForestAdminDatasourceRpc
-  module Utils
-    class SseClient
-      attr_reader :closed
-
-      MAX_BACKOFF_DELAY = 30 # seconds
-      INITIAL_BACKOFF_DELAY = 2 # seconds
-
-      def initialize(uri, auth_secret, &on_rpc_stop)
-        @uri = uri
-        @auth_secret = auth_secret
-        @on_rpc_stop = on_rpc_stop
-        @client = nil
-        @closed = false
-        @connection_attempts = 0
-        @reconnect_thread = nil
-        @connecting = false
-      end
-
-      def start
-        return if @closed
-
-        attempt_connection
-      end
-
-      def close
-        return if @closed
-
-        @closed = true
-        ForestAdminAgent::Facades::Container.logger&.log('Debug', '[SSE Client] Closing connection')
-
-        # Stop reconnection thread if running
-        if @reconnect_thread&.alive?
-          @reconnect_thread.kill
-          @reconnect_thread = nil
-        end
-
-        begin
-          @client&.close
-        rescue StandardError => e
-          ForestAdminAgent::Facades::Container.logger&.log('Debug',
-                                                           "[SSE Client] Error during close: #{e.message}")
-        end
-
-        ForestAdminAgent::Facades::Container.logger&.log('Debug', '[SSE Client] Connection closed')
-      end
-
-      private
-
-      def attempt_connection
-        return if @closed
-        return if @connecting
-
-        @connecting = true
-        @connection_attempts += 1
-        timestamp = Time.now.utc.iso8601(3)
-        signature = generate_signature(timestamp)
-
-        headers = {
-          'Accept' => 'text/event-stream',
-          'X_TIMESTAMP' => timestamp,
-          'X_SIGNATURE' => signature
-        }
-
-        ForestAdminAgent::Facades::Container.logger&.log(
-          'Debug',
-          "[SSE Client] Connecting to #{@uri} (attempt ##{@connection_attempts})"
-        )
-
-        begin
-          # Close existing client if any
-          begin
-            @client&.close
-          rescue StandardError
-            # Ignore close errors
-          end
-
-          @client = SSE::Client.new(@uri, headers: headers) do |client|
-            client.on_event do |event|
-              handle_event(event)
-            end
-
-            client.on_error do |err|
-              handle_error_with_reconnect(err)
-            end
-          end
-
-          ForestAdminAgent::Facades::Container.logger&.log('Debug', '[SSE Client] Connected successfully')
-        rescue StandardError => e
-          ForestAdminAgent::Facades::Container.logger&.log(
-            'Error',
-            "[SSE Client] Failed to connect: #{e.class} - #{e.message}"
-          )
-          @connecting = false
-          schedule_reconnect
-        end
-      end
-
-      def handle_error_with_reconnect(err)
-        # Ignore errors when client is intentionally closed
-        return if @closed
-
-        is_auth_error = false
-        log_level = 'Warn'
-
-        error_message = case err
-                        when SSE::Errors::HTTPStatusError
-                          # Extract more details from HTTP errors
-                          status = err.respond_to?(:status) ? err.status : 'unknown'
-                          body = err.respond_to?(:body) && !err.body.to_s.strip.empty? ? err.body : 'empty response'
-                          is_auth_error = status.to_s =~ /^(401|403)$/
-
-                          # Auth errors during reconnection are expected (server shutdown or credentials expiring)
-                          log_level = 'Debug' if is_auth_error
-
-                          "HTTP #{status} - #{body}"
-                        when EOFError, IOError
-                          # Connection lost is expected when server stops
-                          log_level = 'Debug'
-                          "Connection lost: #{err.class}"
-                        when StandardError
-                          "#{err.class} - #{err.message}"
-                        else
-                          err.to_s
-                        end
-
-        ForestAdminAgent::Facades::Container.logger&.log(log_level, "[SSE Client] Error: #{error_message}")
-
-        # Close client immediately to prevent ld-eventsource from reconnecting with stale credentials
-        begin
-          @client&.close
-        rescue StandardError
-          # Ignore close errors
-        end
-
-        # Reset connecting flag and schedule reconnection
-        @connecting = false
-
-        # For auth errors, increase attempt count to get longer backoff
-        @connection_attempts += 2 if is_auth_error
-
-        schedule_reconnect
-      end
-
-      def schedule_reconnect
-        return if @closed
-        return if @reconnect_thread&.alive?
-
-        @reconnect_thread = Thread.new do
-          delay = calculate_backoff_delay
-          ForestAdminAgent::Facades::Container.logger&.log(
-            'Debug',
-            "[SSE Client] Reconnecting in #{delay} seconds..."
-          )
-          sleep(delay)
-          attempt_connection unless @closed
-        end
-      end
-
-      def calculate_backoff_delay
-        # Exponential backoff: 1, 2, 4, 8, 16, 30, 30, ...
-        delay = INITIAL_BACKOFF_DELAY * (2**[@connection_attempts - 1, 0].max)
-        [delay, MAX_BACKOFF_DELAY].min
-      end
-
-      def handle_event(event)
-        type = event.type.to_s.strip
-        data = event.data.to_s.strip
-
-        case type
-        when 'heartbeat'
-          if @connecting
-            @connecting = false
-            @connection_attempts = 0
-            ForestAdminAgent::Facades::Container.logger&.log('Debug', '[SSE Client] Connection stable')
-          end
-        when 'RpcServerStop'
-          ForestAdminAgent::Facades::Container.logger&.log('Debug', '[SSE Client] RpcServerStop received')
-          handle_rpc_stop
-        else
-          ForestAdminAgent::Facades::Container.logger&.log(
-            'Debug',
-            "[SSE Client] Unknown event: #{type} with payload: #{data}"
-          )
-        end
-      rescue StandardError => e
-        ForestAdminAgent::Facades::Container.logger&.log(
-          'Error',
-          "[SSE Client] Error handling event: #{e.class} - #{e.message}"
-        )
-      end
-
-      def handle_rpc_stop
-        @on_rpc_stop&.call
-      rescue StandardError => e
-        ForestAdminAgent::Facades::Container.logger&.log(
-          'Error',
-          "[SSE Client] Error in RPC stop callback: #{e.class} - #{e.message}"
-        )
-      end
-
-      def generate_signature(timestamp)
-        OpenSSL::HMAC.hexdigest('SHA256', @auth_secret, timestamp)
-      end
-    end
-  end
-end