patient_http-solid_queue 1.2.0 → 1.3.0

data/lib/patient_http/solid_queue/configuration.rb

@@ -4,34 +4,39 @@ require "delegate"
 
 module PatientHttp
   module SolidQueue
-    # Configuration for the Solid Queue Async HTTP gem.
+    # Configuration for the Solid Queue integration.
     #
-    # Wraps PatientHttp::Configuration with Solid Queue-aware defaults and adds
-    # Solid Queue-specific options like queue name settings.
+    # Extends `PatientHttp::Configuration` with Solid Queue defaults and adds
+    # options for the job queue, crash recovery, and named processor profiles.
     class Configuration < PatientHttp::Configuration
-      # Default threshold in bytes above which payloads are stored externally.
-      DEFAULT_PAYLOAD_STORE_THRESHOLD = 64 * 1024 # 64KB
-
-      # @return [Integer] Size threshold in bytes for external payload storage
-      attr_reader :payload_store_threshold
+      # Default size in bytes above which payloads are stored externally.
+      #
+      # @deprecated Use {PatientHttp::Configuration::DEFAULT_PAYLOAD_STORE_THRESHOLD}.
+      #   The `payload_store_threshold` option is defined on the base
+      #   configuration, next to `register_payload_store`.
+      DEFAULT_PAYLOAD_STORE_THRESHOLD = PatientHttp::Configuration::DEFAULT_PAYLOAD_STORE_THRESHOLD
 
-      # @return [Numeric] Orphan detection threshold in seconds
+      # @return [Numeric] The number of seconds without a heartbeat after which
+      #   an in-flight request is considered orphaned and re-enqueued.
       attr_reader :orphan_threshold
 
-      # @return [Numeric] Heartbeat update interval in seconds
+      # @return [Numeric] The number of seconds between heartbeat updates for
+      #   in-flight requests.
       attr_reader :heartbeat_interval
 
-      # @return [String, nil] Queue name for RequestJob and CallbackJob
+      # @return [String, nil] The queue name for `RequestJob` and `CallbackJob`.
       attr_reader :queue_name
 
-      # @return [#call, nil] Handler invoked when a CallbackWorker job exhausts all retries.
+      # Returns or sets the handler that runs when Active Job discards a
+      # `CallbackJob`.
+      #
       # @overload on_retries_exhausted
       #   Returns the current handler.
-      #   @return [#call, nil]
+      #   @return [#call, nil] The handler, or `nil` if none is set.
       # @overload on_retries_exhausted(&block)
       #   Sets a block as the handler.
-      #   @yield [error] block to execute when retries are exhausted
-      #   @yieldparam error [PatientHttp::Error] information about the error
+      #   @yield [error] The block to run when a job is discarded.
+      #   @yieldparam error [PatientHttp::Error] The error from the request.
       def on_retries_exhausted(&block)
         if block
           @on_retries_exhausted = block
@@ -40,115 +45,199 @@ module PatientHttp
         end
       end
 
-      # Buffer in seconds subtracted from SolidQueue.shutdown_timeout to derive
-      # the default shutdown_timeout for this gem's connection pool.
+      # Seconds subtracted from `SolidQueue.shutdown_timeout` to get the default
+      # `shutdown_timeout` for this gem's processor.
       SHUTDOWN_TIMEOUT_BUFFER = 2
 
-      # @param heartbeat_interval [Numeric] Interval in seconds for heartbeat updates (default: 60)
-      # @param orphan_threshold [Numeric] Time in seconds to consider a job orphaned (default: 300)
-      # @param queue_name [String, nil] Optional queue name for RequestJob and CallbackJob (default: nil)
-      # @param payload_store_threshold [Integer] Size threshold in bytes for external payload storage (default: 64KB)
-      # @param on_retries_exhausted [#call, nil] Handler called when a CallbackWorker job exhausts retries
-      # @param pool_options [Hash] Additional options passed to the SolidQueue connection pool
+      # Creates a configuration.
+      #
+      # @param heartbeat_interval [Numeric] The number of seconds between
+      #   heartbeat updates for in-flight requests.
+      # @param orphan_threshold [Numeric] The number of seconds without a
+      #   heartbeat after which an in-flight request is considered orphaned.
+      # @param queue_name [String, nil] The queue name for `RequestJob` and
+      #   `CallbackJob`. If `nil`, the Active Job default queue applies.
+      # @param on_retries_exhausted [#call, nil] The handler that runs when
+      #   Active Job discards a `CallbackJob`.
+      # @param pool_options [Hash] Options for `PatientHttp::Configuration`. If
+      #   `shutdown_timeout` isn't set, it defaults to the Solid Queue shutdown
+      #   timeout minus 2 seconds. If `logger` isn't set, it defaults to the
+      #   Solid Queue logger.
+      # @raise [ArgumentError] If an option isn't valid.
       def initialize(
         heartbeat_interval: 60,
         orphan_threshold: 300,
         queue_name: nil,
-        payload_store_threshold: DEFAULT_PAYLOAD_STORE_THRESHOLD,
         on_retries_exhausted: nil,
         **pool_options
       )
