patient_http-sidekiq 1.0.0

data/lib/patient_http/sidekiq/stats.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module PatientHttp
+  module Sidekiq
+    # Stores processor statistics in Redis with automatic expiration.
+    #
+    # This singleton class tracks various metrics about async HTTP requests,
+    # including total requests, errors, refused requests, and current inflight counts
+    # across all processes. Statistics are stored in Redis with appropriate TTLs.
+    class Stats
+      # Redis key prefixes
+      TOTALS_KEY = "sidekiq:patient_http:totals"
+
+      # TTLs
+      TOTALS_TTL = 30 * 24 * 60 * 60 # 30 days in seconds
+
+      def initialize(config = nil)
+        @hostname = ::Socket.gethostname.force_encoding("UTF-8").freeze
+        @pid = ::Process.pid
+        @config = config
+      end
+
+      # Record a completed request.
+      #
+      # @param status [Integer, nil] HTTP response status code
+      # @param duration [Float] request duration in seconds
+      # @return [void]
+      def record_request(status, duration)
+        ::Sidekiq.redis do |redis|
+          redis.multi do |transaction|
+            transaction.hincrby(TOTALS_KEY, "requests", 1)
+            transaction.hincrbyfloat(TOTALS_KEY, "duration", duration.to_f)
+            transaction.hincrby(TOTALS_KEY, "http_status:#{status}", 1) if status && status >= 100 && status < 600
+            transaction.expire(TOTALS_KEY, TOTALS_TTL)
+          end
+        end
+      rescue => e
+        handle_error(e)
+      end
+
+      # Record a request error
+      #
+      # @param error_type [String] the type of error that occurred
+      # @return [void]
+      def record_error(error_type)
+        ::Sidekiq.redis do |redis|
+          redis.multi do |transaction|
+            transaction.hincrby(TOTALS_KEY, "errors", 1)
+            transaction.hincrby(TOTALS_KEY, "errors:#{error_type}", 1)
+            transaction.expire(TOTALS_KEY, TOTALS_TTL)
+          end
+        end
+      rescue => e
+        handle_error(e)
+      end
+
+      # Record a that a request was refused because the max capacity of the Processor was reached.
+      #
+      # @return [void]
+      def record_capacity_exceeded
+        ::Sidekiq.redis do |redis|
+          redis.multi do |transaction|
+            transaction.hincrby(TOTALS_KEY, "max_capacity_exceeded", 1)
+            transaction.expire(TOTALS_KEY, TOTALS_TTL)
+          end
+        end
+      rescue => e
+        handle_error(e)
+      end
+
+      # Get running totals
+      #
+      # @return [Hash] hash with requests, duration, errors, max_capacity_exceeded, http_status_counts
+      def get_totals
+        ::Sidekiq.redis do |redis|
+          stats = redis.hgetall(TOTALS_KEY)
+
+          # Extract HTTP status counts and error type counts
+          http_status_counts = {}
+          error_type_counts = {}
+          stats.each do |key, value|
+            if key.start_with?("http_status:")
+              status = key.sub("http_status:", "").to_i
+              http_status_counts[status] = value.to_i
+            elsif key.start_with?("errors:") && key != "errors"
+              error_type = key.sub("errors:", "")
+              error_type_counts[error_type] = value.to_i
+            end
+          end
+
+          {
+            "requests" => (stats["requests"] || 0).to_i,
+            "duration" => (stats["duration"] || 0).to_f.round(6),
+            "errors" => (stats["errors"] || 0).to_i,
+            "max_capacity_exceeded" => (stats["max_capacity_exceeded"] || 0).to_i,
+            "http_status_counts" => http_status_counts.sort.to_h,
+            "error_type_counts" => error_type_counts.sort.to_h
+          }
+        end
+      end
+
+      # Reset all stats (useful for testing)
+      #
+      # @return [void]
+      def reset!
+        ::Sidekiq.redis do |redis|
+          redis.del(TOTALS_KEY)
+        end
+      end
+
+      private
+
+      def handle_error(error)
+        @config&.logger&.error("[PatientHttp::Sidekiq] Stats error: #{error.inspect}")
+        raise error if ::Sidekiq.testing?
+      end
+    end
+  end
+end

data/lib/patient_http/sidekiq/task_handler.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module PatientHttp
+  module Sidekiq
+    # Sidekiq implementation of TaskHandler.
+    #
+    # Handles task lifecycle operations using Sidekiq for job management:
+    # - Completion and error callbacks are triggered via CallbackWorker
+    # - Large payloads are stored via ExternalStorage before enqueuing
+    # - Job retry uses Sidekiq::Client.push
+    class TaskHandler < PatientHttp::TaskHandler
+      # @return [Hash] The Sidekiq job hash containing class, jid, args, etc.
+      #   Exposed for TaskMonitor crash recovery serialization.
+      attr_reader :sidekiq_job
+
+      # @param sidekiq_job [Hash] The Sidekiq job hash with "class", "jid", "args", etc.
+      def initialize(sidekiq_job)
+        @sidekiq_job = sidekiq_job
+      end
+
+      # Trigger the completion callback with the response.
+      #
+      # Stores the response via ExternalStorage (for large payloads) and
+      # enqueues a CallbackWorker to invoke the callback asynchronously.
+      #
+      # @param response [Response] the HTTP response object
+      # @param callback [String] callback class name
+      # @return [void]
+      def on_complete(response, callback)
+        data = store_if_needed(response.as_json)
+        CallbackWorker.perform_async(data, "response", callback)
+      end
+
+      # Trigger the error callback with the error.
+      #
+      # Stores the error via ExternalStorage (for large payloads) and
+      # enqueues a CallbackWorker to invoke the callback asynchronously.
+      #
+      # @param error [Error] the error object
+      # @param callback [String] callback class name
+      # @return [void]
+      def on_error(error, callback)
+        data = store_if_needed(error.as_json)
+        CallbackWorker.perform_async(data, "error", callback)
+      end
+
+      # Re-enqueue the original Sidekiq job for retry.
+      #
+      # @return [String] the job ID
+      def retry
+        ::Sidekiq::Client.push(@sidekiq_job)
+      end
+
+      # Return the job ID from the Sidekiq job.
+      #
+      # @return [String] job ID
+      def job_id
+        @sidekiq_job["jid"]
+      end
+
+      # Return the worker class from the Sidekiq job.
+      #
+      # @return [Class] worker class
+      def worker_class
+        PatientHttp::ClassHelper.resolve_class_name(@sidekiq_job["class"])
+      end
+
+      private
+
+      def store_if_needed(data)
+        encrypted = Sidekiq.encrypt(data)
+        external_storage = PatientHttp::Sidekiq.external_storage
+        if external_storage.enabled?
+          external_storage.store(encrypted, max_size: PatientHttp::Sidekiq.configuration.payload_store_threshold)
+        else
+          encrypted
+        end
+      end
+    end
+  end
+end