patient_http-sidekiq 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5ae5287613de3682de817fb6c434e6a1a33c21c1b8aa1dde7b7808c1733b927
-  data.tar.gz: 350e8f054d1047fe70482d9c3fc2f5473b077e1e7f1c64cc6f023c8bf76f62b4
+  metadata.gz: 47d12842c42be5d8953e2e54afcaa7f702ead028c6aef09c9f01bb16e48d0193
+  data.tar.gz: 1ab374564b701fd7201b36a208bdd31a24e60829eaa4522a4cdbcae27380721e
 SHA512:
-  metadata.gz: d843ce929d22f48c20bc7f487b35d11421166218081f4fea2490440781d0a00839266c3cb1dec039611a6728e2213c3a71f0a966454ba40c1efc6ab466648ca7
-  data.tar.gz: 006cf97e99a6d27847b038c19065a88b09e28a94c7392fbee5af4253e9483652e8022b21e42c271840cfc8bff326fcfd490b137d1b08c8984760c68f6f7bc3df
+  metadata.gz: b26e488319bde0bc5d778e19281897b8244e7e70a82df90f8c7824329fe449b2d1cc52664ffb090d62c6671edd99e6c98c9e12c669c7888560ad082b8d1db2b6
+  data.tar.gz: 0ff5a1cfe9e6ce4ee41e4a3a50ce8af4b88ec47020be8d3d6117ebe96a0cb7b402f0ec77e0911b7dd2e803ea5b70fb1e1acd939dcd69b15e865855e4a1a35f42

data/ARCHITECTURE.md

@@ -112,14 +112,21 @@ sequenceDiagram
     participant Callback as Callback Service
 
     App->>Module: get(url, callback: MyCallback)
-    Module->>Sidekiq: Enqueue RequestWorker
-    Sidekiq->>ReqWorker: Execute job
-    ReqWorker->>Processor: submit(request, handler)
-    activate Processor
-    Note over Processor: Request queued<br/>in memory
-    Processor-->>ReqWorker: Returns immediately
-    ReqWorker-->>Sidekiq: Job completes
-    deactivate Processor
+
+    alt Processor running in this process (direct execution)
+        Module->>Processor: submit(request, handler)
+        Note over Module: DirectTaskHandler keeps the<br/>RequestWorker args for re-enqueue
+        Processor-->>Module: Returns immediately
+    else Processor not in this process
+        Module->>Sidekiq: Enqueue RequestWorker
+        Sidekiq->>ReqWorker: Execute job
+        ReqWorker->>Processor: submit(request, handler)
+        activate Processor
+        Note over Processor: Request queued<br/>in memory
+        Processor-->>ReqWorker: Returns immediately
+        ReqWorker-->>Sidekiq: Job completes
+        deactivate Processor
+    end
 
     Note over Sidekiq: Worker thread free<br/>to process other jobs
 
@@ -149,6 +156,8 @@ Key integration points:
 3. **CallbackWorker** invokes the user's callback service methods
 4. **ExternalStorage** handles large payloads transparently at each step
 
+Direct execution (enabled by default with `config.direct_execution`) skips the `RequestWorker` enqueue when the processor runs in the current process. The request gets a `DirectTaskHandler` that holds the `RequestWorker` job arguments, so every re-enqueue path (processor shutdown, crash recovery, and the at-capacity fallback) can enqueue the request as a normal `RequestWorker` job. The handler exposes a minimal job record for the crash-recovery registry because the orphan sweep pushes the stored record from another process. Requests made in a `with_sidekiq_options` block and requests made while `Sidekiq::Testing` is enabled always go through the queue, so that Sidekiq applies the options. Options set with `config.sidekiq_options` (including a `queue`) do not apply to direct-executed requests, because no Sidekiq job is created; set `config.direct_execution = false` to route every request through the configured queue. A failure to write the crash-recovery registry entry rejects the request and raises to the caller, the same as a failed enqueue.
+
 ## Component Relationships
 
 ```mermaid
@@ -377,13 +386,15 @@ In-flight requests are tracked in Redis to enable recovery when Sidekiq processe
 - Re-enqueues orphaned requests via `Sidekiq::Client.push`
 
 ### Recovery Process
-1. `ProcessorObserver` notifies `TaskMonitor` when requests start/complete
-2. `TaskMonitorThread` updates heartbeat timestamps in Redis
+1. `ProcessorObserver` registers a request with `TaskMonitor` when the processor accepts it (before `Processor#enqueue` returns) and unregisters it when the request completes or when a Sidekiq job owns the request again (rejected or re-enqueued)
+2. `TaskMonitorThread` updates heartbeat timestamps in Redis for all tracked requests (queued, pending, and in-flight)
 3. If a process crashes, heartbeat updates stop
 4. Other processes' monitor threads detect stale timestamps
 5. Orphaned requests are atomically removed and re-enqueued
 6. Prevents lost work during deployments or crashes
 
