gruf-queue 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0aed8b2822b571278254b3fa5838fcee2bd1c709ce7397bf4dbe9fc296f8847
-  data.tar.gz: e4972e7017721f7c6d1f2924c6b362bb0bb08705b4ef63b31f9ee2465904d953
+  metadata.gz: 93e75c950c181dceecb26c7bb037014232fb190602c85800702c6b8bf29329c7
+  data.tar.gz: a81edb2a6d96d1c514c850b20ed0422eeed701e296497149df0e57597cc1875e
 SHA512:
-  metadata.gz: '09802fce427e339133d11fd72776a61061334e0b29e38e28628a636948830b48280fdc6b89e60dedad2e4a6fcce6355e21c1c1c79ff3c27691697f4eac560624'
-  data.tar.gz: 26ae3647141bc9bee23607743bc94c19f42a2b7bd81bf3a9440c3bd6f86d01122c1b4e5f81144ee6a009595aa445e685cc7f33bba5fdf604a07acacb013182df
+  metadata.gz: 6d6f81af6800c4f8aca41a5400609e147b011b24ae9c6864b3caede6492889e7b9b8e9912274828f9bb35f57793b93355a50b918527d9383b3a719ad7346e509
+  data.tar.gz: e4efc9c13fe4c3867f65312175f65896e6dcd1f65c52ecbec99727ccb2a62e3c4f527ba7afc941ff3ec53faa9c212175b28bf286f753eee6190e47119eb41cc4

data/CHANGELOG.md

@@ -5,7 +5,36 @@ 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.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 +57,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/lib/gruf/queue/configuration.rb

@@ -12,10 +12,6 @@ module Gruf
     module Configuration
       module_function
 
-      # Apply queue-specific configuration to Gruf.
-      #
-      # @return [void]
-      # @raise [StandardError] if configuration fails
       def configure
         return if configured?
 
@@ -25,83 +21,44 @@ module Gruf
           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)
+          if defined?(Gruf) && Gruf.respond_to?(:logger)
+            Gruf.logger.error("Failed to enhance Gruf configuration: #{e.message}")
+          end
           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
+        return unless defined?(Gruf) && Gruf.respond_to?(:configuration)
 
-        log_debug('Gruf configuration state reset', reason: 'test_environment')
+        config = Gruf.configuration
+        config.rpc_server = nil if config.respond_to?(:rpc_server=)
       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

@@ -14,145 +14,73 @@ module Gruf
       #     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}")
+          rescue StandardError
+            # Ignore connection reset errors silently
           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)
+            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
+          return false unless klass.is_a?(Class)
+          return false unless klass.respond_to?(:connection_handler)
 
           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)
+        rescue StandardError
           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

data/lib/gruf/queue/plugin.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'pool_enhancements'
+
 module Gruf
   module Queue
     # Plugin management for gruf-queue integration.
@@ -14,18 +16,12 @@ module Gruf
     #   Gruf::Queue::Plugin.installed?  # => true
     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
+            enhance_grpc_pool
             Gruf.configure do |config|
               configure_rpc_server(config)
               configure_interceptors(config)
@@ -33,45 +29,26 @@ module Gruf
 
             @installed = true
             true
-          rescue StandardError => e
-            # Log the error but don't raise to avoid breaking the application startup
-            log_installation_error(e)
+          rescue StandardError
             false
           end
         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)
 
@@ -85,31 +62,15 @@ module Gruf
           )
         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
@@ -119,7 +80,6 @@ module Gruf
           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 }
@@ -127,30 +87,15 @@ module Gruf
             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)
 
           raise StandardError, 'Interceptors registry initialization failed: missing use method'
         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
-          end
+        def enhance_grpc_pool
+          return if ::GRPC::Pool.included_modules.include?(Gruf::Queue::PoolEnhancements)
+
+          ::GRPC::Pool.prepend(Gruf::Queue::PoolEnhancements)
         end
       end
     end

data/lib/gruf/queue/pool.rb

@@ -15,141 +15,74 @@ module Gruf
       # 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')
+          return false if @stopped
 
           @jobs << [blk, args]
           true
         end
-      rescue StandardError => e
-        log_structured(:error, 'Failed to schedule job', error: e.message)
+      rescue StandardError
         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)
+      rescue StandardError
         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))
+          rescue ThreadError, SystemStackError, IOError
+            # Ignore system-level errors to prevent worker thread death
           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
+      rescue SystemStackError, IOError, GRPC::Core::CallError, GRPC::BadStatus, Timeout::Error
+        # Ignore system/network/gRPC errors to prevent worker thread death
       end
     end
   end

data/lib/gruf/queue/pool_enhancements.rb

@@ -0,0 +1,26 @@
+# 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
+      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

@@ -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,
                      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.2'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gruf-queue
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ether Moon
@@ -139,6 +139,7 @@ files:
 - 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