forest_admin_datasource_rpc 1.19.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fe97adef6604fbdd481a33bb2cb4edd1ccf0714934efdf1427c381dd11313c5
-  data.tar.gz: 9359c5f4b64cf2b1ef7e470375e4c263d6d72e21af4fd4c4bff68b3741488888
+  metadata.gz: f0b6bdcda842a6d936560f74f955186c51f36d4be1dbd332c51d0ecdea710cf5
+  data.tar.gz: faabc27ad8e0b3b9fe5f719da93375224c8e4f42bec99dff71c9a132c58119fc
 SHA512:
-  metadata.gz: 4582367363f7a396c8f4bbd76c4ca4b984ab49c240e5c8bb3dc875fedbf2fa1cdc7396b79f7fde7eb03f5a786172c8340bf1893b6d3735174c978a6a8cf81a9a
-  data.tar.gz: 59aace65b04ae6a21262789a5b6f6fa808cd06bb8c9f85a6e078bf0532b53e704394866c9d6b5f41478b8017513041558c7abff01db1a04dce5735c9f818ef6f
+  metadata.gz: 9fe4da7443c4080e0097ad823e750a4cc5fab2e992a1890cc22568ed055cc0b7f78702ca4523bcc0ecb56715355d02c89915d4bffbfd80e9e861ee128633cbe2
+  data.tar.gz: ff37fcf51cf77f521b284dc4f21358241a1c5cd5859117cf614b507a1f4cb0836f547cf0220222052b0cc05a5f898debeb1ab3bf01aa182767fca3a3ff769543

data/lib/forest_admin_datasource_rpc/Utils/rpc_client.rb

@@ -32,8 +32,6 @@ module ForestAdminDatasourceRpc
 
       HTTP_NOT_MODIFIED = 304
       NotModified = Class.new
-      DEFAULT_TIMEOUT = 30 # seconds
-      DEFAULT_OPEN_TIMEOUT = 10 # seconds
 
       def initialize(api_url, auth_secret)
         @api_url = api_url
@@ -65,8 +63,6 @@ module ForestAdminDatasourceRpc
           faraday.response :json, parser_options: { symbolize_names: symbolize_keys }
           faraday.adapter Faraday.default_adapter
           faraday.ssl.verify = !ForestAdminAgent::Facades::Container.cache(:debug)
-          faraday.options.timeout = DEFAULT_TIMEOUT
-          faraday.options.open_timeout = DEFAULT_OPEN_TIMEOUT
         end
 
         timestamp = Time.now.utc.iso8601(3)

data/lib/forest_admin_datasource_rpc/Utils/schema_polling_client.rb

@@ -1,50 +1,54 @@
 require 'openssl'
 require 'json'
 require 'time'
-require 'digest'
 
 module ForestAdminDatasourceRpc
   module Utils
     class SchemaPollingClient
-      attr_reader :closed, :current_schema, :client_id
+      attr_reader :closed
 
-      DEFAULT_POLLING_INTERVAL = 600
-      MIN_POLLING_INTERVAL = 1
-      MAX_POLLING_INTERVAL = 3600
+      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, polling_interval: DEFAULT_POLLING_INTERVAL, introspection_schema: nil,
-                     &on_schema_change)
+      def initialize(uri, auth_secret, options = {}, &on_schema_change)
         @uri = uri
         @auth_secret = auth_secret
-        @polling_interval = polling_interval
+        @polling_interval = options[:polling_interval] || DEFAULT_POLLING_INTERVAL
         @on_schema_change = on_schema_change
         @closed = false
-        @introspection_schema = introspection_schema
-        @current_schema = nil
         @cached_etag = nil
+        @polling_thread = nil
+        @mutex = Mutex.new
         @connection_attempts = 0
-        @initial_sync_completed = false
-        @client_id = uri
 
+        # 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 false if @closed
-
-        ForestAdminAgent::Facades::Container.logger&.log('Info', "Getting schema from RPC agent on #{@uri}.")
-        fetch_initial_schema_sync
+      def start
+        return if @closed
 
