gruf-queue 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93e75c950c181dceecb26c7bb037014232fb190602c85800702c6b8bf29329c7
-  data.tar.gz: a81edb2a6d96d1c514c850b20ed0422eeed701e296497149df0e57597cc1875e
+  metadata.gz: cc1f1ae6ceeae244f3240289293550ac50d4817c146bdd0ae08c0ba4aac3d6b9
+  data.tar.gz: 510388ca36e935b14f7d727acc5f74a46969018b87cce11bfedf6a0a5723ba1b
 SHA512:
-  metadata.gz: 6d6f81af6800c4f8aca41a5400609e147b011b24ae9c6864b3caede6492889e7b9b8e9912274828f9bb35f57793b93355a50b918527d9383b3a719ad7346e509
-  data.tar.gz: e4efc9c13fe4c3867f65312175f65896e6dcd1f65c52ecbec99727ccb2a62e3c4f527ba7afc941ff3ec53faa9c212175b28bf286f753eee6190e47119eb41cc4
+  metadata.gz: 456159e1ad576446eb160c81a5fd285a8892c005cafc89c3607fcf8371da9e65e98481f14d44760f798cba36abda25e55c80199779e5e68339b6836faf5a32b3
+  data.tar.gz: 2c4e4d90a9667a860de5fb243d0d1c8d4fa8cae4499307c5f65f9e2b0dc7827973662ea24b03c1d1b000807a880645c272b93a52c8b4cd373c01e96c765028a7

data/CHANGELOG.md

@@ -5,6 +5,56 @@ 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.4]
+
+### Changed
+- Renamed `AvaiallableQueue` to `AlwaysReadyQueue` (fixed typo)
+- Improved null object pattern implementation for worker queue management
+- Simplified README.md to focus on core functionality
+
+### Added
+- Graceful shutdown support with `@stopped` flag checking
+- Enhanced test coverage for environment variable configuration
+- Comprehensive test suite for graceful shutdown behavior
+- Thread-safe shutdown handling for GRPC::Pool enhancements
+
+### Fixed
+- Fixed graceful shutdown issues that prevented proper signal handling
+- Improved AlwaysReadyQueue method implementations for better compatibility
+- Enhanced error handling in ready_for_work? method
+
+### Improved
+- More accurate documentation reflecting actual gem purpose
+- Better test organization with focused integration tests
+- Cleaner code structure with proper separation of concerns
+
+## [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

data/README.md

