gruf-queue 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0aed8b2822b571278254b3fa5838fcee2bd1c709ce7397bf4dbe9fc296f8847
-  data.tar.gz: e4972e7017721f7c6d1f2924c6b362bb0bb08705b4ef63b31f9ee2465904d953
+  metadata.gz: 16b3387c40ed0f1175b3b6ee1127a15825788f17ae1ccd829385462d58c49913
+  data.tar.gz: d6694faf0538b2f6085a318433389ccf073c2f93876e78f1fb770bc061f6273d
 SHA512:
-  metadata.gz: '09802fce427e339133d11fd72776a61061334e0b29e38e28628a636948830b48280fdc6b89e60dedad2e4a6fcce6355e21c1c1c79ff3c27691697f4eac560624'
-  data.tar.gz: 26ae3647141bc9bee23607743bc94c19f42a2b7bd81bf3a9440c3bd6f86d01122c1b4e5f81144ee6a009595aa445e685cc7f33bba5fdf604a07acacb013182df
+  metadata.gz: b69971940855b247545a1488522d7b0abb9833c9d2eea4b4f8399e664fe9910f3a044a07e967e4cb3f8da91188b758d6ebdf5fd3097b477a51cf707d3275e13e
+  data.tar.gz: bc4d7414d8fdb9223721928facbb5b17db77bd753904a1419af72729ebaae22dcbcaf60244a53fca058ece126d9b1c16a284a3eb1ad0b7fbb92a1352a85d7591

data/CHANGELOG.md

@@ -5,7 +5,63 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.1.0] - 2024-01-01
+## [0.1.3]
+
+### Changed
+- **BREAKING**: Removed ServerFactory - use `QueuedRpcServer.new()` directly instead
+- **BREAKING**: Removed Configuration wrapper - use Gruf's native configuration
+- **BREAKING**: Removed custom ConnectionReset interceptor - use gruf's built-in `Gruf::Interceptors::ActiveRecord::ConnectionReset`
+- Simplified plugin.rb from 104 to 60 lines by removing complex validation logic
+- Merged pool.rb into pool_enhancements.rb for better organization
+
+### Removed
+- `Gruf::Queue::ServerFactory` - unnecessary abstraction layer
+- `Gruf::Queue::Configuration` - wrapper around Gruf's native config
+- `Gruf::Queue::Interceptors::ConnectionReset` - replaced with gruf's built-in
+- `Gruf::Queue::Pool` class - functionality moved to PoolEnhancements module
+- Obsolete test files and redundant test cases
+
+### Improved
+- **730 lines of code removed** - dramatically simplified codebase
+- More direct and intuitive API without unnecessary abstractions
+- Better integration with gruf's native features
+- Cleaner test suite with eliminated logging noise
+- Improved maintainability and reduced complexity
+
+### Fixed
+- Suppressed Gruf logger output during tests for cleaner test runs
+- Updated all documentation and examples to reflect simplified API
+
+## [0.1.2]
+
+### Changed
+- **BREAKING**: Simplified logging system by removing custom log helpers
+- Removed all custom logging methods (log_structured, log_debug, log_error)
+- Simplified error handling to use Gruf.logger directly only where critical
+- Eliminated redundant logging as it's not the gem's responsibility
+- Removed excessive YARD documentation and inline comments for better readability
+- Replaced const replacement with safer module prepend pattern
+- Enhanced GRPC::Pool using PoolEnhancements module without class replacement
+- Improved error handling and recovery mechanisms
+- Updated test suite to handle new module prepend architecture
+
+### Improved
+- Code is now more readable with essential documentation only
+- Reduced complexity following single responsibility principle
+- Applications handle their own logging strategy
+- Fixed all rubocop style issues
+
+### Fixed
+- **CRITICAL**: Fixed parameter passing to parent GRPC::RpcServer class
+- Fixed Rails initialization timing issues with auto-install
+- Fixed thread pool management with proper parameter inheritance
+
+### Added
+- PoolEnhancements module for clean GRPC::Pool extension
+- Improved thread safety and pool management
+- Better error isolation in worker threads
+
+## [0.1.0]
 
 ### Added
 - Initial release of gruf-queue
@@ -28,4 +84,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Observability**: Structured logging with metadata for monitoring and debugging
 - **Customization**: Flexible configuration options for different deployment scenarios
 
-[0.1.0]: https://github.com/ether-moon/gruf-queue/releases/tag/v0.1.0
+[0.1.0]: https://github.com/ether-moon/gruf-queue/releases/tag/v0.1.0

data/README.md

