forest_admin_datasource_rpc 1.22.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee7aa557c745a41ad9255d6e71ba5fab30ed3b6f3b9c48d7ff24c4d031280d4b
-  data.tar.gz: 600f4cae467a95b84779dff19568b9a572f4ce64f12f49f6851112d165fb6bc4
+  metadata.gz: f0b6bdcda842a6d936560f74f955186c51f36d4be1dbd332c51d0ecdea710cf5
+  data.tar.gz: faabc27ad8e0b3b9fe5f719da93375224c8e4f42bec99dff71c9a132c58119fc
 SHA512:
-  metadata.gz: ebbf43da8ccca6679c0e33f9765af986ac3b138b30db72bcc1a9e6775038db90f85469301ff3176721dd544c13d5c1d2371b6da15b99a77c578d011ce21eaaf6
-  data.tar.gz: 0f1eb73352ca77a4380548e657fc8dfaeff4910a971fc571fee401903880069ce6dec6251d74522a91a3769e89c990c0cd6642a2a1dbfd2fa042cd9a89986a84
+  metadata.gz: 9fe4da7443c4080e0097ad823e750a4cc5fab2e992a1890cc22568ed055cc0b7f78702ca4523bcc0ecb56715355d02c89915d4bffbfd80e9e861ee128633cbe2
+  data.tar.gz: ff37fcf51cf77f521b284dc4f21358241a1c5cd5859117cf614b507a1f4cb0836f547cf0220222052b0cc05a5f898debeb1ab3bf01aa182767fca3a3ff769543

data/forest_admin_datasource_rpc.gemspec

@@ -33,12 +33,9 @@ admin work on any Ruby application."
   spec.require_paths = ["lib"]
 
   spec.add_dependency "base64"
-  spec.add_dependency "benchmark"
   spec.add_dependency "bigdecimal"
-  spec.add_dependency "cgi"
   spec.add_dependency "csv"
   spec.add_dependency "faraday", "~> 2.7"
-  spec.add_dependency "logger"
   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

@@ -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
@@ -60,31 +58,13 @@ module ForestAdminDatasourceRpc
       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 = build_faraday_client(symbolize_keys)
-        headers = build_request_headers(caller, if_none_match)
-
-        response = client.send(method, endpoint, payload, headers)
-        log_request_complete(response, endpoint)
-        response
-      rescue Faraday::ConnectionFailed => e
-        handle_connection_failed(endpoint, e)
-      rescue Faraday::TimeoutError => e
-        handle_timeout_error(endpoint, e)
-      end
-      # rubocop:enable Metrics/ParameterLists
-
-      def build_faraday_client(symbolize_keys)
-        Faraday.new(url: @api_url) do |faraday|
+        client = Faraday.new(url: @api_url) do |faraday|
           faraday.request :json
           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
-      end
 
-      def build_request_headers(caller, if_none_match)
         timestamp = Time.now.utc.iso8601(3)
         signature = generate_signature(timestamp)
 
@@ -96,26 +76,12 @@ module ForestAdminDatasourceRpc
 
         headers['forest_caller'] = caller.to_json if caller
         headers['If-None-Match'] = %("#{if_none_match}") if if_none_match
-        headers
-      end
 
-      def handle_connection_failed(endpoint, error)
-        ForestAdminAgent::Facades::Container.logger&.log(
-          'Error',
-          "[RPC Client] Connection failed to #{@api_url}#{endpoint}: #{error.message}"
-        )
-        raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
-              "RPC connection failed: Unable to connect to #{@api_url}. Please check if the RPC server is running."
-      end
-
-      def handle_timeout_error(endpoint, error)
-        ForestAdminAgent::Facades::Container.logger&.log(
-          'Error',
-          "[RPC Client] Request timeout to #{@api_url}#{endpoint}: #{error.message}"
-        )
-        raise ForestAdminDatasourceToolkit::Exceptions::ForestException,
-              "RPC request timeout: The RPC server at #{@api_url} did not respond in time."
+        response = client.send(method, endpoint, payload, headers)
+        log_request_complete(response, endpoint)
+        response
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def generate_signature(timestamp)
         OpenSSL::HMAC.hexdigest('SHA256', @auth_secret, timestamp)

data/lib/forest_admin_datasource_rpc/Utils/schema_polling_client.rb