@@ -3,291 +3,55 @@
 [![Gem Version](https://badge.fury.io/rb/gruf-queue.svg)](https://badge.fury.io/rb/gruf-queue)
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.2.0-red.svg)](https://ruby-lang.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Build Status](https://github.com/your-org/gruf-queue/workflows/CI/badge.svg)](https://github.com/your-org/gruf-queue/actions)
 
-A high-performance, queue-based gRPC server extension for Gruf that provides enhanced thread pool management, intelligent resource handling, and seamless database connection management.
+Simple GRPC::Pool enhancement that replaces worker-based capacity checking with job count based threshold.
 
-## Features
+## What it does
 
-🚀 **Enhanced Performance**
-- Queue-based request processing with intelligent job scheduling
-- Resource exhaustion protection with automatic `RESOURCE_EXHAUSTED` responses
-- Structured logging with comprehensive error handling and debugging support
-
-🔌 **Plugin Architecture**
-- Zero-configuration auto-installation
-- Non-invasive integration with existing Gruf applications
-- Modular design with configurable components
-
-🛡️ **Reliability & Safety**
-- Thread-safe operations with proper synchronization
-- Graceful error handling and recovery
-- Smart ActiveRecord connection management
-
-📊 **Observability**
-- Structured logging with metadata for monitoring
-- Thread naming for better debugging
-- Comprehensive error reporting with context
+- Replaces `GRPC::Pool` worker queue management with a simple job count check
+- Uses `jobs_waiting < threshold` instead of tracking actual worker availability
+- Configurable threshold via `GRUF_MAX_WAITING_REQUESTS` (default: 60)
+- Supports graceful shutdown
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
 ```ruby
 gem 'gruf-queue'
 ```
 
-And then execute:
-
-```bash
-$ bundle install
-```
-
-## Quick Start
-
-### Zero Configuration Setup
-
-The simplest way to use gruf-queue is to just require it:
+## Usage
 
 ```ruby
 require 'gruf-queue'
 
-# That's it! Everything is automatically configured.
-# Start your Gruf server as usual:
+# Optional: Set threshold (default is 60)
+ENV['GRUF_MAX_WAITING_REQUESTS'] = '100'
+
+# Start server normally
 Gruf::Server.new(
   hostname: '0.0.0.0:9001',
   services: [YourService]
 ).start
 ```
 
-When you require `gruf-queue`, it automatically:
-- ✅ Configures Gruf to use `QueuedRpcServer`
-- ✅ Registers the `ConnectionReset` interceptor (if ActiveRecord is available)
-- ✅ Sets up enhanced thread pool management
-- ✅ Enables structured logging
-
-### Manual Installation Control
-
-To disable auto-installation and configure manually:
+## Configuration
 
 ```ruby
 # Disable auto-installation
 ENV['GRUF_QUEUE_NO_AUTO_INSTALL'] = 'true'
 
-require 'gruf-queue'
-
 # Manual installation
 Gruf::Queue::Plugin.install!
-
-# Or configure components individually
-Gruf.configure do |config|
-  config.rpc_server = Gruf::Queue::QueuedRpcServer
-  
-  config.interceptors.use(
-    Gruf::Queue::Interceptors::ConnectionReset,
-    enabled: true,
-    target_classes: [ActiveRecord::Base]
-  )
-end
-```
-
-## Configuration
-
-### Server Configuration
-
-```ruby
-# Configure the QueuedRpcServer with custom settings
-Gruf.configure do |config|
-  config.rpc_server = Gruf::Queue::QueuedRpcServer
-  config.rpc_server_options = {
-    pool_size: 10,                    # Thread pool size
-    max_waiting_requests: 20,         # Queue capacity
-    pool_keep_alive: 300,             # Thread keep-alive time
-    poll_period: 1                    # Polling interval
-  }
-end
 ```
 
-### Using Server Factory
-
-For advanced server creation:
+## How it works
 
 ```ruby
-# Create custom server instances
-server = Gruf::Queue::ServerFactory.create_server(
-  pool_size: 15,
-  max_waiting_requests: 30,
-  server: Gruf::Queue::QueuedRpcServer,
-  interceptors: [
-    Gruf::Queue::Interceptors::ConnectionReset
-  ]
-)
+# Before: GRPC::Pool tracks actual worker availability
+pool.ready_for_work? # Complex worker state checking
 
-Gruf::Server.new(
-  hostname: '0.0.0.0:9001',
-  services: [YourService],
-  rpc_server: server
-).start
-```
-
-### ActiveRecord Connection Management
-
-The `ConnectionReset` interceptor automatically manages database connections:
-
-```ruby
-# Automatically registered when ActiveRecord is detected
-# Customizable with additional target classes:
-Gruf.configure do |config|
-  config.interceptors.use(
-    Gruf::Queue::Interceptors::ConnectionReset,
-    enabled: true,
-    target_classes: [ActiveRecord::Base, CustomConnectionClass]
-  )
-end
-```
-
-## Architecture
-
-### Core Components
-
-#### `Gruf::Queue::QueuedRpcServer`
-Enhanced gRPC server with intelligent resource management:
-- Monitors thread pool capacity
-- Automatically sends `RESOURCE_EXHAUSTED` when overloaded
-- Provides structured error handling
-
-#### `Gruf::Queue::Pool`
-Advanced thread pool implementation:
-- Extends `GRPC::Pool` with enhanced job scheduling
-- Structured logging with thread identification
-- Comprehensive error isolation and recovery
-
-#### `Gruf::Queue::Interceptors::ConnectionReset`
-Smart database connection management:
-- Automatically resets ActiveRecord connections after each request
-- Validates connection handlers before attempting reset
-- Graceful error handling to prevent request failures
-
-#### `Gruf::Queue::Plugin`
-Plugin management system:
-- Idempotent installation process
-- Comprehensive error handling during setup
-- Validation of dependencies and requirements
-
-### Plugin Lifecycle
-
-```ruby
-# Plugin installation process
-Gruf::Queue::Plugin.install!  # => true (success) or false (failure)
-
-# Check installation status
-Gruf::Queue::Plugin.installed?  # => true/false
-
-# Reset for testing (test environments only)
-Gruf::Queue::Plugin.reset!
-```
-
-## Advanced Usage
-
-### Custom Server Implementation
-
-```ruby
-# Create a custom server class
-class MyCustomServer < Gruf::Queue::QueuedRpcServer
-  def initialize(*)
-    super
-    # Custom initialization logic
-  end
-  
-  private
-  
-  def handle_custom_logic
-    # Your custom server logic
-  end
-end
-
-# Use with gruf-queue
-Gruf.configure do |config|
-  config.rpc_server = MyCustomServer
-end
-```
-
-### Monitoring and Observability
-
-```ruby
-# Structured logging is automatically enabled
-# Logs include contextual information:
-# - Thread IDs for debugging
-# - Error details with full context
-# - Performance metrics
-# - Resource utilization info
-
-# Example log output:
-# [INFO] Starting thread pool target_size=10
-# [DEBUG] Worker thread started thread_id=47185656920560
-# [WARN] Job execution failed error=SomeError error_class=StandardError
-```
-
-### Environment-specific Configuration
-
-```ruby
-# Production settings
-if Rails.env.production?
-  Gruf.configure do |config|
-    config.rpc_server_options = {
-      pool_size: 20,
-      max_waiting_requests: 50,
-      pool_keep_alive: 600
-    }
-  end
-end
-
-# Development settings
-if Rails.env.development?
-  Gruf.configure do |config|
-    config.rpc_server_options = {
-      pool_size: 5,
-      max_waiting_requests: 10,
-      pool_keep_alive: 60
-    }
-  end
-end
-```
-
-## Performance Considerations
-
-- **Thread Pool Sizing**: Set `pool_size` based on your server's CPU cores and expected load
-- **Queue Capacity**: Configure `max_waiting_requests` to handle traffic spikes
-- **Connection Management**: The `ConnectionReset` interceptor prevents connection leaks in threaded environments
-- **Resource Monitoring**: Use structured logs to monitor resource utilization
-
-## Troubleshooting
-
-### Common Issues
-
-**Server not starting with custom configuration:**
-```ruby
-# Ensure plugin is installed before configuration
-Gruf::Queue::Plugin.install!
-# Then configure...
-```
-
-**ActiveRecord connection issues:**
-```ruby
-# Verify ActiveRecord is loaded before gruf-queue
-require 'active_record'
-require 'gruf-queue'
-```
-
-**High memory usage:**
-```ruby
-# Adjust pool size and keep-alive settings
-Gruf.configure do |config|
-  config.rpc_server_options = {
-    pool_size: 8,           # Reduce if memory constrained
-    pool_keep_alive: 60     # Shorter keep-alive
-  }
-end
+# After: Simple job count threshold
+pool.ready_for_work? # jobs_waiting < max_waiting_requests
 ```
 
 ## Requirements
@@ -296,28 +60,6 @@ end
 - Gruf >= 2.21.0
 - gRPC >= 1.0
 
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
-
-```bash
-# Install dependencies
-$ bundle install
-
-# Run tests
-$ bundle exec rspec
-
-# Run linting
-$ bundle exec rubocop
-
-# Install locally
-$ bundle exec rake install
-```
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/ether-moon/gruf-queue. This project is intended to be a safe, welcoming space for collaboration.
-
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+MIT License

data/lib/gruf/queue/plugin.rb

@@ -6,92 +6,24 @@ 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
         def install!
           return false if @installed
 
-          begin
-            Configuration.configure unless Configuration.configured?
-            enhance_grpc_pool
-            Gruf.configure do |config|
-              configure_rpc_server(config)
-              configure_interceptors(config)
-            end
+          enhance_grpc_pool
 
-            @installed = true
-            true
-          rescue StandardError
-            false
-          end
-        end
-
-        def installed?
-          !!@installed
+          @installed = true
         end
 
+        # Reset installation state for testing
         def reset!
           @installed = false
-          Configuration.reset! if Configuration.respond_to?(:reset!)
         end
 
         private
 
-        def configure_rpc_server(config)
-          config.rpc_server = QueuedRpcServer
-        end
-
-        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
-
-        def validate_active_record_availability
-          return if ActiveRecord::Base.respond_to?(:connection_handler)
-
-          raise StandardError, 'ActiveRecord::Base does not support connection_handler'
-        end
-
-        def ensure_interceptors_registry_available(config)
-          return if config.respond_to?(:interceptors) && !config.interceptors.nil?
-
-          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)
-            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
-
-          return if config.respond_to?(:interceptors) && config.interceptors.respond_to?(:use)
-
-          raise StandardError, 'Interceptors registry initialization failed: missing use method'
-        end
-
         def enhance_grpc_pool
           return if ::GRPC::Pool.included_modules.include?(Gruf::Queue::PoolEnhancements)
 