-        if ::SolidQueue.shutdown_timeout
-          pool_options[:shutdown_timeout] ||= [::SolidQueue.shutdown_timeout - SHUTDOWN_TIMEOUT_BUFFER, 1].max
-        end
-        pool_options[:user_agent] ||= "SolidQueue-AsyncHttp"
-        pool_options[:logger] ||= (defined?(SolidQueue.logger) ? SolidQueue.logger : nil)
+        # The Solid Queue defaults for these options are read when the options
+        # are used, so settings that Solid Queue gets after this configuration
+        # is built still apply.
+        pool_options = pool_options.compact
 
         super(**pool_options)
 
+        @shutdown_timeout_set = pool_options.key?(:shutdown_timeout)
+        @logger_set = pool_options.key?(:logger)
         @processor_profiles = {default: {}}
+        @profile_configs = {}
+        @profile_configs_mutex = Mutex.new
         self.queue_name = queue_name
         self.heartbeat_interval = heartbeat_interval
         self.orphan_threshold = orphan_threshold
-        self.payload_store_threshold = payload_store_threshold || DEFAULT_PAYLOAD_STORE_THRESHOLD
         self.on_retries_exhausted = on_retries_exhausted
       end
 
-      # Declare a named processor profile.
+      # Declares a named processor profile.
       #
       # Each profile becomes an independent processor with its own capacity,
-      # timeouts, and threads. Options are overrides applied on top of this
-      # configuration's HTTP pool options. Calling this with no options
-      # declares a profile that inherits every option. Requests select a
-      # processor with the +processor:+ option on
-      # +PatientHttp::SolidQueue.execute+ (or on the request itself). The
-      # +:default+ profile always exists; declaring it overrides options for
-      # the default processor.
+      # timeouts, and threads. The options override this configuration's HTTP
+      # options. With no options, the profile inherits every option. A request
+      # selects a processor with the `processor:` option, or with the
+      # request's own processor name. The `:default` profile always exists.
+      # Declare it to override options for the default processor.
       #
       # @example
-      #   PatientHttp::SolidQueue.configure do |config|
+      #   PatientHttp.configure do |config|
       #     config.processor(:llm, max_connections: 200, request_timeout: 120)
       #     config.processor(:webhooks, max_connections: 64, request_timeout: 10)
       #   end
       #
-      # @param name [Symbol, String] the processor name
-      # @param options [Hash] overrides for PatientHttp::Configuration options
-      # @return [Hash] the stored options for the profile
+      # @param name [Symbol, String] The processor name.
+      # @param options [Hash] Overrides for `PatientHttp::Configuration`
+      #   options. `encryption_key` can't be overridden, because all processors
+      #   share encryption.
+      # @return [Hash] The stored options for the profile.
+      # @raise [ArgumentError] If the name is empty or an option is invalid.
       def processor(name, **options)
         key = normalize_processor_name(name)
-        @processor_profiles[key] = normalize_profile_options!(options)
+        normalized = normalize_profile_options!(options)
+        @profile_configs_mutex.synchronize do
+          @profile_configs.delete(key)
+          @processor_profiles[key] = normalized
+        end
       end
 
-      # Read back the options declared for a named processor profile.
+      # Returns the options declared for a named processor profile.
       #
-      # @param name [Symbol, String] the processor name
-      # @return [Hash, nil] the stored options, or nil if the profile is not declared
+      # @param name [Symbol, String] The processor name.
+      # @return [Hash, nil] The stored options, or `nil` if the profile isn't
+      #   declared.
       def processor_options(name)
-        @processor_profiles[normalize_processor_name(name)]
+        key = name.to_s
+        return nil if key.empty?
+
+        @processor_profiles[key.to_sym]
       end
 