@@ -1,51 +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,
-                     introspection_etag: 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
-        @introspection_etag = introspection_etag
-        @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
@@ -54,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
@@ -69,73 +107,15 @@ module ForestAdminDatasourceRpc
         log_connection_error(e)
       rescue ForestAdminAgent::Http::Exceptions::AuthenticationOpenIdClient => e
         log_authentication_error(e)
-      rescue ForestAdminDatasourceToolkit::Exceptions::ForestException => e
-        log_rpc_error(e)
       rescue StandardError => e
         log_unexpected_error(e)
       end
 
-      private
-
-      def compute_etag(schema)
-        return nil if schema.nil?
-
-        Digest::SHA1.hexdigest(JSON.generate(schema))
-      end
-
-      def fetch_initial_schema_sync
-        # If we have an introspection schema, send its ETag to avoid re-downloading unchanged schema
-        introspection_etag = @introspection_etag || (@introspection_schema && compute_etag(@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,
-             ForestAdminDatasourceToolkit::Exceptions::ForestException, 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 = @introspection_etag || compute_etag(@current_schema)
-          @introspection_schema = nil
-          @introspection_etag = 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)
@@ -182,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)
@@ -216,13 +191,6 @@ module ForestAdminDatasourceRpc
         )
       end
 
-      def log_rpc_error(error)
-        ForestAdminAgent::Facades::Container.logger&.log(
-          'Warn',
-          "[Schema Polling] RPC error: #{error.message}"
-        )
-      end
-
       def log_authentication_error(error)
         ForestAdminAgent::Facades::Container.logger&.log(
           'Error',

data/lib/forest_admin_datasource_rpc/collection.rb

@@ -6,9 +6,10 @@ module ForestAdminDatasourceRpc
     include ForestAdminDatasourceRpc::Utils
     include ForestAdminDatasourceCustomizer::Decorators::Action
 
-    def initialize(datasource, name, schema)
+    def initialize(datasource, name, options, schema)
       super(datasource, name)
-      @client = datasource.shared_rpc_client
+      @options = options
+      @client = RpcClient.new(@options[:uri], @options[:auth_secret] || ForestAdminAgent::Facades::Container.cache(:auth_secret))
       @rpc_collection_uri = "/forest/rpc/#{name}"
       @base_params = { collection_name: name }
 

data/lib/forest_admin_datasource_rpc/datasource.rb

@@ -2,8 +2,6 @@ module ForestAdminDatasourceRpc
   class Datasource < ForestAdminDatasourceToolkit::Datasource
     include ForestAdminDatasourceRpc::Utils
 
-    attr_reader :shared_rpc_client, :rpc_relations
-
     def initialize(options, introspection, schema_polling_client = nil)
       super()
 
@@ -13,15 +11,11 @@ module ForestAdminDatasourceRpc
         "collections and #{introspection[:charts].length} charts."
       )
 
-      @shared_rpc_client = RpcClient.new(
-        options[:uri],
-        options[:auth_secret] || ForestAdminAgent::Facades::Container.cache(:auth_secret)
-      )
-
       introspection[:collections].each do |schema|
-        add_collection(Collection.new(self, schema[:name], schema))
+        add_collection(Collection.new(self, schema[:name], options, schema))
       end
 
+      @options = options
       @charts = introspection[:charts]
       @rpc_relations = introspection[:rpc_relations]
       @schema_polling_client = schema_polling_client
@@ -31,12 +25,10 @@ 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)
+      client = RpcClient.new(@options[:uri], @options[:auth_secret] || ForestAdminAgent::Facades::Container.cache(:auth_secret))
       url = 'forest/rpc-datasource-chart'
 
       ForestAdminAgent::Facades::Container.logger.log(
@@ -44,10 +36,11 @@ module ForestAdminDatasourceRpc
         "Forwarding datasource chart '#{name}' call to the Rpc agent on #{url}."
       )
 
-      @shared_rpc_client.call_rpc(url, caller: caller, method: :post, payload: { chart: name })
+      client.call_rpc(url, caller: caller, method: :post, payload: { chart: name })
     end
 
     def execute_native_query(connection_name, query, binds)
+      client = RpcClient.new(@options[:uri], @options[:auth_secret] || ForestAdminAgent::Facades::Container.cache(:auth_secret))
       url = 'forest/rpc-native-query'
 
       ForestAdminAgent::Facades::Container.logger.log(
@@ -55,11 +48,8 @@ module ForestAdminDatasourceRpc
         "Forwarding native query for connection '#{connection_name}' to the Rpc agent on #{url}."
       )
 