data/lib/gruf/queue/pool_enhancements.rb

@@ -2,24 +2,34 @@
 
 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)
+    # Null object implementation for worker queue management.
+    # Provides clean interface without complex worker state tracking.
+    class AlwaysReadyQueue
+      def empty? = false
+
+      def <<(*) = self
+
+      def push(*) = self
+
+      def pop = ::Queue.new
+
+      def size = 1
+    end
+
+    # Enhanced GRPC::Pool with job count based capacity management
     module PoolEnhancements
-      def jobs_waiting
-        @jobs&.size || 0
+      DEFAULT_MAX_WAITING_REQUESTS = 60
+
+      def initialize(...)
+        super
+        @ready_workers = AlwaysReadyQueue.new
+        @max_waiting_requests = ENV.fetch('GRUF_MAX_WAITING_REQUESTS', DEFAULT_MAX_WAITING_REQUESTS).to_i
       end
 
-      def schedule(*args, &blk)
-        return false if blk.nil?
+      def ready_for_work?
+        return false if @stopped
 
-        super
-      rescue StandardError
-        false
+        jobs_waiting < @max_waiting_requests
       end
     end
   end

data/lib/gruf/queue/version.rb

@@ -2,6 +2,6 @@
 
 module Gruf
   module Queue
-    VERSION = '0.1.2'
+    VERSION = '0.1.4'
   end
 end