-      # All declared processor profiles. Always includes :default.
+      # Returns all declared processor profiles, including `:default`.
       #
-      # @return [Hash{Symbol => Hash}] profile options by processor name
+      # @return [Hash{Symbol => Hash}] The profile options, keyed by processor
+      #   name.
       def processor_profiles
         @processor_profiles.dup
       end
 
-      # Build the effective configuration for a named processor. The default
-      # profile with no overrides is this configuration itself; other profiles
-      # get a view of this configuration with their overrides applied, so they
-      # share secrets, preprocessors, payload stores, and encryption.
+      # Returns the configuration for a named processor.
       #
-      # @param name [Symbol, String] the processor name
-      # @return [PatientHttp::Configuration] the configuration for the processor
-      # @raise [ArgumentError] if the profile is not declared
+      # A profile without overrides uses this configuration. Other profiles use
+      # a view of this configuration with their overrides applied, so all
+      # processors share secrets, preprocessors, payload stores, and
+      # encryption. The view is built once and reused until the profile is
+      # declared again.
+      #
+      # @param name [Symbol, String] The processor name.
+      # @return [PatientHttp::Configuration] The configuration for the processor.
+      # @raise [ArgumentError] If the profile isn't declared.
       def processor_config(name)
         key = normalize_processor_name(name)
-        profile = @processor_profiles[key]
-        raise ArgumentError.new("Unknown processor profile: #{name.inspect}") unless profile
 
-        return self if profile.empty?
+        @profile_configs_mutex.synchronize do
+          profile = @processor_profiles[key]
+          raise ArgumentError.new("Unknown processor profile: #{name.inspect}") unless profile
+
+          return self if profile.empty?
+
+          @profile_configs[key] ||= ProfileConfiguration.new(self, profile)
+        end
+      end
+
+      # Returns the graceful shutdown timeout in seconds. If it isn't set,
+      # returns the Solid Queue shutdown timeout minus 2 seconds, so that the
+      # processor stops before Solid Queue gives up on the worker.
+      #
+      # @return [Numeric] The timeout in seconds.
+      def shutdown_timeout
+        solid_queue_timeout = ::SolidQueue.shutdown_timeout
+        return super if @shutdown_timeout_set || solid_queue_timeout.nil?
+
+        [solid_queue_timeout - SHUTDOWN_TIMEOUT_BUFFER, 1].max
+      end
+
+      # Sets the graceful shutdown timeout in seconds.
+      #
+      # @param value [Numeric] The timeout in seconds. Must be positive.
+      # @return [void]
+      # @raise [ArgumentError] If `value` isn't positive.
+      def shutdown_timeout=(value)
+        super
+        @shutdown_timeout_set = true
+      end
+
+      # Returns the logger. If it isn't set, returns the Solid Queue logger.
+      #
+      # @return [Logger] The logger.
+      def logger
+        return super if @logger_set
 
-        ProfileConfiguration.new(self, profile)
+        solid_queue_logger = ::SolidQueue.logger if ::SolidQueue.respond_to?(:logger)
+        solid_queue_logger || super
       end
 
-      def payload_store_threshold=(value)
-        validate_positive_integer(:payload_store_threshold, value)
-        @payload_store_threshold = value
+      # Sets the logger.
+      #
+      # @param value [Logger, nil] The logger.
+      # @return [void]
+      def logger=(value)
+        super
+        @logger_set = true
       end
 
+      # Sets the number of seconds between heartbeat updates for in-flight
+      # requests.
+      #
+      # @param value [Numeric] The interval in seconds. Must be positive and less
+      #   than `orphan_threshold`.
+      # @return [void]
+      # @raise [ArgumentError] If `value` isn't positive or isn't less than
+      #   `orphan_threshold`.
       def heartbeat_interval=(value)
         raise ArgumentError, "heartbeat_interval must be positive, got: #{value.inspect}" unless value.positive?
         @heartbeat_interval = value
         validate_heartbeat_and_threshold
       end
 
+      # Sets the number of seconds without a heartbeat after which an in-flight
+      # request is considered orphaned and re-enqueued.
+      #
+      # @param value [Numeric] The threshold in seconds. Must be positive and
+      #   greater than `heartbeat_interval`.
+      # @return [void]
+      # @raise [ArgumentError] If `value` isn't positive or isn't greater than
+      #   `heartbeat_interval`.
       def orphan_threshold=(value)
         raise ArgumentError, "orphan_threshold must be positive, got: #{value.inspect}" unless value.positive?
         @orphan_threshold = value
         validate_heartbeat_and_threshold
       end
 