+Recovery gives at-least-once delivery. A crash between a re-enqueue and the removal of the registry entry can execute a request more than once, so callbacks must be idempotent. A request is durable once the submitting call returns; a crash during the call behaves like a failed enqueue.
+
 **Redis Keys:**
 - `sidekiq:patient_http:inflight_index` - Sorted set of request IDs by timestamp
 - `sidekiq:patient_http:inflight_jobs` - Hash of request payloads
@@ -401,6 +412,9 @@ PatientHttp::Sidekiq.configure do |config|
   # Sidekiq worker options (applied to both RequestWorker and CallbackWorker)
   config.sidekiq_options = {queue: "patient_http", retry: 5}
 
+  # Skip the Sidekiq queue when the processor runs in the current process
+  config.direct_execution = true
+
   # Encryption (for sensitive data in Sidekiq jobs; inherited from PatientHttp::Configuration)
   config.encryption_key = ENV["PATIENT_HTTP_ENCRYPTION_KEY"]
 
@@ -465,6 +479,13 @@ Fiber reactor processes request
 Response/Error received
 ```
 
+With direct execution (the default), a request made in a process with a running
+processor skips the enqueue and the `RequestWorker#perform` steps. A
+`DirectTaskHandler` holds the `RequestWorker` job arguments, and the request
+goes straight to the processor. The rest of the flow is identical, and the
+re-enqueue paths use the handler to enqueue a normal `RequestWorker` job when
+needed.
+
 ### Processing a Response
 
 ```

data/CHANGELOG.md

@@ -4,6 +4,16 @@ 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).
 
+## 1.3.0
+
+### Added
+
+- Requests made in a process with a running processor now go straight to the processor instead of being enqueued through Sidekiq. The request can always be re-enqueued as a normal `RequestWorker` job, so all of the re-enqueue paths (processor shutdown, crash recovery, and the at-capacity fallback) behave the same as the enqueued path. Requests made in a `with_sidekiq_options` block always go through the Sidekiq queue, so that Sidekiq applies the options; options set with `config.sidekiq_options` do not apply to direct-executed requests because no Sidekiq job is created. The new `direct_execution` configuration option (default: `true`) turns this behavior off.
+
+### Changed
+
+- Requests are now registered in the crash-recovery registry when the processor accepts them, before the enqueue call returns, instead of when the request starts processing. A request handed to the processor is durable from that point on, and heartbeats now cover queued requests as well as in-flight ones. The entry is removed when the request completes or when a Sidekiq job owns the request again. A failure to write the registry entry rejects the request and raises to the caller, the same as a failed enqueue. This requires patient_http 1.4.0.
+
 ## 1.2.0
 
 ### Added

data/README.md

@@ -246,6 +246,19 @@ The options are applied with Sidekiq's `set` method, so any Sidekiq job option (
 
 - If the options include a `queue`, the callback job that invokes your `on_complete`/`on_error` methods is enqueued on that queue as well, so the whole request keeps one priority end to end.
 - Nested blocks merge their options, and the innermost values take precedence. The previous options are restored when the block exits, even if the block raises an error.
+- Requests made in the block always go through the Sidekiq queue, even when the processor runs in the current process, so that Sidekiq applies the options (see Direct Execution below).
+
+### Direct Execution
+
+When a request is made in a process where the processor is running (normally a Sidekiq server process), the request skips the Sidekiq queue and goes straight to the processor. This removes a round trip through Redis. The behavior is the same as the enqueued path:
+
+- The request can always be re-enqueued. It is registered in the crash-recovery registry before the call returns, so if the processor shuts down or the process crashes, the request is enqueued as a normal `RequestWorker` job. If the registry entry cannot be written (for example, Redis is unavailable), the call raises, the same as a failed enqueue.
+- If the processor is at max capacity or stops accepting requests, the request is enqueued through Sidekiq instead, and the normal Sidekiq retry behavior applies from there.
+- Requests made in a `with_sidekiq_options` block always go through the Sidekiq queue, so that Sidekiq applies the options (queue routing, scheduling, retry). Use this to route specific requests to a dedicated Sidekiq process.
+- Options set with `config.sidekiq_options` (including a `queue`) do not apply to direct-executed requests, because no Sidekiq job is created. If every request must go through the configured queue (for example, to run all requests on a dedicated Sidekiq process), set `config.direct_execution = false`.
+- Direct execution is disabled when `Sidekiq::Testing` is enabled, so tests can observe enqueued jobs as usual.
+
+You can turn this off with `config.direct_execution = false`. Do this if you route all requests to a dedicated queue with `config.sidekiq_options`, if you need Sidekiq client or server middleware to run for every request, or if you want every request to be visible as an enqueued job in Sidekiq metrics and the Web UI.
 
 ### Using Request Templates
 
@@ -464,6 +477,12 @@ PatientHttp::Sidekiq.configure do |config|
   # (use PatientHttp::Sidekiq.with_sidekiq_options to override per request)
   config.sidekiq_options = {queue: "patient_http", retry: 5}
 
+  # Whether requests made in a process with a running processor skip the
+  # Sidekiq queue and go straight to the processor (default: true).
+  # Sidekiq options, including a queue, do not apply to direct-executed
+  # requests; set this to false to route every request through the queue.
+  config.direct_execution = true
+
   # Handler called when a callback job exhausts all Sidekiq retries
   config.on_retries_exhausted { |error| MyAlertService.notify(error) }
 
@@ -588,6 +607,8 @@ The gem includes crash recovery to handle process failures:
 
 This ensures that if a Sidekiq process crashes, its in-flight requests will be retried by another process.
 
+Crash recovery gives at-least-once delivery. If a process crashes at the wrong moment (for example, between a re-enqueue and the removal of the registry entry), a request can execute more than once and its callback can fire more than once. Make your callbacks idempotent. A request is durable once the call that submits it returns; a crash during the call behaves like a failed enqueue, and the caller never received an acknowledgment.
+
 ## Testing
 
 The gem supports `Sidekiq::Testing.inline!` mode for synchronous testing. When in inline mode, async HTTP requests are executed immediately within the worker thread, blocking until completion. This allows you to write tests that verify the full request/response cycle without needing the async processor to be running.

data/VERSION

@@ -1 +1 @@
-1.2.0
+1.3.0

data/lib/patient_http/sidekiq/configuration.rb

@@ -24,6 +24,10 @@ module PatientHttp
       # @return [Hash, nil] Sidekiq options to apply to RequestWorker and CallbackWorker
       attr_reader :sidekiq_options
 
+      # @return [Boolean] Whether requests execute directly on a processor running in the
+      #   current process instead of being enqueued through Sidekiq
+      attr_reader :direct_execution
+
       # @return [#call, nil] Handler invoked when a CallbackWorker job exhausts all retries.
       # @overload on_retries_exhausted
       #   Returns the current handler.
@@ -51,6 +55,8 @@ module PatientHttp
       # @param orphan_threshold [Integer] Age threshold for detecting orphaned requests in seconds
       # @param sidekiq_options [Hash, nil] Sidekiq options to apply to RequestWorker and CallbackWorker
       # @param on_retries_exhausted [#call, nil] Handler called when a CallbackWorker job exhausts retries
+      # @param direct_execution [Boolean] Whether requests execute directly on a processor
+      #   running in the current process instead of being enqueued through Sidekiq
       # @param pool_options [Hash] Options passed through to PatientHttp::Configuration.
       #   Sidekiq-aware defaults are applied for shutdown_timeout and logger
       #   if not explicitly provided.
@@ -60,6 +66,7 @@ module PatientHttp
         sidekiq_options: nil,
         payload_store_threshold: DEFAULT_PAYLOAD_STORE_THRESHOLD,
         on_retries_exhausted: nil,
+        direct_execution: true,
         **pool_options
       )
         pool_options[:shutdown_timeout] ||= (::Sidekiq.default_configuration[:timeout] || 25) - 2
@@ -73,6 +80,7 @@ module PatientHttp
         self.orphan_threshold = orphan_threshold
         self.payload_store_threshold = payload_store_threshold || DEFAULT_PAYLOAD_STORE_THRESHOLD
         self.on_retries_exhausted = on_retries_exhausted
+        self.direct_execution = direct_execution
       end
 
       # Set the on_retries_exhausted handler.
@@ -144,6 +152,24 @@ module PatientHttp
         apply_sidekiq_options(options)
       end
 
+      # Set whether requests execute directly on a processor running in the current
+      # process. When enabled, requests made in a process with a running processor
+      # skip the Sidekiq queue and go straight to the processor. The value is
+      # coerced to a boolean.
+      #
+      # @param value [Boolean] true to enable direct execution
+      # @return [void]
+      def direct_execution=(value)
+        @direct_execution = !!value
+      end
+
+      # Check if direct execution is enabled.
+      #
+      # @return [Boolean]
+      def direct_execution?
+        @direct_execution
+      end
+
       # Convert to hash for inspection
       # @return [Hash] hash representation with string keys
       def to_h
@@ -152,6 +178,7 @@ module PatientHttp
           "heartbeat_interval" => heartbeat_interval,
           "orphan_threshold" => orphan_threshold,
           "sidekiq_options" => sidekiq_options,
+          "direct_execution" => direct_execution,
           "on_retries_exhausted" => on_retries_exhausted ? "defined" : nil
         )
       end

data/lib/patient_http/sidekiq/direct_task_handler.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PatientHttp
+  module Sidekiq
+    # TaskHandler for requests executed directly on the local processor
+    # without an enqueued Sidekiq job. Requests with scoped Sidekiq options
+    # always go through the queue, so the handler only deals with the
+    # default RequestWorker options.
+    #
+    # Retry enqueues a normal RequestWorker job with the original arguments,
+    # so the fail-back behavior matches the enqueued path. The sidekiq_job
+    # hash is a minimal job record kept for the crash-recovery registry; it
+    # has no jid because no Sidekiq job exists until the request is
+    # re-enqueued, so job_id returns nil.
+    class DirectTaskHandler < TaskHandler
+      # @param args [Array] the RequestWorker job arguments
+      def initialize(args)
+        @args = args
+        super(minimal_job_record)
+      end
+
+      # Re-enqueue the request as a normal RequestWorker job.
+      #
+      # @return [String] the job ID
+      def retry
+        RequestWorker.perform_async(*@args)
+      end
+
+      private
+
+      # Minimal pushable job record for the crash-recovery registry.
+      # TaskMonitor serializes it to Redis and the orphan GC pushes it
+      # verbatim, possibly from another process, so it cannot enqueue
+      # through this handler. The worker options are included because
+      # Sidekiq::Client.push does not apply them when "class" is a String.
+      #
+      # @return [Hash]
+      def minimal_job_record
+        RequestWorker.get_sidekiq_options
+          .merge("class" => RequestWorker.name, "args" => @args)
+      end
+    end
+  end
+end

data/lib/patient_http/sidekiq/processor_observer.rb

@@ -4,6 +4,12 @@ module PatientHttp
   module Sidekiq
     # Procesor Observer that collect stats in Redis for the WebUI and
     # monitors for crashed processes in order to re-enqueue workers.
+    #
+    # 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. The entry is
+    # removed when the request completes or when a Sidekiq job owns the
+    # request again (the task was rejected or re-enqueued).
     class ProcessorObserver < PatientHttp::ProcessorObserver
       attr_reader :task_monitor
 
@@ -14,7 +20,7 @@ module PatientHttp
         @monitor_thread = TaskMonitorThread.new(
           processor.config,
           @task_monitor,
-          -> { @processor.inflight_request_ids }
+          -> { @processor.tracked_request_ids }
         )
       end
 
@@ -31,10 +37,18 @@ module PatientHttp
         @stats.record_capacity_exceeded
       end
 
-      def request_start(request_task)
+      def request_enqueued(request_task)
         task_monitor.register(request_task)
       end
 
+      def request_rejected(request_task)
+        task_monitor.unregister(request_task)
+      end
+
+      def request_requeued(request_task)
+        task_monitor.unregister(request_task)
+      end
+
       def request_end(request_task)
         task_monitor.unregister(request_task)
         @stats.record_request(request_task.response&.status, request_task.duration)

data/lib/patient_http/sidekiq/request_executor.rb

@@ -7,9 +7,8 @@ module PatientHttp
       class << self
         # Execute the request directly on the async processor.
         #
-        # This method enqueues the request directly to the async processor. It must be
-        # called from within a Sidekiq job context (the sidekiq_job parameter is required).
-        # Used internally by RequestWorker.
+        # This method enqueues the request directly to the async processor. Used internally
+        # by RequestWorker.
         #
         # When the request completes, the callback's +on_complete+ method is called with
         # a Response object. If an error occurs (network error, timeout, or non-2xx response
@@ -22,6 +21,9 @@ module PatientHttp
         #   If not provided, uses PatientHttp::Sidekiq::Context.current_job.
         #   This requires the PatientHttp::Sidekiq::Context::Middleware to be added
         #   to the Sidekiq server middleware chain.
+        # @param task_handler [PatientHttp::TaskHandler, nil] A prebuilt task handler.
+        #   When provided, the sidekiq_job parameter is ignored and no handler is
+        #   built from it. Used for direct execution on the local processor.
         # @param synchronous [Boolean] If true, runs the request inline (for testing).
         # @param callback_args [#to_h, nil] Arguments to pass to callback via the
         #   Response/Error object. Must respond to +to_h+ and contain only JSON-native types
@@ -38,14 +40,14 @@ module PatientHttp
           request,
           callback:,
           sidekiq_job: nil,
+          task_handler: nil,
           synchronous: false,
           callback_args: nil,
           raise_error_responses: false,
           request_id: nil
         )
-          sidekiq_job = validate_sidekiq_job(sidekiq_job)
+          task_handler ||= TaskHandler.new(validate_sidekiq_job(sidekiq_job))
           config = PatientHttp::Sidekiq.configuration
-          task_handler = TaskHandler.new(sidekiq_job)
 
           task = PatientHttp::RequestTask.new(
             request: request,

data/lib/patient_http/sidekiq/task_monitor_thread.rb

@@ -20,12 +20,13 @@ module PatientHttp
       #
       # @param config [Configuration] the configuration object
       # @param task_monitor [TaskMonitor] the inflight request registry
-      # @param inflight_ids_callback [Proc] callback to get current inflight request IDs
+      # @param tracked_ids_callback [Proc] callback to get the IDs of all requests the
+      #   processor is tracking (queued, pending, and in-flight)
       # @return [void]
-      def initialize(config, task_monitor, inflight_ids_callback)
+      def initialize(config, task_monitor, tracked_ids_callback)
         @config = config
         @task_monitor = task_monitor
-        @inflight_ids_callback = inflight_ids_callback
+        @tracked_ids_callback = tracked_ids_callback
         @thread = nil
         @running = Concurrent::AtomicBoolean.new(false)
         @stop_signal = Concurrent::Event.new
@@ -107,16 +108,16 @@ module PatientHttp
         @config.logger&.info("[PatientHttp::Sidekiq] Monitor thread stopped")
       end
 
-      # Update heartbeats for all inflight requests.
+      # Update heartbeats for all tracked requests.
       #
       # @return [void]
       def update_heartbeats
-        request_ids = @inflight_ids_callback.call
+        request_ids = @tracked_ids_callback.call
         return if request_ids.empty?
 
         @task_monitor.update_heartbeats(request_ids)
 
-        @config.logger&.debug("[PatientHttp::Sidekiq] Updated heartbeats for #{request_ids.size} inflight requests")
+        @config.logger&.debug("[PatientHttp::Sidekiq] Updated heartbeats for #{request_ids.size} tracked requests")
       rescue => e
         @config.logger&.error("[PatientHttp::Sidekiq] Failed to update heartbeats: #{e.class} - #{e.message}")
         raise if PatientHttp.testing?

data/lib/patient_http/sidekiq.rb

@@ -77,6 +77,7 @@ module PatientHttp
     autoload :CallbackWorker, File.join(__dir__, "sidekiq/callback_worker")
     autoload :Configuration, File.join(__dir__, "sidekiq/configuration")
     autoload :Context, File.join(__dir__, "sidekiq/context")
+    autoload :DirectTaskHandler, File.join(__dir__, "sidekiq/direct_task_handler")
     autoload :ProcessorObserver, File.join(__dir__, "sidekiq/processor_observer")
     autoload :RequestExecutor, File.join(__dir__, "sidekiq/request_executor")
     autoload :RequestWorker, File.join(__dir__, "sidekiq/request_worker")
@@ -220,7 +221,9 @@ module PatientHttp
       # Nested calls merge options with the innermost values taking precedence.
       # If the options include a queue, the callback job for the request is
       # enqueued on that queue as well. Options only apply to requests enqueued
-      # in the same fiber as the block. This method has no effect
+      # in the same fiber as the block. Requests made in the block always go
+      # through the Sidekiq queue, even when direct execution is enabled, so
+      # that Sidekiq applies the options. This method has no effect
       # when jobs run inline with Sidekiq::Testing.inline!.
       #
       # @param options [Hash] Sidekiq job options (symbol or string keys)
@@ -260,7 +263,8 @@ module PatientHttp
         callback_args = PatientHttp::CallbackValidator.validate_callback_args(callback_args)
         request_id = SecureRandom.uuid
 
-        encrypted = encrypt(request.as_json)
+        request_json = request.as_json
+        encrypted = encrypt(request_json)
 
         data = if external_storage.enabled?
           external_storage.store(encrypted, max_size: configuration.payload_store_threshold)
@@ -272,9 +276,22 @@ module PatientHttp
         if options&.any?
           queue = options["queue"]
           options = options.merge("patient_http_callback_queue" => queue.to_s) if queue
-          RequestWorker.set(options).perform_async(data, callback_name, raise_error_responses, callback_args, request_id)
+        end
+        args = [data, callback_name, raise_error_responses, callback_args, request_id]
+
+        if direct_execution?(options)
+          execute_on_local_processor(
+            request_json,
+            args,
+            callback_name: callback_name,
+            raise_error_responses: raise_error_responses,
+            callback_args: callback_args,
+            request_id: request_id
+          )
+        elsif options&.any?
+          RequestWorker.set(options).perform_async(*args)
         else
-          RequestWorker.perform_async(data, callback_name, raise_error_responses, callback_args, request_id)
+          RequestWorker.perform_async(*args)
         end
 
         request_id
@@ -395,6 +412,56 @@ module PatientHttp
       def current_sidekiq_options
         Thread.current[:patient_http_sidekiq_options]
       end
+
+      # Check if the request can go directly to a processor running in the current
+      # process. Requests made in a with_sidekiq_options block always go through
+      # the queue so that Sidekiq applies the options (queue routing, scheduling,
+      # retry), and Sidekiq testing modes must keep their normal enqueue semantics.
+      #
+      # @param options [Hash, nil] scoped Sidekiq options for the request
+      # @return [Boolean]
+      def direct_execution?(options)
+        return false unless options.nil?
+        return false unless configuration.direct_execution?
+        return false unless running?
+        return false if defined?(::Sidekiq::Testing) && ::Sidekiq::Testing.enabled?
+
+        true
+      end
+
+      # Hand the request to the processor running in the current process. If the
+      # processor cannot accept the request (at capacity or shutting down), the
+      # request is enqueued as a normal RequestWorker job instead through the
+      # same retry path the processor uses when it drains.
+      #
+      # @param request_json [Hash] the serialized request
+      # @param args [Array] the RequestWorker job arguments
+      # @param callback_name [String] the callback service class name
+      # @param raise_error_responses [Boolean] whether non-2xx responses are errors
+      # @param callback_args [Hash, nil] arguments to pass to the callback
+      # @param request_id [String] unique request ID
+      # @return [void]
+      def execute_on_local_processor(request_json, args, callback_name:, raise_error_responses:, callback_args:, request_id:)
+        task_handler = DirectTaskHandler.new(args)
+
+        begin
+          # Reload the request from its serialized form so the direct path
+          # processes the same reconstructed request a RequestWorker job would.
+          RequestExecutor.execute(
+            PatientHttp::Request.load(request_json),
+            callback: callback_name,
+            raise_error_responses: raise_error_responses,
+            callback_args: callback_args,
+            task_handler: task_handler,
+            request_id: request_id
+          )
+        rescue PatientHttp::NotRunningError, PatientHttp::MaxCapacityError => e
+          configuration.logger&.info(
+            "[PatientHttp::Sidekiq] Falling back to enqueuing request: #{e.message}"
+          )
+          task_handler.retry
+        end
+      end
     end
   end
 

data/patient_http-sidekiq.gemspec

@@ -40,5 +40,5 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 3.2"
 
   spec.add_dependency "sidekiq", ">= 7.0"
-  spec.add_dependency "patient_http", ">= 1.3.0"
+  spec.add_dependency "patient_http", ">= 1.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patient_http-sidekiq
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Brian Durand
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.4.0
 description: This gem provides a mechanism to offload long-running HTTP requests from
   Sidekiq workers to a dedicated async I/O processor running in the same process,
   freeing the worker thread immediately while the HTTP request is in flight.
@@ -56,6 +56,7 @@ files:
 - lib/patient_http/sidekiq/callback_worker.rb
 - lib/patient_http/sidekiq/configuration.rb
 - lib/patient_http/sidekiq/context.rb
+- lib/patient_http/sidekiq/direct_task_handler.rb
 - lib/patient_http/sidekiq/lifecycle_hooks.rb
 - lib/patient_http/sidekiq/processor_observer.rb
 - lib/patient_http/sidekiq/request_executor.rb