data/lib/gruf-queue.rb

@@ -2,11 +2,7 @@
 
 require 'gruf'
 require 'gruf/queue/version'
-require 'gruf/queue/pool'
-require 'gruf/queue/queued_rpc_server'
-require 'gruf/queue/configuration'
-require 'gruf/queue/server_factory'
-require 'gruf/queue/interceptors/connection_reset'
+require 'gruf/queue/pool_enhancements'
 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.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Ether Moon
@@ -135,13 +135,8 @@ 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,64 +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
-
-      def configure
-        return if configured?
-
-        begin
-          Gruf.configure do |config|
-            enhance_gruf_configuration(config)
-          end
-
-          @configured = true
-        rescue StandardError => e
-          if defined?(Gruf) && Gruf.respond_to?(:logger)
-            Gruf.logger.error("Failed to enhance Gruf configuration: #{e.message}")
-          end
-          raise
-        end
-      end
-
-      def configured?
-        !!@configured
-      end
-
-      def reset!
-        raise 'reset! can only be called in test environments' unless test_environment?
-
-        @configured = false
-
-        return unless defined?(Gruf) && Gruf.respond_to?(:configuration)
-
-        config = Gruf.configuration
-        config.rpc_server = nil if config.respond_to?(:rpc_server=)
-      end
-
-      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)
-
-        return if Gruf.respond_to?(:configuration)
-
-        Gruf.define_singleton_method(:configuration) { config }
-      end
-
-      def test_environment?
-        ENV['RACK_ENV'] == 'test' ||
-          ENV['RAILS_ENV'] == 'test' ||
-          defined?(RSpec)
-      end
-    end
-  end
-end

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

@@ -1,87 +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
-        def initialize(request, call, method, options = {})
-          @request = request
-          @call = call
-          @method = method
-          @options = options || {}
-          @options[:enabled] = true unless @options.key?(:enabled)
-        end
-
-        def call
-          yield
-        ensure
-          begin
-            reset_connections if enabled?
-          rescue StandardError
-            # Ignore connection reset errors silently
-          end
-        end
-
-        private
-
-        attr_reader :options
-
-        def enabled?
-          return false if options[:enabled] == false
-          return false if target_classes.empty?
-
-          true
-        end
-
-        def reset_connections
-          validated_classes = validate_target_classes
-          return if validated_classes.empty?
-
-          validated_classes.each do |klass|
-            reset_connection_for_class(klass)
-          end
-        end
-
-        def target_classes
-          return Array(@target_classes).compact if instance_variable_defined?(:@target_classes)
-
-          default_classes = defined?(::ActiveRecord::Base) ? [::ActiveRecord::Base] : []
-          classes = options.fetch(:target_classes, default_classes)
-          Array(classes).compact
-        end
-
-        def validate_target_classes
-          target_classes.select do |klass|
-            valid_class?(klass)
-          end
-        end
-
-        def valid_class?(klass)
-          return false unless klass.is_a?(Class)
-          return false unless klass.respond_to?(:connection_handler)
-
-          true
-        end
-
-        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
-          false
-        end
-      end
-    end
-  end
-end

data/lib/gruf/queue/pool.rb