+      # Sets the queue name for `RequestJob` and `CallbackJob`.
+      #
+      # @param name [String, nil] The queue name, or `nil` to use the Active Job
+      #   default queue.
+      # @return [void]
+      # @raise [ArgumentError] If `name` isn't `nil` or a String.
       def queue_name=(name)
         if name.nil?
           @queue_name = nil
@@ -160,13 +249,14 @@ module PatientHttp
         apply_queue_name(name)
       end
 
-      # Set the on_retries_exhausted handler.
-      #
-      # This handler is called when a CallbackWorker job exhausts all retries.
-      # It receives the same arguments as the on_error callback.
+      # Sets the handler that runs when Active Job discards a `CallbackJob`. The
+      # handler receives the same error object as the `on_error` callback.
       #
-      # @param value [#call, nil] A callable object or nil to clear the handler
-      # @raise [ArgumentError] If value is not callable and not nil
+      # @param value [#call, nil] A callable object, or `nil` to remove the
+      #   handler.
+      # @return [void]
+      # @raise [ArgumentError] If `value` isn't `nil` and doesn't respond to
+      #   `call`.
       def on_retries_exhausted=(value)
         if value && !value.respond_to?(:call)
           raise ArgumentError.new("on_retries_exhausted must respond to #call, got: #{value.class}")
@@ -175,10 +265,12 @@ module PatientHttp
         @on_retries_exhausted = value
       end
 
-      # @return [Hash] configuration as a hash for logging/inspection
+      # Returns the configuration as a Hash for inspection.
+      #
+      # @return [Hash{String => Object}] The option values, keyed by option
+      #   name.
       def to_h
         super.merge(
-          "payload_store_threshold" => payload_store_threshold,
           "heartbeat_interval" => heartbeat_interval,
           "orphan_threshold" => orphan_threshold,
           "queue_name" => queue_name,
@@ -187,11 +279,16 @@ module PatientHttp
         )
       end
 
-      # View of a base configuration with a profile's option overrides applied.
-      # Everything not overridden (secrets, preprocessors, payload stores,
-      # encryption, logging) delegates to the base configuration, so all
-      # processors share those registries.
+      # A view of a base configuration with a processor profile's overrides
+      # applied. Options that the profile doesn't override, such as secrets,
+      # preprocessors, payload stores, and the logger, come from the base
+      # configuration, so all processors share them.
       class ProfileConfiguration < SimpleDelegator
+        # Creates a view of the base configuration.
+        #
+        # @param base_configuration [PatientHttp::Configuration] The
+        #   configuration to delegate to.
+        # @param overrides [Hash] Option values that replace the base values.
         def initialize(base_configuration, overrides)
           super(base_configuration)
           overrides.each do |key, value|
@@ -207,13 +304,18 @@ module PatientHttp
         PatientHttp::SolidQueue::CallbackJob.queue_as(name)
       end
 
-      # Profile options must be valid PatientHttp::Configuration options. A
+      # Profile options must be valid PatientHttp::Configuration options other
+      # than `encryption_key`, which all processors share. A
       # throwaway configuration exercises each option's own validation and
       # normalization, so the stored value is what the writer would have
       # produced rather than the raw input.
       def normalize_profile_options!(options)
         return options if options.empty?
 
+        if options.key?(:encryption_key)
+          raise ArgumentError.new("encryption_key can't be set for a processor profile")
+        end
+
         probe = PatientHttp::Configuration.new(**options)
         options.to_h do |key, value|
           [key, probe.respond_to?(key) ? probe.public_send(key) : value]

data/lib/patient_http/solid_queue/context.rb

@@ -2,26 +2,27 @@
 
 module PatientHttp
   module SolidQueue
-    # Provides thread-safe context for Active Jobs.
+    # Stores the current Active Job for each thread.
     #
-    # Manages the current Active Job context using a thread-id keyed hash,
-    # allowing async HTTP requests to access job information without it being
-    # passed explicitly. Only RequestJob needs this context for re-enqueueing jobs.
+    # Code that runs in a job reads the job from this class instead of
+    # receiving it as an argument. `RequestJob` uses the job to re-enqueue a
+    # request.
     class Context
       @jobs = Concurrent::Map.new
 
       class << self