-        # Register with the shared pool
-        SchemaPollingPool.instance.register?(@client_id, self)
+        @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] Registered with pool (interval: #{@polling_interval}s, client: #{@client_id})"
+          "[Schema Polling] Polling started (interval: #{@polling_interval}s)"
         )
-        true
       end
 
       def stop
@@ -53,11 +57,46 @@ module ForestAdminDatasourceRpc
         @closed = true
         ForestAdminAgent::Facades::Container.logger&.log('Debug', '[Schema Polling] Stopping polling')
 
-        SchemaPollingPool.instance.unregister?(@client_id)
+        @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
@@ -72,65 +111,11 @@ module ForestAdminDatasourceRpc
         log_unexpected_error(e)
       end
 
-      private
-
-      def compute_etag(schema)
-        return nil if schema.nil?
-
-        Digest::SHA1.hexdigest(schema.to_json)
-      end
-
-      def fetch_initial_schema_sync
-        # If we have an introspection schema, send its ETag to avoid re-downloading unchanged schema
-        introspection_etag = compute_etag(@introspection_schema) if @introspection_schema
-        result = @rpc_client.fetch_schema('/forest/rpc-schema', if_none_match: introspection_etag)
-
-        if result == RpcClient::NotModified
-          # Schema unchanged from introspection - use introspection
-          @current_schema = @introspection_schema
-          @cached_etag = introspection_etag
-          @initial_sync_completed = true
-          ForestAdminAgent::Facades::Container.logger&.log(
-            'Info',
-            "[Schema Polling] RPC schema unchanged (HTTP 304), using introspection (ETag: #{@cached_etag})"
-          )
-        else
-          # New schema from RPC
-          @current_schema = result.body
-          @cached_etag = result.etag || compute_etag(@current_schema)
-          @initial_sync_completed = true
-          ForestAdminAgent::Facades::Container.logger&.log(
-            'Debug',
-            "[Schema Polling] Initial schema fetched successfully (ETag: #{@cached_etag})"
-          )
-        end
-
-        @introspection_schema = nil
-      rescue Faraday::ConnectionFailed, Faraday::TimeoutError,
-             ForestAdminAgent::Http::Exceptions::AuthenticationOpenIdClient, StandardError => e
-        handle_initial_fetch_error(e)
-      end
-
-      def handle_initial_fetch_error(error)
-        if @introspection_schema
-          # Fallback to introspection schema - don't crash
-          @current_schema = @introspection_schema
-          @cached_etag = compute_etag(@current_schema)
-          @introspection_schema = nil
-          @initial_sync_completed = true
-          ForestAdminAgent::Facades::Container.logger&.log(
-            'Warn',
-            "RPC agent at #{@uri} is unreachable (#{error.class}: #{error.message}), " \
-            "using provided introspection schema (ETag: #{@cached_etag})"
-          )
-        else
-          # No introspection - re-raise to crash
-          ForestAdminAgent::Facades::Container.logger&.log(
-            'Error',
-            "Failed to get schema from RPC agent at #{@uri}: #{error.class} - #{error.message}"
-          )
-          raise error
-        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)
@@ -177,27 +162,22 @@ module ForestAdminDatasourceRpc
       end
 
       def handle_schema_changed(result)
-        new_schema = result.body
-        new_etag = result.etag || compute_etag(new_schema)
-
-        if @initial_sync_completed
-          handle_schema_update(new_schema, new_etag)
-        else
-          @cached_etag = new_etag
-          @current_schema = new_schema
-          @initial_sync_completed = true
-          ForestAdminAgent::Facades::Container.logger&.log(
-            'Info',
-            "[Schema Polling] Initial sync completed successfully (ETag: #{new_etag})"
-          )
-        end
+        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
-        @current_schema = schema
         msg = "[Schema Polling] Schema changed detected (old ETag: #{old_etag}, new ETag: #{etag}), " \
               'triggering reload callback'
         ForestAdminAgent::Facades::Container.logger&.log('Info', msg)

