forest_admin_datasource_rpc 1.16.10 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c76facc94fe343ca29176a93b36f2a85b1d9e90f33c9d2e9a8300e0c1ff824c8
-  data.tar.gz: f47529d4767faf8ec9aaf7fe3c3863e26c092a526fc1c99fc6596fd8931ff235
+  metadata.gz: 9485d38ceffa876811869166eb3b74209f0c1a9807c4a2b3571b1271a552d428
+  data.tar.gz: 4dff025fcea11c17531f412b37ae13dfa68485484aa74fd7ccfcf5c3b11fc829
 SHA512:
-  metadata.gz: dd67fcda71f0307b651d1bb00c98ac03ac184ec9717f623394f3865680497220bc9558b10501aa9052ecf7ca7d94c0fac5f0486e5f1fc5c6f5e61ce0848a4351
-  data.tar.gz: 2a6d7cd793499fffb01ab99c75f5fbec550aef76b71aeeb82dd582cbd1f0274ef4f40ccb1080c364c58687d9451eea7170d453e8fa7c570bf32c0ff0a2cbf6ab
+  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

@@ -5,20 +5,17 @@ require 'time'
 
 module ForestAdminDatasourceRpc
   module Utils
+    # Response wrapper for schema requests that need ETag
+    class SchemaResponse
+      attr_reader :body, :etag
+
+      def initialize(body, etag = nil)
+        @body = body
+        @etag = etag
+      end
+    end
+
     class RpcClient
-      # RpcClient handles HTTP communication with the RPC Agent.
-      #
-      # Error Handling:
-      # When the RPC agent returns an error, this client automatically maps HTTP status codes
-      # to appropriate Forest Admin exception types. This ensures business errors from the
-      # RPC agent are properly propagated to the datasource_rpc.
-      #
-      # To add support for a new error type:
-      # 1. Add the status code and exception class to ERROR_STATUS_MAP
-      # 2. (Optional) Add a default message to generate_default_message method
-      # 3. Tests will automatically cover the new mapping
-
-      # Map HTTP status codes to Forest Admin exception classes
       ERROR_STATUS_MAP = {
         400 => ForestAdminAgent::Http::Exceptions::ValidationError,
         401 => ForestAdminAgent::Http::Exceptions::AuthenticationOpenIdClient,
@@ -28,12 +25,39 @@ module ForestAdminDatasourceRpc
         422 => ForestAdminAgent::Http::Exceptions::UnprocessableError
       }.freeze
 
+      DEFAULT_ERROR_MESSAGES = {
+        400 => 'Bad Request', 401 => 'Unauthorized', 403 => 'Forbidden',
+        404 => 'Not Found', 409 => 'Conflict', 422 => 'Unprocessable Entity'
+      }.freeze
+
+      HTTP_NOT_MODIFIED = 304
+      NotModified = Class.new
+
       def initialize(api_url, auth_secret)
         @api_url = api_url
         @auth_secret = auth_secret
       end
 
-      def call_rpc(endpoint, caller: nil, method: :get, payload: nil, symbolize_keys: false)
+      # rubocop:disable Metrics/ParameterLists
+      def call_rpc(endpoint, caller: nil, method: :get, payload: nil, symbolize_keys: false, if_none_match: nil)
+        response = make_request(endpoint, caller: caller, method: method, payload: payload,
+                                          symbolize_keys: symbolize_keys, if_none_match: if_none_match)
+        handle_response(response)
+      end
+
+      # rubocop:enable Metrics/ParameterLists
+
+      def fetch_schema(endpoint, if_none_match: nil)
+        response = make_request(endpoint, method: :get, symbolize_keys: true, if_none_match: if_none_match)
+        handle_response_with_etag(response)
+      end
+
+      private
+
+      # 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 }
@@ -51,22 +75,42 @@ module ForestAdminDatasourceRpc
         }
 
         headers['forest_caller'] = caller.to_json if caller
+        headers['If-None-Match'] = %("#{if_none_match}") if if_none_match
 
         response = client.send(method, endpoint, payload, headers)
-
-        handle_response(response)
+        log_request_complete(response, endpoint)
+        response
       end
-
-      private
+      # rubocop:enable Metrics/ParameterLists
 
       def generate_signature(timestamp)
         OpenSSL::HMAC.hexdigest('SHA256', @auth_secret, timestamp)
       end
 
       def handle_response(response)
-        raise_appropriate_error(response) unless response.success?
+        return response.body if response.success?
+        return NotModified if response.status == HTTP_NOT_MODIFIED
 
-        response.body
+        raise_appropriate_error(response)
+      end
+
+      def handle_response_with_etag(response)
+        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)
+      end
+
+      def extract_etag(response)
+        etag = response.headers['ETag'] || response.headers['etag']
+        etag&.gsub(/\A"?|"?\z/, '')
       end
 
       def raise_appropriate_error(response)
@@ -75,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
@@ -89,37 +138,18 @@ module ForestAdminDatasourceRpc
       end
 
       def generate_default_message(status, url)
-        default_messages = {
-          400 => "Bad Request: #{url}",
-          401 => "Unauthorized: #{url}",
-          403 => "Forbidden: #{url}",
-          404 => "Not Found: #{url}",
-          409 => "Conflict: #{url}",
-          422 => "Unprocessable Entity: #{url}"
-        }
-
-        default_messages[status] || "Unknown error (#{url})"
+        prefix = DEFAULT_ERROR_MESSAGES[status] || 'Unknown error'
+        "#{prefix}: #{url}"
       end
 
       def parse_error_body(response)
         body = response.body
-
-        # If body is already a hash (Faraday parsed it as JSON)
         return symbolize_error_keys(body) if body.is_a?(Hash)
+        return { message: 'Unknown error' } unless body.is_a?(String) && !body.empty?
 
-        # Try to parse as JSON if it's a string
-        if body.is_a?(String) && !body.empty?
-          begin
-            parsed = JSON.parse(body)
-            return symbolize_error_keys(parsed)
-          rescue JSON::ParserError
-            # If parsing fails, return the body as the message
-            return { message: body }
-          end
-        end
-
-        # Fallback for empty or unexpected body types
-        { message: 'Unknown error' }
+        symbolize_error_keys(JSON.parse(body))
+      rescue JSON::ParserError
+        { message: body }
       end
 
       def symbolize_error_keys(hash)
@@ -129,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.16.10"
+  VERSION = "1.18.0"
 end

data/lib/forest_admin_datasource_rpc.rb

@@ -8,15 +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
+
     begin
       rpc_client = Utils::RpcClient.new(uri, auth_secret)
-      schema = rpc_client.call_rpc('/forest/rpc-schema', method: :get, symbolize_keys: true)
-      last_hash_schema = Digest::SHA1.hexdigest(schema.to_h.to_s)
+      response = rpc_client.fetch_schema('/forest/rpc-schema')
+      schema = response.body
     rescue Faraday::ConnectionFailed => e
       ForestAdminAgent::Facades::Container.logger.log(
         'Error',
@@ -43,21 +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...')
-        new_schema = rpc_client.call_rpc('/forest/rpc-schema', method: :get, symbolize_keys: true)
+      # 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
+
+      polling_options = {
+        polling_interval: polling_interval
+      }
 
-        if last_hash_schema == Digest::SHA1.hexdigest(new_schema.to_h.to_s)
-          ForestAdminAgent::Facades::Container.logger.log('Debug', '[RPCDatasource] Schema has not changed')
-        else
-          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.16.10
+  version: 1.18.0
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-09 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -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