-        # Returns the current job data hash for the running thread.
+        # Returns the current Active Job for this thread.
         #
-        # @return [Hash, nil]
+        # @return [Hash, nil] The serialized job, or `nil` if no job is set.
         def current_job
           @jobs[Thread.current.object_id]
         end
 
-        # Set the current job context for the duration of a block.
+        # Sets the current job for the duration of a block.
         #
-        # @param job_data [Hash] Active Job serialized hash
-        # @yield
+        # @param job_data [Hash] The serialized Active Job.
+        # @yield The block to run.
+        # @return [Object] The return value of the block.
         def with_job(job_data)
           thread_id = Thread.current.object_id
           previous_job = @jobs[thread_id]

data/lib/patient_http/solid_queue/engine.rb

@@ -2,7 +2,9 @@
 
 module PatientHttp
   module SolidQueue
-    # Rails Engine that makes gem migrations discoverable by the host application.
+    # Rails engine that exposes the gem's migrations to the
+    # `patient_http_solid_queue:install:migrations` task. The migrations don't
+    # run with the host application's `db:migrate` until they are copied.
     class Engine < ::Rails::Engine
       engine_name "patient_http_solid_queue"
 

data/lib/patient_http/solid_queue/gc_lock.rb

@@ -2,11 +2,11 @@
 
 module PatientHttp
   module SolidQueue
-    # Active Record model for distributed garbage collection locking.
+    # Active Record model for the distributed garbage collection lock.
     #
-    # Ensures only one process runs orphan detection at a time. The last_gc_at
-    # column records when GC was last successfully completed, allowing processes
-    # to skip GC attempts if another process ran GC recently.
+    # The lock makes sure that only one process at a time runs orphan
+    # detection. The `last_gc_at` column records when garbage collection last
+    # completed, so a process can skip it if another process ran it recently.
     class GcLock < Record
       self.table_name = "patient_http_solid_queue_gc_locks"
     end

data/lib/patient_http/solid_queue/inflight_request.rb

@@ -2,11 +2,11 @@
 
 module PatientHttp
   module SolidQueue
-    # Active Record model tracking inflight HTTP requests for crash recovery.
+    # Active Record model for in-flight HTTP requests, used for crash recovery.
     #
-    # Each record represents a single in-flight HTTP request. The heartbeat_at
-    # timestamp is updated periodically; stale records from dead processes are
-    # detected and re-enqueued by the GC mechanism.
+    # Each record represents one in-flight HTTP request. The processor updates
+    # the `heartbeat_at` timestamp periodically. Garbage collection finds stale
+    # records from dead processes and re-enqueues their requests.
     class InflightRequest < Record
       self.table_name = "patient_http_solid_queue_inflight_requests"
     end

data/lib/patient_http/solid_queue/lifecycle_hooks.rb

@@ -2,11 +2,21 @@
 
 module PatientHttp
   module SolidQueue
-    # Registers lifecycle hooks with SolidQueue to start/stop the async HTTP processor.
+    # Registers Solid Queue worker lifecycle hooks that manage the processors.
+    #
+    # The hooks do the following:
+    #
+    # - Start the processors when a Solid Queue worker starts
+    #   (`on_worker_start`).
+    # - Stop the processors when the worker stops (`on_worker_stop`).
     class LifecycleHooks
       @registered = false
 
       class << self
+        # Registers the lifecycle hooks. The gem calls this method when it loads.
+        # Repeated calls have no effect.
+        #
+        # @return [void]
         def register
           return if @registered
 

data/lib/patient_http/solid_queue/process_registration.rb

@@ -2,11 +2,11 @@
 
 module PatientHttp
   module SolidQueue
-    # Active Record model tracking registered async HTTP processor processes.
+    # Active Record model for processes that run an async HTTP processor.
     #
-    # Each record represents a running processor process. The last_seen_at
-    # timestamp is updated via heartbeats. Records for processes that are not
-    # in this table are considered orphaned during GC.
+    # Each record represents a running process. Heartbeats update the
+    # `last_seen_at` timestamp. During garbage collection, in-flight requests
+    # from processes that aren't in this table are considered orphaned.
     class ProcessRegistration < Record
       self.table_name = "patient_http_solid_queue_processes"
     end

data/lib/patient_http/solid_queue/processor_observer.rb