data/lib/forest_admin_datasource_rpc/datasource.rb

@@ -25,9 +25,6 @@ module ForestAdminDatasourceRpc
       @live_query_connections = native_query_connections.to_h { |conn| [conn[:name], conn[:name]] }
 
       @schema = { charts: @charts }
-
-      # Register shutdown hook to cleanup schema polling gracefully
-      register_shutdown_hook if @schema_polling_client
     end
 
     def render_chart(caller, name)
@@ -62,38 +59,15 @@ module ForestAdminDatasourceRpc
       @cleaned_up = true
 
       if @schema_polling_client
-        log_info('[RPCDatasource] Stopping schema polling...')
+        ForestAdminAgent::Facades::Container.logger&.log('Info', '[RPCDatasource] Stopping schema polling...')
         @schema_polling_client.stop
-        log_info('[RPCDatasource] Schema polling stopped')
+        ForestAdminAgent::Facades::Container.logger&.log('Info', '[RPCDatasource] Schema polling stopped')
       end
     rescue StandardError => e
-      log_error("[RPCDatasource] Error during cleanup: #{e.class} - #{e.message}")
-    end
-
-    private
-
-    def register_shutdown_hook
-      # Register at_exit hook for graceful shutdown
-      # This ensures schema polling is stopped when the application exits
-      at_exit do
-        cleanup
-      end
-    end
-
-    def log_info(message)
-      return unless defined?(ForestAdminAgent::Facades::Container)
-
-      ForestAdminAgent::Facades::Container.logger&.log('Info', message)
-    rescue StandardError
-      # Silently ignore logging errors during shutdown
-    end
-
-    def log_error(message)
-      return unless defined?(ForestAdminAgent::Facades::Container)
-
-      ForestAdminAgent::Facades::Container.logger&.log('Error', message)
-    rescue StandardError
-      # Silently ignore logging errors during shutdown
+      ForestAdminAgent::Facades::Container.logger&.log(
+        'Error',
+        "[RPCDatasource] Error during cleanup: #{e.class} - #{e.message}"
+      )
     end
   end
 end

data/lib/forest_admin_datasource_rpc/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminDatasourceRpc
-  VERSION = "1.19.1"
+  VERSION = "2.0.0"
 end

data/lib/forest_admin_datasource_rpc.rb

@@ -8,61 +8,116 @@ loader.setup
 module ForestAdminDatasourceRpc
   class Error < StandardError; end
 
-  def self.configure_polling_pool(max_threads:)
-    Utils::SchemaPollingPool.instance.configure(max_threads: max_threads)
-  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)
-    provided_introspection = options[:introspection]
+    ForestAdminAgent::Facades::Container.logger.log('Info', "Getting schema from RPC agent on #{uri}.")
 
-    polling_interval = options[:schema_polling_interval_sec] ||
-                       ENV['SCHEMA_POLLING_INTERVAL_SEC']&.to_i ||
-                       600
+    schema = nil
 
-    # Auto-configure pool with default settings if not already configured
-    ensure_pool_configured
+    begin
+      rpc_client = Utils::RpcClient.new(uri, auth_secret)
+      response = rpc_client.fetch_schema('/forest/rpc-schema')
+      schema = response.body
+    rescue Faraday::ConnectionFailed => e
+      ForestAdminAgent::Facades::Container.logger.log(
+        'Error',
+        "Connection failed to RPC agent at #{uri}: #{e.message}\n#{e.backtrace.join("\n")}"
+      )
+    rescue Faraday::TimeoutError => e
+      ForestAdminAgent::Facades::Container.logger.log(
+        'Error',
+        "Request timeout to RPC agent at #{uri}: #{e.message}"
+      )
+    rescue ForestAdminAgent::Http::Exceptions::AuthenticationOpenIdClient => e
+      ForestAdminAgent::Facades::Container.logger.log(
+        'Error',
+        "Authentication failed with RPC agent at #{uri}: #{e.message}"
+      )
+    rescue StandardError => e
+      ForestAdminAgent::Facades::Container.logger.log(
+        'Error',
+        "Failed to get schema from RPC agent at #{uri}: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
+      )
+    end
+
+    if schema.nil?
+      # return empty datasource for not breaking stack
+      ForestAdminDatasourceToolkit::Datasource.new
+    else
+      # 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
 