@@ -1,89 +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
-
-      def initialize(size, keep_alive: DEFAULT_KEEP_ALIVE)
-        super
-      end
-
-      def jobs_waiting
-        @jobs&.size || 0
-      end
-
-      def schedule(*args, &blk)
-        return false if blk.nil?
-
-        @stop_mutex.synchronize do
-          return false if @stopped
-
-          @jobs << [blk, args]
-          true
-        end
-      rescue StandardError
-        false
-      end
-
-      def start
-        @stop_mutex.synchronize do
-          raise 'Pool already stopped' if @stopped
-        end
-
-        target_size = @size.to_i
-
-        until @workers.size == target_size
-          next_thread = create_worker_thread
-          @workers << next_thread if next_thread
-        end
-      end
-
-      protected
-
-      def create_worker_thread
-        Thread.new do
-          catch(:exit) do
-            _loop_execute_jobs
-          end
-          remove_current_thread
-        end
-      rescue StandardError
-        nil
-      end
-
-      def _loop_execute_jobs
-        Thread.current.name = "gruf-queue-worker-#{Thread.current.object_id}"
-
-        loop do
-          begin
-            blk, args = @jobs.pop
-            execute_job_safely(blk, args)
-          rescue ThreadError, SystemStackError, IOError
-            # Ignore system-level errors to prevent worker thread death
-          end
-
-          @stop_mutex.synchronize do
-            return if @stopped
-          end
-        end
-      end
-
-      def execute_job_safely(blk, args)
-        blk.call(*args)
-      rescue SystemStackError, IOError, GRPC::Core::CallError, GRPC::BadStatus, Timeout::Error
-        # Ignore system/network/gRPC errors to prevent worker thread death
-      end
-    end
-  end
-end

data/lib/gruf/queue/queued_rpc_server.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'pool'
-
-module Gruf
-  module Queue
-    # Enhanced gRPC server with queue-based request handling and resource exhaustion protection.
-    #
-    # Extends GRPC::RpcServer to provide intelligent thread pool management with
-    # automatic RESOURCE_EXHAUSTED responses when the server is overloaded.
-    #
-    # @example Basic usage
-    #   server = Gruf::Queue::QueuedRpcServer.new(pool_size: 20)
-    #   server.handle(MyService)
-    #   server.run_till_terminated
-    class QueuedRpcServer < ::GRPC::RpcServer
-      # Default pool size for the thread pool
-      DEFAULT_POOL_SIZE = 30
-
-      # Default maximum number of waiting requests
-      DEFAULT_MAX_WAITING_REQUESTS = 60
-
-      # Default poll period for the server
-      DEFAULT_POLL_PERIOD = 1
-
-      # No-op procedure for gRPC active call creation
-      NOOP_PROC = proc { |x| x }.freeze
-      private_constant :NOOP_PROC
-
-      # Error message for resource exhaustion
-      RESOURCE_EXHAUSTED_MESSAGE = 'No free threads in thread pool'
-
-      def initialize(pool_size: DEFAULT_POOL_SIZE,
-                     max_waiting_requests: DEFAULT_MAX_WAITING_REQUESTS,
-                     pool_keep_alive: Pool::DEFAULT_KEEP_ALIVE,
-                     poll_period: DEFAULT_POLL_PERIOD,
-                     **args)
-        super
-
-        @pool_size = pool_size
-        @max_waiting_requests = max_waiting_requests
-        @pool_keep_alive = pool_keep_alive
-        @poll_period = poll_period
-      end
-
-      def available?(an_rpc)
-        job_count = safe_job_count
-        return an_rpc if job_count < @max_waiting_requests
-
-        send_resource_exhausted_response(an_rpc)
-        false
-      end
-
-      private
-
-      def safe_job_count
-        return 0 unless @pool
-
-        @pool.jobs_waiting
-      rescue StandardError => e
-        Gruf.logger.warn("Failed to get job count: #{e.message}") if defined?(Gruf) && Gruf.respond_to?(:logger)
-        @max_waiting_requests
-      end
-
-      def send_resource_exhausted_response(an_rpc)
-        Gruf.logger.warn('no free worker threads currently') if defined?(Gruf) && Gruf.respond_to?(:logger)
-
-        begin
-          if an_rpc.respond_to?(:send_status)
-            an_rpc.send_status(
-              ::GRPC::Core::StatusCodes::RESOURCE_EXHAUSTED,
-              RESOURCE_EXHAUSTED_MESSAGE,
-              {},
-            )
-            return
-          end
-
-          active_call = ::GRPC::ActiveCall.new(
-            an_rpc.call,
-            NOOP_PROC,
-            NOOP_PROC,
-            an_rpc.deadline,
-            metadata_received: true,
-            started: false,
-          )
-
-          active_call.send_status(
-            ::GRPC::Core::StatusCodes::RESOURCE_EXHAUSTED,
-            RESOURCE_EXHAUSTED_MESSAGE,
-          )
-        rescue TypeError => e
-          raise unless e.message.include?('Core::Call')
-
-          warn "RESOURCE_EXHAUSTED: #{RESOURCE_EXHAUSTED_MESSAGE}" if defined?(RSpec)
-        end
-      rescue StandardError => e
-        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
-      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