@@ -2,22 +2,27 @@
 
 module PatientHttp
   module SolidQueue
-    # Processor observer that maintains the crash-recovery registry for one
-    # processor. The task monitor is shared across all processors in the
-    # process; the module owns it and the monitor thread.
+    # Processor observer that maintains the crash recovery registry for one
+    # processor. All processors in the process share one task monitor, which
+    # the `PatientHttp::SolidQueue` module owns along with the monitor thread.
     #
-    # Tasks are registered in the crash-recovery registry when the processor
-    # accepts them, before Processor#enqueue returns, so a request always has
-    # a durable record from the moment the caller hands it off. Registration
-    # runs on the caller's thread (a job worker thread), not the reactor
-    # thread. The entry is removed when the request completes or when an
-    # Active Job owns the request again (the task was rejected or
-    # re-enqueued). When result delivery fails (completion_failed), the entry
-    # is deliberately kept so the orphan collector re-enqueues the request
-    # instead of losing it.
+    # The observer registers a task when the processor accepts it, before
+    # `Processor#enqueue` returns. A request therefore has a durable record
+    # from the moment the caller hands it off. Registration runs on the
+    # caller's job worker thread, not on the reactor thread.
+    #
+    # The observer removes the entry when the request completes, or when an
+    # Active Job owns the request again because the task was rejected or
+    # re-enqueued. If result delivery fails, the observer keeps the entry, so
+    # the orphan collector re-enqueues the request instead of losing it.
     class ProcessorObserver < PatientHttp::ProcessorObserver
+      # @return [TaskMonitor] The in-flight request registry.
       attr_reader :task_monitor
 
+      # Creates an observer for a processor.
+      #
+      # @param processor [PatientHttp::Processor] The processor to observe.
+      # @param task_monitor [TaskMonitor] The in-flight request registry.
       def initialize(processor, task_monitor:)
         @processor = processor
         @task_monitor = task_monitor
@@ -25,14 +30,29 @@ module PatientHttp
         @requeued_mutex = Mutex.new
       end
 
+      # Adds a request to the crash-recovery registry.
+      #
+      # @param request_task [PatientHttp::RequestTask] The request task.
+      # @return [void]
+      # @raise [RegistrationError] If the registry entry can't be written.
       def request_enqueued(request_task)
         task_monitor.register(request_task)
       end
 
+      # Removes a rejected request from the crash-recovery registry. An Active
+      # Job owns the request again.
+      #
+      # @param request_task [PatientHttp::RequestTask] The request task.
+      # @return [void]
       def request_rejected(request_task)
         task_monitor.unregister(request_task)
       end
 
+      # Removes a re-enqueued request from the crash-recovery registry. An
+      # Active Job owns the request again.
+      #
+      # @param request_task [PatientHttp::RequestTask] The request task.
+      # @return [void]
       def request_requeued(request_task)
         task_monitor.unregister(request_task)
         # The re-enqueue path fires request_end after request_requeued, but
@@ -45,6 +65,10 @@ module PatientHttp
         @requeued_mutex.synchronize { @requeued_task_ids << request_task.id }
       end
 
+      # Removes a finished request from the crash-recovery registry.
+      #
+      # @param request_task [PatientHttp::RequestTask] The request task.
+      # @return [void]
       def request_end(request_task)
         requeued = @requeued_mutex.synchronize { @requeued_task_ids.delete?(request_task.id) }
         return if requeued
@@ -52,6 +76,13 @@ module PatientHttp
         task_monitor.unregister(request_task)
       end
 
+      # Handles a failure to deliver a request's result. Keeps the
+      # crash-recovery record and releases it, so that the orphan collector
+      # re-enqueues the request, and logs the error.
+      #
+      # @param request_task [PatientHttp::RequestTask] The request task.
+      # @param error [Exception] The delivery failure.
+      # @return [void]
       def completion_failed(request_task, error)
         # Keep the crash-recovery registry entry, but hand it off to the orphan
         # collector. Orphan collection ignores records that belong to a live

data/lib/patient_http/solid_queue/record.rb

@@ -2,7 +2,8 @@
 
 module PatientHttp
   module SolidQueue
-    # Base Active Record class for patient_http-solid_queue models.
+    # Base Active Record class for this gem's models. The models use the
+    # Solid Queue database.
     class Record < ::SolidQueue::Record
       self.abstract_class = true
     end