-    schema_polling = Utils::SchemaPollingClient.new(
-      uri,
-      auth_secret,
-      polling_interval: polling_interval,
-      introspection_schema: provided_introspection
-    ) do
-      Thread.new do
+      polling_options = {
+        polling_interval: polling_interval
+      }
+
+      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 in background...')
-        begin
-          ForestAdminAgent::Builder::AgentFactory.instance.reload!
-          logger.log('Info', '[RPCDatasource] Agent reload completed successfully')
-        rescue StandardError => e
-          logger.log('Error', "[RPCDatasource] Agent reload failed: #{e.class} - #{e.message}")
-        end
+        logger.log('Info', '[RPCDatasource] Schema change detected, reloading agent...')
+        ForestAdminAgent::Builder::AgentFactory.instance.reload!
       end
-    end
+      schema_polling.start
 
-    # Start polling (includes initial synchronous schema fetch)
-    # - Without introspection: crashes if RPC is unreachable
-    # - With introspection: falls back to introspection if RPC is unreachable
-    schema_polling.start?
+      datasource = ForestAdminDatasourceRpc::Datasource.new(options, schema, schema_polling)
 
-    schema = schema_polling.current_schema
-    if schema.nil?
-      raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
-            'Fatal: Unable to build RPC datasource - no introspection schema was provided and schema fetch failed'
-    end
+      # Setup cleanup hooks for proper schema polling client shutdown
+      setup_cleanup_hooks(datasource)
 
-    ForestAdminDatasourceRpc::Datasource.new(options, schema, schema_polling)
+      datasource
+    end
   end
 
-  def self.ensure_pool_configured
-    pool = Utils::SchemaPollingPool.instance
-    return if pool.configured
+  def self.setup_cleanup_hooks(datasource)
+    # Register cleanup handler for graceful shutdown
+    at_exit do
+      datasource.cleanup
+    rescue StandardError => e
+      # Silently ignore errors during exit cleanup to prevent test pollution
+      warn "[RPCDatasource] Error during at_exit cleanup: #{e.message}" if $VERBOSE
+    end
 
-    # Auto-configure with default thread count if user hasn't configured
-    pool.configure(max_threads: Utils::SchemaPollingPool::DEFAULT_MAX_THREADS)
-  end
+    # Handle SIGINT (Ctrl+C)
+    Signal.trap('INT') do
+      begin
+        ForestAdminAgent::Facades::Container.logger&.log('Info', '[RPCDatasource] Received SIGINT, cleaning up...')
+      rescue StandardError
+        # Logger might not be available
+      end
+      datasource.cleanup
+      exit(0)
+    end
 
-  private_class_method :ensure_pool_configured
+    # Handle SIGTERM (default kill signal)
+    Signal.trap('TERM') do
+      begin
+        ForestAdminAgent::Facades::Container.logger&.log('Info', '[RPCDatasource] Received SIGTERM, cleaning up...')
+      rescue StandardError
+        # Logger might not be available
+      end
+      datasource.cleanup
+      exit(0)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_datasource_rpc
 version: !ruby/object:Gem::Version
-  version: 1.19.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-24 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -126,7 +126,6 @@ files:
 - lib/forest_admin_datasource_rpc.rb
 - lib/forest_admin_datasource_rpc/Utils/rpc_client.rb
 - lib/forest_admin_datasource_rpc/Utils/schema_polling_client.rb