-      result = @shared_rpc_client.call_rpc(
-        url,
-        method: :post,
-        payload: { connection_name: connection_name, query: query, binds: binds }
-      )
+      result = client.call_rpc(url, method: :post,
+                                    payload: { connection_name: connection_name, query: query, binds: binds })
       ForestAdminDatasourceToolkit::Utils::HashHelper.convert_keys(result.to_a)
     end
 
@@ -69,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.22.1"
+  VERSION = "2.0.0"
 end

data/lib/forest_admin_datasource_rpc.rb

@@ -8,64 +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]
-    provided_introspection_etag = options[:introspection_etag]
+    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,
-      introspection_etag: provided_introspection_etag
-    ) 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)
 
-    options.delete(:introspection)
-    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.22.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-13 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -25,20 +25,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: benchmark
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bigdecimal
   requirement: !ruby/object:Gem::Requirement
@@ -53,20 +39,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: cgi
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: csv
   requirement: !ruby/object:Gem::Requirement
@@ -95,20 +67,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.7'
-- !ruby/object:Gem::Dependency
-  name: logger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: mutex_m
   requirement: !ruby/object:Gem::Requirement
@@ -168,10 +126,8 @@ 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/reconciliate_rpc.rb
 - lib/forest_admin_datasource_rpc/version.rb
 homepage: https://www.forestadmin.com
 licenses:

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

data/lib/forest_admin_datasource_rpc/reconciliate_rpc.rb

@@ -1,71 +0,0 @@
-module ForestAdminDatasourceRpc
-  class ReconciliateRpc < ForestAdminDatasourceCustomizer::Plugins::Plugin
-    def run(datasource_customizer, _collection_customizer = nil, options = {})
-      datasource_customizer.composite_datasource.datasources.each do |datasource|
-        real_datasource = get_datasource(datasource)
-        next unless real_datasource.is_a?(ForestAdminDatasourceRpc::Datasource)
-
-        # Disable search for non-searchable collections
-        real_datasource.collections.each_value do |collection|
-          unless collection.schema[:searchable]
-            cz = datasource_customizer.get_collection(get_collection_name(options[:rename], collection.name))
-            cz.disable_search
-          end
-        end
-
-        # Add relations from rpc_relations
-        (real_datasource.rpc_relations || {}).each do |collection_name, relations|
-          collection_name = get_collection_name(options[:rename], collection_name)
-          cz = datasource_customizer.get_collection(collection_name)
-
-          relations.each do |relation_name, relation_definition|
-            add_relation(cz, options[:rename], relation_name.to_s, relation_definition)
-          end
-        end
-      end
-    end
-
-    private
-
-    def get_datasource(datasource)
-      # can be publication -> rename deco or a custom one
-      while datasource.is_a?(ForestAdminDatasourceToolkit::Decorators::DatasourceDecorator)
-        datasource = datasource.child_datasource
-      end
-
-      datasource
-    end
-
-    def get_collection_name(renames, collection_name)
-      name = collection_name
-
-      if renames.is_a?(Proc)
-        name = renames.call(collection_name)
-      elsif renames.is_a?(Hash) && renames.key?(collection_name.to_s)
-        name = renames[collection_name.to_s]
-      end
-
-      name
-    end
-
-    def add_relation(collection_customizer, renames, relation_name, relation_definition)
-      relation = relation_definition.transform_keys(&:to_sym)
-      foreign_collection = get_collection_name(renames, relation[:foreign_collection])
-      options = relation.except(:type, :foreign_collection, :through_collection)
-
-      case relation[:type]
-      when 'ManyToMany'
-        through_collection = get_collection_name(renames, relation[:through_collection])
-        collection_customizer.add_many_to_many_relation(relation_name, foreign_collection, through_collection, options)
-      when 'OneToMany'
-        collection_customizer.add_one_to_many_relation(relation_name, foreign_collection, options)
-      when 'OneToOne'
-        collection_customizer.add_one_to_one_relation(relation_name, foreign_collection, options)
-      when 'ManyToOne'
-        collection_customizer.add_many_to_one_relation(relation_name, foreign_collection, options)
-      else
-        raise ForestAdminDatasourceToolkit::Exceptions::ForestException, "Unsupported relation type: #{relation[:type]}"
-      end
-    end
-  end
-end