@@ -84,7 +84,7 @@ Gruf.configure do |config|
   config.rpc_server = Gruf::Queue::QueuedRpcServer
   
   config.interceptors.use(
-    Gruf::Queue::Interceptors::ConnectionReset,
+    Gruf::Interceptors::ActiveRecord::ConnectionReset,
     enabled: true,
     target_classes: [ActiveRecord::Base]
   )
@@ -108,19 +108,15 @@ Gruf.configure do |config|
 end
 ```
 
-### Using Server Factory
+### Custom Server Configuration
 
-For advanced server creation:
+For custom server instances with specific options:
 
 ```ruby
-# Create custom server instances
-server = Gruf::Queue::ServerFactory.create_server(
+# Create custom server instances directly
+server = Gruf::Queue::QueuedRpcServer.new(
   pool_size: 15,
-  max_waiting_requests: 30,
-  server: Gruf::Queue::QueuedRpcServer,
-  interceptors: [
-    Gruf::Queue::Interceptors::ConnectionReset
-  ]
+  max_waiting_requests: 30
 )
 
 Gruf::Server.new(
@@ -139,7 +135,7 @@ The `ConnectionReset` interceptor automatically manages database connections:
 # Customizable with additional target classes:
 Gruf.configure do |config|
   config.interceptors.use(
-    Gruf::Queue::Interceptors::ConnectionReset,
+    Gruf::Interceptors::ActiveRecord::ConnectionReset,
     enabled: true,
     target_classes: [ActiveRecord::Base, CustomConnectionClass]
   )
@@ -162,7 +158,7 @@ Advanced thread pool implementation:
 - Structured logging with thread identification
 - Comprehensive error isolation and recovery
 
-#### `Gruf::Queue::Interceptors::ConnectionReset`
+#### `Gruf::Interceptors::ActiveRecord::ConnectionReset`
 Smart database connection management:
 - Automatically resets ActiveRecord connections after each request
 - Validates connection handlers before attempting reset

data/lib/gruf/queue/plugin.rb

@@ -1,155 +1,61 @@
 # frozen_string_literal: true
 
+require_relative 'pool_enhancements'
+
 module Gruf
   module Queue
     # Plugin management for gruf-queue integration.
     #
-    # Provides idempotent installation and configuration of queue-specific settings
-    # including RPC server setup and interceptor registration.
-    #
-    # @example Install plugin
-    #   Gruf::Queue::Plugin.install!  # => true
-    #
-    # @example Check installation status
-    #   Gruf::Queue::Plugin.installed?  # => true
+    # Provides simple installation and configuration of queue-specific settings.
     class Plugin
       class << self
-        # Install and configure the gruf-queue plugin.
-        # This method is idempotent and can be called multiple times safely.
-        #
-        # @return [Boolean] true if installation completed, false if already installed
         def install!
           return false if @installed
 
-          begin
-            # Configure Gruf with queue-specific settings
-            Configuration.configure unless Configuration.configured?
-
-            # Configure Gruf with all queue-specific settings
-            Gruf.configure do |config|
-              configure_rpc_server(config)
-              configure_interceptors(config)
-            end
-
-            @installed = true
-            true
-          rescue StandardError => e
-            # Log the error but don't raise to avoid breaking the application startup
-            log_installation_error(e)
-            false
-          end
+          enhance_grpc_pool
+          configure_gruf
+          @installed = true
+          true
+        rescue StandardError
+          false
         end
 
-        # Check installation status.
-        #
-        # @return [Boolean] true if installed, false otherwise
         def installed?
           !!@installed
         end
 
-        # Reset installation state for testing.
-        #
-        # @return [void]
         def reset!
           @installed = false
-          # Also reset the configuration state
-          Configuration.reset! if Configuration.respond_to?(:reset!)
         end
 
         private
 
-        # Configure RPC server to use QueuedRpcServer.
-        #
-        # @param config [Object] Gruf configuration object
-        # @return [void]
-        # @api private
-        def configure_rpc_server(config)
-          config.rpc_server = QueuedRpcServer
-        end
-
-        # Configure interceptors if ActiveRecord is available.
-        #
-        # @param config [Object] Gruf configuration object
-        # @return [void]
-        # @api private
-        def configure_interceptors(config)
-          return unless defined?(ActiveRecord)
-
-          validate_active_record_availability
-          ensure_interceptors_registry_available(config)
-
-          config.interceptors.use(
-            Interceptors::ConnectionReset,
-            enabled: true,
-            target_classes: [ActiveRecord::Base],
-          )
-        end
-
-        # Validate ActiveRecord connection handler availability.
-        #
-        # @raise [StandardError] if ActiveRecord doesn't support connection_handler
-        # @return [void]
-        # @api private
-        def validate_active_record_availability
-          return if ActiveRecord::Base.respond_to?(:connection_handler)
-
-          raise StandardError, 'ActiveRecord::Base does not support connection_handler'
-        end
-
-        # Ensure interceptors registry is available and initialized.
-        #
-        # Handles Rails initialization timing issues where gruf-queue loads
-        # before Gruf's configuration is fully initialized.
-        #
-        # @param config [Object] Gruf configuration object
-        # @return [void]
-        # @raise [StandardError] if interceptors registry cannot be initialized
-        # @api private
-        def ensure_interceptors_registry_available(config)
-          # Check if interceptors registry exists and is initialized
-          return if config.respond_to?(:interceptors) && !config.interceptors.nil?
-
-          # Initialize interceptors registry if missing
-          begin
-            require 'gruf/interceptors/registry'
-          rescue LoadError => e
-            raise StandardError, "Failed to load Gruf interceptors registry: #{e.message}"
-          end
-
-          if config.respond_to?(:interceptors=)
-            config.interceptors = ::Gruf::Interceptors::Registry.new
-          elsif config.respond_to?(:define_singleton_method)
-            # Fallback: define interceptors accessor methods dynamically
-            registry = ::Gruf::Interceptors::Registry.new
-            config.define_singleton_method(:interceptors) { registry }
-            config.define_singleton_method(:interceptors=) { |val| registry = val }
-          else
-            raise StandardError, 'Cannot initialize interceptors registry: configuration object lacks required methods'
-          end
-
-          # Verify initialization was successful
-          return if config.respond_to?(:interceptors) && config.interceptors.respond_to?(:use)
+        def enhance_grpc_pool
+          return if ::GRPC::Pool.included_modules.include?(Gruf::Queue::PoolEnhancements)
 
-          raise StandardError, 'Interceptors registry initialization failed: missing use method'
+          ::GRPC::Pool.prepend(Gruf::Queue::PoolEnhancements)
         end
 
-        # Log installation error using available logger.
-        #
-        # @param error [StandardError] Error to log
-        # @return [void]
-        # @api private
-        def log_installation_error(error)
-          message = "Failed to install gruf-queue plugin: #{error.message}"
-
-          # Skip error logging in test environment
-          return if ENV['RACK_ENV'] == 'test' || ENV['RAILS_ENV'] == 'test' || defined?(RSpec)
-
-          if defined?(Rails) && Rails.logger.respond_to?(:error)
-            Rails.logger.error(message)
-          elsif defined?(GRPC) && GRPC.logger.respond_to?(:error)
-            GRPC.logger.error(message)
-          else
-            warn message
+        def configure_gruf
+          Gruf.configure do |config|
+            # Set default server options compatible with QueuedRpcServer
+            config.rpc_server_options = {
+              pool_size: QueuedRpcServer::DEFAULT_POOL_SIZE,
+              max_waiting_requests: QueuedRpcServer::DEFAULT_MAX_WAITING_REQUESTS,
+              poll_period: QueuedRpcServer::DEFAULT_POLL_PERIOD,
+              pool_keep_alive: PoolEnhancements::DEFAULT_KEEP_ALIVE,
+            }
+
+            if defined?(ActiveRecord)
+              require 'gruf/interceptors/active_record/connection_reset'
+              # Configure interceptors at the global level
+              if Gruf.respond_to?(:interceptors)
+                Gruf.interceptors.use(
+                  Gruf::Interceptors::ActiveRecord::ConnectionReset,
+                  target_classes: [ActiveRecord::Base],
+                )
+              end
+            end
           end
         end
       end

data/lib/gruf/queue/pool_enhancements.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Gruf
+  module Queue
+    # Enhanced functionality for GRPC::Pool without intrusive modifications.
+    #
+    # Provides essential queue management features while preserving the original
+    # GRPC::Pool class structure and inheritance hierarchy.
+    #
+    # @example Usage
+    #   GRPC::Pool.prepend(Gruf::Queue::PoolEnhancements)
+    module PoolEnhancements
+      # Default keep-alive time for worker threads (in seconds)
+      DEFAULT_KEEP_ALIVE = 600
+
+      def jobs_waiting
+        @jobs&.size || 0
+      end
+
+      def schedule(*args, &blk)
+        return false if blk.nil?
+
+        super
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/gruf/queue/queued_rpc_server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'pool'
+require_relative 'pool_enhancements'
 
 module Gruf
   module Queue
@@ -30,32 +30,19 @@ module Gruf
       # Error message for resource exhaustion
       RESOURCE_EXHAUSTED_MESSAGE = 'No free threads in thread pool'
 
-      # Initialize the QueuedRpcServer with custom pool settings.
-      #
-      # @param pool_size [Integer] Number of worker threads in the pool
-      # @param max_waiting_requests [Integer] Maximum requests to queue before rejecting
-      # @param pool_keep_alive [Integer] Thread keep-alive time in seconds
-      # @param poll_period [Integer] Server polling interval in seconds
-      # @param args [Hash] Additional arguments passed to GRPC::RpcServer
       def initialize(pool_size: DEFAULT_POOL_SIZE,
                      max_waiting_requests: DEFAULT_MAX_WAITING_REQUESTS,
-                     pool_keep_alive: Pool::DEFAULT_KEEP_ALIVE,
+                     pool_keep_alive: PoolEnhancements::DEFAULT_KEEP_ALIVE,
                      poll_period: DEFAULT_POLL_PERIOD,
                      **args)
-        super(**args)
+        super
 
         @pool_size = pool_size
         @max_waiting_requests = max_waiting_requests
         @pool_keep_alive = pool_keep_alive
         @poll_period = poll_period
-
-        @pool = Gruf::Queue::Pool.new(@pool_size, keep_alive: @pool_keep_alive)
       end
 
-      # Check if server can handle the request based on current queue load.
-      #
-      # @param an_rpc [Object] The incoming RPC request
-      # @return [Object, false] The RPC if available, false if resource exhausted
       def available?(an_rpc)
         job_count = safe_job_count
         return an_rpc if job_count < @max_waiting_requests
@@ -66,26 +53,19 @@ module Gruf
 
       private
 
-      # Get current job count from pool with error handling.
-      #
-      # @return [Integer] Number of jobs waiting, or max_waiting_requests on error
       def safe_job_count
+        return 0 unless @pool
+
         @pool.jobs_waiting
       rescue StandardError => e
-        ::GRPC.logger.warn("Failed to get job count: #{e.message}")
-        # Assume maximum load if we can't determine the actual count
+        Gruf.logger.warn("Failed to get job count: #{e.message}") if defined?(Gruf) && Gruf.respond_to?(:logger)
         @max_waiting_requests
       end
 
-      # Send RESOURCE_EXHAUSTED status to client with error handling.
-      #
-      # @param an_rpc [Object] The RPC to send error response to
-      # @return [void]
       def send_resource_exhausted_response(an_rpc)
-        ::GRPC.logger.warn('no free worker threads currently') if ::GRPC.logger.respond_to?(:warn)
+        Gruf.logger.warn('no free worker threads currently') if defined?(Gruf) && Gruf.respond_to?(:logger)
 
         begin
-          # Try calling send_status directly on the RPC object first (for test mocks)
           if an_rpc.respond_to?(:send_status)
             an_rpc.send_status(
               ::GRPC::Core::StatusCodes::RESOURCE_EXHAUSTED,
@@ -95,7 +75,6 @@ module Gruf
             return
           end
 
-          # Create a new active call that knows that metadata hasn't been sent yet
           active_call = ::GRPC::ActiveCall.new(
             an_rpc.call,
             NOOP_PROC,
@@ -110,15 +89,13 @@ module Gruf
             RESOURCE_EXHAUSTED_MESSAGE,
           )
         rescue TypeError => e
-          # Handle test scenario where an_rpc.call is a mock object
           raise unless e.message.include?('Core::Call')
 
-          # In test environment, just log the response
           warn "RESOURCE_EXHAUSTED: #{RESOURCE_EXHAUSTED_MESSAGE}" if defined?(RSpec)
         end
       rescue StandardError => e
-        if ::GRPC.logger.respond_to?(:error)
-          ::GRPC.logger.error("Failed to send resource exhausted response: #{e.message}")
+        if defined?(Gruf) && Gruf.respond_to?(:logger)
+          Gruf.logger.error("Failed to send resource exhausted response: #{e.message}")
         else
           warn "Failed to send resource exhausted response: #{e.message}"
         end

data/lib/gruf/queue/version.rb

@@ -2,6 +2,6 @@
 
 module Gruf
   module Queue
-    VERSION = '0.1.1'
+    VERSION = '0.1.3'
   end
 end

data/lib/gruf-queue.rb

@@ -2,11 +2,8 @@
 
 require 'gruf'
 require 'gruf/queue/version'
-require 'gruf/queue/pool'
+require 'gruf/queue/pool_enhancements'
 require 'gruf/queue/queued_rpc_server'
-require 'gruf/queue/configuration'
-require 'gruf/queue/server_factory'
-require 'gruf/queue/interceptors/connection_reset'
 require 'gruf/queue/plugin'
 
 # Auto-install plugin when required unless explicitly disabled

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gruf-queue
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Ether Moon
@@ -135,12 +135,9 @@ files:
 - README.md
 - gruf-queue.gemspec
 - lib/gruf-queue.rb
-- lib/gruf/queue/configuration.rb
-- lib/gruf/queue/interceptors/connection_reset.rb
 - lib/gruf/queue/plugin.rb
-- lib/gruf/queue/pool.rb
+- lib/gruf/queue/pool_enhancements.rb
 - lib/gruf/queue/queued_rpc_server.rb
-- lib/gruf/queue/server_factory.rb
 - lib/gruf/queue/version.rb
 homepage: https://github.com/ether-moon/gruf-queue
 licenses:

data/lib/gruf/queue/configuration.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Gruf
-  module Queue
-    # Configuration management for gruf-queue integration.
-    #
-    # Enhances Gruf configuration with queue-specific settings and provides
-    # idempotent configuration setup with proper error handling.
-    #
-    # @example Configure Gruf
-    #   Gruf::Queue::Configuration.configure
-    module Configuration
-      module_function
-
-      # Apply queue-specific configuration to Gruf.
-      #
-      # @return [void]
-      # @raise [StandardError] if configuration fails
-      def configure
-        return if configured?
-
-        begin
-          Gruf.configure do |config|
-            enhance_gruf_configuration(config)
-          end
-
-          @configured = true
-          log_debug('Gruf configuration enhanced with rpc_server support', version: Gruf::Queue::VERSION)
-        rescue StandardError => e
-          log_error('Failed to enhance Gruf configuration', error: e.message, error_class: e.class.name)
-          raise
-        end
-      end
-
-      # Check if configuration has been applied.
-      #
-      # @return [Boolean] true if configured, false otherwise
-      def configured?
-        !!@configured
-      end
-
-      # Reset configuration state for testing.
-      #
-      # @return [void]
-      # @raise [RuntimeError] if not in test environment
-      def reset!
-        raise 'reset! can only be called in test environments' unless test_environment?
-
-        @configured = false
-
-        # Reset Gruf configuration to clean state
-        if defined?(Gruf) && Gruf.respond_to?(:configuration)
-          config = Gruf.configuration
-          config.rpc_server = nil if config.respond_to?(:rpc_server=)
-        end
-
-        log_debug('Gruf configuration state reset', reason: 'test_environment')
-      end
-
-      # Enhance Gruf configuration with rpc_server support
-      def enhance_gruf_configuration(config)
-        config.define_singleton_method(:rpc_server) { @rpc_server }
-        config.define_singleton_method(:rpc_server=) { |val| @rpc_server = val }
-        config.rpc_server = nil unless config.respond_to?(:rpc_server)
-
-        # Make the configuration accessible via Gruf.configuration if not already available
-        return if Gruf.respond_to?(:configuration)
-
-        Gruf.define_singleton_method(:configuration) { config }
-      end
-
-      # Check if running in test environment
-      def test_environment?
-        ENV['RACK_ENV'] == 'test' ||
-          ENV['RAILS_ENV'] == 'test' ||
-          defined?(RSpec)
-      end
-
-      # Log debug message
-      def log_debug(message, **metadata)
-        return unless defined?(Gruf) && Gruf.respond_to?(:logger)
-
-        if metadata.any?
-          Gruf.logger.debug(metadata.merge(message: message))
-        else
-          Gruf.logger.debug(message)
-        end
-      rescue StandardError
-        # Ignore logging errors
-      end
-
-      # Log error message
-      def log_error(message, **metadata)
-        return unless defined?(Gruf) && Gruf.respond_to?(:logger)
-        return if test_environment? # Skip error logging in test environment
-
-        if metadata.any?
-          Gruf.logger.error(metadata.merge(message: message))
-        else
-          Gruf.logger.error(message)
-        end
-      rescue StandardError
-        # Ignore logging errors
-      end
-    end
-  end
-end

data/lib/gruf/queue/interceptors/connection_reset.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module Gruf
-  module Queue
-    module Interceptors
-      # ActiveRecord connection reset interceptor for threaded gRPC environments.
-      #
-      # Automatically resets database connections after each request to prevent
-      # connection leaks and stale connections in multi-threaded environments.
-      #
-      # @example Basic usage with Gruf
-      #   config.interceptors.use(
-      #     Gruf::Queue::Interceptors::ConnectionReset,
-      #     target_classes: [ActiveRecord::Base]
-      #   )
-      class ConnectionReset < ::Gruf::Interceptors::ServerInterceptor
-        # Initialize interceptor with request context and options.
-        #
-        # @param request [Object] gRPC request object
-        # @param call [Object] gRPC call object
-        # @param method [Object] gRPC method object
-        # @param options [Hash] Configuration options
-        # @option options [Boolean] :enabled (true) Enable/disable interceptor
-        # @option options [Array<Class>] :target_classes Classes to reset connections for
-        def initialize(request, call, method, options = {})
-          @request = request
-          @call = call
-          @method = method
-          @options = options || {}
-          # Set default enabled value if not provided
-          @options[:enabled] = true unless @options.key?(:enabled)
-        end
-
-        # Execute request and reset connections on completion.
-        #
-        # @yield Block containing the actual request handling
-        # @return [Object] Result of yielded block
-        def call
-          yield
-        ensure
-          begin
-            reset_connections if enabled?
-          rescue StandardError => e
-            # Log error but don't prevent handler execution
-            log_message(:error, "Connection reset failed: #{e.message}")
-          end
-        end
-
-        private
-
-        # Get interceptor configuration options.
-        #
-        # @return [Hash] Configuration options
-        attr_reader :options
-
-        # Check if interceptor is enabled and has valid target classes.
-        #
-        # @return [Boolean] true if should execute, false otherwise
-        def enabled?
-          # Check if explicitly disabled
-          return false if options[:enabled] == false
-
-          # If no target classes are provided and ActiveRecord is not available, disable
-          return false if target_classes.empty?
-
-          true
-        end
-
-        # Reset connections for all valid target classes.
-        #
-        # @return [void]
-        def reset_connections
-          validated_classes = validate_target_classes
-          return if validated_classes.empty?
-
-          reset_count = 0
-          validated_classes.each do |klass|
-            reset_count += 1 if reset_connection_for_class(klass)
-          end
-
-          log_reset_summary(reset_count, validated_classes.size) if reset_count.positive?
-        end
-
-        def target_classes
-          # Use instance variable if set (for testing)
-          return Array(@target_classes).compact if instance_variable_defined?(:@target_classes)
-
-          # Otherwise use options or default
-          default_classes = defined?(::ActiveRecord::Base) ? [::ActiveRecord::Base] : []
-          classes = options.fetch(:target_classes, default_classes)
-          Array(classes).compact
-        end
-
-        # Validate and filter target classes to ensure they support connection handling
-        def validate_target_classes
-          target_classes.select do |klass|
-            valid_class?(klass)
-          end
-        end
-
-        # Check if a class is valid for connection reset capability
-        def valid_class?(klass)
-          unless klass.is_a?(Class)
-            log_validation_warning(klass, 'not a class')
-            return false
-          end
-
-          unless klass.respond_to?(:connection_handler)
-            log_validation_warning(klass, 'does not respond to connection_handler')
-            return false
-          end
-
-          true
-        end
-
-        # Reset connections for a single class
-        def reset_connection_for_class(klass)
-          handler = klass.connection_handler
-          handler.clear_active_connections!(:all) if handler.respond_to?(:clear_active_connections!)
-          handler.clear_reloadable_connections! if handler.respond_to?(:clear_reloadable_connections!)
-          true
-        rescue StandardError => e
-          log_reset_error(klass, e)
-          false
-        end
-
-        # Log validation warnings
-        def log_validation_warning(klass, reason)
-          message = "Skipping connection reset for #{klass.inspect}: #{reason}"
-          log_message(:debug, message)
-        end
-
-        # Log connection reset errors
-        def log_reset_error(klass, error)
-          message = "Failed to reset connections for #{klass}: #{error.message}"
-          log_message(:warn, message)
-        end
-
-        # Log reset operation summary
-        def log_reset_summary(reset_count, total_count)
-          message = "Reset connections for #{reset_count}/#{total_count} classes"
-          log_message(:debug, message)
-        end
-
-        # Centralized logging with fallback chain
-        def log_message(level, message)
-          if defined?(Rails) && Rails.logger.respond_to?(level)
-            Rails.logger.public_send(level, message)
-          elsif defined?(GRPC) && GRPC.logger.respond_to?(level)
-            GRPC.logger.public_send(level, message)
-          elsif level == :warn
-            # Fallback to stderr for critical messages
-            warn(message)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gruf/queue/pool.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-module Gruf
-  module Queue
-    # Enhanced thread pool with structured logging and improved error handling.
-    #
-    # Extends GRPC::Pool to provide better job scheduling, thread safety,
-    # and comprehensive error isolation for gRPC server request handling.
-    #
-    # @example Basic usage
-    #   pool = Gruf::Queue::Pool.new(10, keep_alive: 300)
-    #   pool.schedule { puts "Hello from worker thread" }
-    #   pool.start
-    class Pool < ::GRPC::Pool
-      # Default keep-alive time for worker threads (in seconds)
-      DEFAULT_KEEP_ALIVE = 600
-
-      # Initialize pool with specified size and keep-alive time.
-      #
-      # @param size [Integer] Number of worker threads to maintain
-      # @param keep_alive [Integer] Thread keep-alive time in seconds
-      def initialize(size, keep_alive: DEFAULT_KEEP_ALIVE)
-        super
-      end
-
-      # Get number of jobs currently waiting in queue.
-      #
-      # @return [Integer] Count of queued jobs
-      def jobs_waiting
-        @jobs&.size || 0
-      end
-
-      # Schedule block for execution on worker thread.
-      #
-      # @param args [Array] Arguments to pass to block
-      # @param blk [Proc] Block to execute
-      # @return [Boolean] true if scheduled, false if stopped or nil block
-      def schedule(*args, &blk)
-        return false if blk.nil?
-
-        @stop_mutex.synchronize do
-          if @stopped
-            log_structured(:warn, 'Job scheduling rejected: pool already stopped')
-            return false
-          end
-          log_structured(:debug, 'Job scheduled for execution')
-
-          @jobs << [blk, args]
-          true
-        end
-      rescue StandardError => e
-        log_structured(:error, 'Failed to schedule job', error: e.message)
-        false
-      end
-
-      # Start thread pool and create worker threads.
-      #
-      # @raise [RuntimeError] if pool is already stopped
-      # @return [void]
-      def start
-        @stop_mutex.synchronize do
-          raise 'Pool already stopped' if @stopped
-        end
-
-        target_size = @size.to_i
-        log_structured(:info, 'Starting thread pool', target_size: target_size)
-
-        until @workers.size == target_size
-          next_thread = create_worker_thread
-          @workers << next_thread if next_thread
-        end
-
-        log_structured(:info, 'Thread pool started', worker_count: @workers.size)
-      rescue StandardError => e
-        log_structured(:error, 'Failed to start thread pool', error: e.message)
-        raise
-      end
-
-      protected
-
-      # Create new worker thread with error handling.
-      #
-      # @return [Thread, nil] Worker thread or nil on error
-      def create_worker_thread
-        Thread.new do
-          catch(:exit) do
-            # allows { throw :exit } to kill a thread
-            _loop_execute_jobs
-          end
-          remove_current_thread
-        end
-      rescue StandardError => e
-        log_structured(:error, 'Failed to create worker thread', error: e.message)
-        nil
-      end
-
-      # Main worker thread loop for job execution.
-      #
-      # @return [void]
-      # @api private
-      def _loop_execute_jobs
-        Thread.current.name = "gruf-queue-worker-#{Thread.current.object_id}"
-        log_structured(:debug, 'Worker thread started', thread_id: Thread.current.object_id)
-
-        loop do
-          begin
-            blk, args = @jobs.pop
-            execute_job_safely(blk, args)
-          rescue StandardError => e
-            log_structured(:error, 'Unexpected error in worker thread',
-                           error: e.message,
-                           backtrace: e.backtrace&.first(5))
-          end
-
-          @stop_mutex.synchronize do
-            return if @stopped
-          end
-        end
-      ensure
-        log_structured(:debug, 'Worker thread stopping', thread_id: Thread.current.object_id)
-      end
-
-      # Execute job with error isolation and logging.
-      #
-      # @param blk [Proc] Job block to execute
-      # @param args [Array] Arguments for the block
-      # @return [void]
-      def execute_job_safely(blk, args)
-        blk.call(*args)
-      rescue StandardError, GRPC::Core::CallError => e
-        log_structured(:warn, 'Job execution failed',
-                       error: e.message,
-                       error_class: e.class.name)
-        # Log full backtrace only in debug mode to avoid log spam
-        log_structured(:debug, 'Job execution backtrace', backtrace: e.backtrace) if e.backtrace
-      end
-
-      # Log message with structured metadata.
-      #
-      # @param level [Symbol] Log level (:info, :warn, :error, :debug)
-      # @param message [String] Base log message
-      # @param metadata [Hash] Additional metadata to include
-      # @return [void]
-      def log_structured(level, message, **metadata)
-        return unless GRPC.logger.respond_to?(level)
-
-        if metadata.any?
-          formatted_message = "#{message} #{metadata.map { |k, v| "#{k}=#{v}" }.join(' ')}"
-          GRPC.logger.public_send(level, formatted_message)
-        else
-          GRPC.logger.public_send(level, message)
-        end
-      end
-    end
-  end
-end

data/lib/gruf/queue/server_factory.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module Gruf
-  module Queue
-    # Factory for creating configured gRPC servers with queue-specific options.
-    #
-    # Provides centralized server creation with intelligent defaults, option validation,
-    # and fallback handling for different server types.
-    #
-    # @example Create basic server
-    #   server = Gruf::Queue::ServerFactory.create_server(pool_size: 20)
-    #
-    # @example Create with custom server class
-    #   server = Gruf::Queue::ServerFactory.create_server(
-    #     server: MyCustomServer,
-    #     pool_size: 15
-    #   )
-    module ServerFactory
-      module_function
-
-      # Create a new gRPC server instance with the provided options.
-      #
-      # @param opts [Hash] Configuration options for the server
-      # @option opts [Class] :server Custom server class to use
-      # @option opts [Integer] :pool_size Thread pool size
-      # @option opts [Proc] :event_listener_proc Event listener procedure
-      # @return [GRPC::RpcServer] Configured server instance
-      def create_server(opts = {})
-        # Default to QueuedRpcServer if no server specified
-        rpc_server = opts.fetch(:server, nil)
-        rpc_server ||= (defined?(Gruf) && Gruf.respond_to?(:rpc_server) && Gruf.rpc_server) || QueuedRpcServer
-
-        # Validate server class
-        validate_server_class!(rpc_server) if opts.key?(:server)
-
-        default_options = get_default_options
-
-        server_options = {
-          pool_size: opts.fetch(:pool_size, default_options[:pool_size]),
-          max_waiting_requests: opts.fetch(:max_waiting_requests, default_options[:max_waiting_requests]),
-          poll_period: opts.fetch(:poll_period, default_options[:poll_period]),
-          pool_keep_alive: opts.fetch(:pool_keep_alive, default_options[:pool_keep_alive]),
-          connect_md_proc: opts.fetch(:connect_md_proc, nil),
-          server_args: opts.fetch(:server_args, default_options[:server_args]),
-        }
-
-        # Handle interceptors via Gruf configuration if available
-        interceptors = opts.fetch(:interceptors, [])
-        if interceptors.any? && defined?(Gruf) && Gruf.respond_to?(:configuration)
-          interceptors.each do |interceptor|
-            Gruf.configuration.interceptors.use(interceptor, enabled: true)
-          end
-        elsif interceptors.any?
-          server_options[:interceptors] = interceptors
-        end
-
-        begin
-          rpc_server.new(**server_options)
-        rescue ArgumentError => e
-          raise unless e.message.include?('unknown keywords')
-
-          # Filter out unsupported options for basic GRPC::RpcServer
-          filtered_options = server_options.except(:pool_size, :max_waiting_requests, :poll_period, :pool_keep_alive)
-          rpc_server.new(**filtered_options)
-        end
-      end
-
-      # Validate server class inherits from GRPC::RpcServer.
-      #
-      # @param server_class [Class] Server class to validate
-      # @raise [ArgumentError] if not a valid GRPC server class
-      # @return [void]
-      def validate_server_class!(server_class)
-        return if server_class.is_a?(Class) && server_class <= ::GRPC::RpcServer
-
-        raise ArgumentError, "Server must be a subclass of GRPC::RpcServer, got #{server_class}"
-      end
-      module_function :validate_server_class!
-
-      # Get default server options with Gruf integration fallback.
-      #
-      # @return [Hash] Default configuration options
-      def get_default_options
-        if defined?(Gruf) && Gruf.respond_to?(:rpc_server_options)
-          Gruf.rpc_server_options
-        else
-          {
-            pool_size: QueuedRpcServer::DEFAULT_POOL_SIZE,
-            max_waiting_requests: QueuedRpcServer::DEFAULT_MAX_WAITING_REQUESTS,
-            poll_period: QueuedRpcServer::DEFAULT_POLL_PERIOD,
-            pool_keep_alive: Pool::DEFAULT_KEEP_ALIVE,
-            server_args: {},
-          }
-        end
-      end
-      module_function :get_default_options
-    end
-  end
-end