-- lib/forest_admin_datasource_rpc/Utils/schema_polling_pool.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/schema_polling_pool.rb

@@ -1,286 +0,0 @@
-require 'singleton'
-
-module ForestAdminDatasourceRpc
-  module Utils
-    # Thread pool manager for RPC schema polling.
-    # Uses a single scheduler thread that dispatches polling tasks to a bounded
-    # pool of worker threads, preventing thread exhaustion when many RPC slaves
-    # are configured.
-    #
-    # Design principles:
-    # - Minimal mutex hold times to avoid blocking HTTP request threads
-    # - Workers yield control frequently to prevent GIL starvation
-    # - Non-blocking queue operations where possible
-    class SchemaPollingPool
-      include Singleton
-
-      DEFAULT_MAX_THREADS = 5
-      MIN_THREADS = 1
-      MAX_THREADS = 50
-      SCHEDULER_INTERVAL = 1
-      INITIAL_STAGGER_WINDOW = 30
-
-      attr_reader :max_threads, :configured
-
-      def initialize
-        @mutex = Mutex.new
-        @clients = {}
-        @work_queue = Queue.new
-        @workers = []
-        @running = false
-        @max_threads = DEFAULT_MAX_THREADS
-        @shutdown_requested = false
-        @configured = false
-        @scheduler_thread = nil
-      end
-
-      # Configure the pool before starting. Must be called before any clients register.
-      # @param max_threads [Integer] Maximum number of worker threads (1-20)
-      def configure(max_threads:)
-        @mutex.synchronize do
-          raise 'Cannot configure pool while running' if @running
-
-          validated_max = max_threads.to_i.clamp(MIN_THREADS, MAX_THREADS)
-          @max_threads = validated_max
-          @configured = true
-
-          log('Info', "[SchemaPollingPool] Configured with max_threads: #{@max_threads}")
-        end
-      end
-
-      def register?(client_id, client)
-        should_start = false
-
-        @mutex.synchronize do
-          if @clients.key?(client_id)
-            log('Warn', "[SchemaPollingPool] Client #{client_id} already registered, skipping")
-            return false
-          end
-
-          @clients[client_id] = {
-            client: client,
-            last_poll_at: nil,
-            next_poll_at: calculate_initial_poll_time
-          }
-
-          log('Info', "[SchemaPollingPool] Registered client: #{client_id} (#{@clients.size} total clients)")
-
-          should_start = !@running
-        end
-
-        start_pool if should_start
-
-        true
-      end
-
-      def unregister?(client_id)
-        should_stop = false
-
-        @mutex.synchronize do
-          unless @clients.key?(client_id)
-            log('Debug', "[SchemaPollingPool] Client #{client_id} not found for unregister")
-            return false
-          end
-
-          @clients.delete(client_id)
-          log('Info', "[SchemaPollingPool] Unregistered client: #{client_id} (#{@clients.size} remaining)")
-
-          should_stop = @clients.empty? && @running
-        end
-
-        stop_pool if should_stop
-
-        true
-      end
-
-      def client_count
-        @mutex.synchronize { @clients.size }
-      end
-
-      def running?
-        @mutex.synchronize { @running }
-      end
-
-      def shutdown!
-        @mutex.synchronize do
-          return unless @running
-
-          @shutdown_requested = true
-        end
-
-        stop_pool
-
-        @mutex.synchronize do
-          @clients.clear
-          @shutdown_requested = false
-        end
-      end
-
-      def reset!
-        shutdown!
-        @mutex.synchronize do
-          @max_threads = DEFAULT_MAX_THREADS
-          @configured = false
-        end
-      end
-
-      private
-
-      def start_pool
-        @mutex.synchronize do
-          return if @running
-
-          @running = true
-          @shutdown_requested = false
-
-          thread_count = @clients.size.clamp(MIN_THREADS, @max_threads)
-
-          log('Info',
-              "[SchemaPollingPool] Starting pool with #{thread_count} worker threads for #{@clients.size} clients")
-
-          thread_count.times do |i|
-            @workers << Thread.new { worker_loop(i) }
-          end
-
-          @scheduler_thread = Thread.new { scheduler_loop }
-        end
-      end
-
-      def stop_pool
-        workers_to_join = nil
-        scheduler_to_join = nil
-
-        @mutex.synchronize do
-          return unless @running
-
-          log('Info', '[SchemaPollingPool] Stopping pool...')
-
-          @running = false
-
-          @workers.size.times { @work_queue << nil }
-
-          workers_to_join = @workers.dup
-          scheduler_to_join = @scheduler_thread
-
-          @workers.clear
-          @scheduler_thread = nil
-        end
-
-        workers_to_join&.each { |w| w.join(2) }
-        scheduler_to_join&.join(2)
-
-        @work_queue.clear
-
-        log('Info', '[SchemaPollingPool] Pool stopped')
-      end
-
-      def worker_loop(worker_id)
-        log('Debug', "[SchemaPollingPool] Worker #{worker_id} started")
-
-        loop do
-          task = fetch_next_task
-          break if task.nil?
-
-          process_task(task, worker_id)
-          Thread.pass
-        end
-
-        log('Debug', "[SchemaPollingPool] Worker #{worker_id} stopped")
-      end
-
-      def fetch_next_task
-        @work_queue.pop(true)
-      rescue ThreadError
-        Thread.pass
-        sleep(0.1)
-        retry if @running
-        nil
-      end
-
-      def process_task(task, worker_id)
-        client_id = task[:client_id]
-        execute_poll(client_id)
-      rescue StandardError => e
-        log('Error',
-            "[SchemaPollingPool] Worker #{worker_id} error polling #{client_id}: #{e.class} - #{e.message}")
-      end
-
-      def scheduler_loop
-        log('Debug', '[SchemaPollingPool] Scheduler started')
-
-        while @running
-          sleep_with_check(SCHEDULER_INTERVAL)
-
-          next unless @running
-
-          schedule_due_polls
-        end
-
-        log('Debug', '[SchemaPollingPool] Scheduler stopped')
-      end
-
-      def sleep_with_check(duration)
-        remaining = duration
-        while remaining.positive? && @running
-          sleep_time = [remaining, 1.0].min
-          sleep(sleep_time)
-          remaining -= sleep_time
-          Thread.pass
-        end
-      end
-
-      def schedule_due_polls
-        now = Time.now
-        polls_to_schedule = []
-
-        @mutex.synchronize do
-          @clients.each do |client_id, state|
-            next if state[:next_poll_at].nil?
-            next if now < state[:next_poll_at]
-
-            polls_to_schedule << client_id
-
-            interval = state[:client].instance_variable_get(:@polling_interval) || 600
-            state[:next_poll_at] = now + interval
-          end
-        end
-
-        polls_to_schedule.each do |client_id|
-          @work_queue << { client_id: client_id, scheduled_at: now }
-        end
-      end
-
-      def execute_poll(client_id)
-        client = nil
-        @mutex.synchronize do
-          state = @clients[client_id]
-          client = state[:client] if state
-        end
-
-        return unless client
-        return if client.closed
-
-        log('Debug', "[SchemaPollingPool] Polling client: #{client_id}")
-
-        client.check_schema
-
-        @mutex.synchronize do
-          @clients[client_id][:last_poll_at] = Time.now if @clients[client_id]
-        end
-      end
-
-      def calculate_initial_poll_time
-        # Stagger initial polls to avoid thundering herd
-        Time.now + rand(0.0..INITIAL_STAGGER_WINDOW.to_f)
-      end
-
-      def log(level, message)
-        return unless defined?(ForestAdminAgent::Facades::Container)
-
-        ForestAdminAgent::Facades::Container.logger&.log(level, message)
-      rescue StandardError
-        # Ignore logging errors to prevent cascading failures
-      end
-    end
-  end
-end