activejob-temporal 0.1.0 → 0.3.0

data/lib/activejob/temporal/dependency_options.rb

@@ -9,8 +9,9 @@ module ActiveJob
       JOB_CLASS_NAME_PATTERN = /\A[A-Z]\w*(?:::[A-Z]\w*)*\z/
       SAFE_ID_PATTERN = /\A[A-Za-z0-9_.:-]+\z/
       FAILURE_POLICIES = %i[fail ignore].freeze
+      WAIT_OPTION_KEYS = %i[timeout initial_interval max_interval backoff].freeze
 
-      attr_reader :temporal_dependencies, :temporal_dependency_failure_policy
+      attr_reader :temporal_dependencies, :temporal_dependency_failure_policy, :temporal_dependency_wait
 
       def self.normalize(depends_on)
         dependencies = depends_on.is_a?(Array) ? depends_on : [depends_on]
@@ -28,6 +29,17 @@ module ActiveJob
         raise ArgumentError, "on_dependency_failure must be :fail or :ignore"
       end
 
+      def self.normalize_wait_options(options)
+        raise ArgumentError, "dependency_wait must be a hash" unless options.is_a?(Hash)
+
+        normalized = options.each_with_object({}) do |(key, value), wait_options|
+          normalized_key = normalize_wait_option_key(key)
+          wait_options[normalized_key] = normalize_wait_option_value(normalized_key, value)
+        end
+        validate_wait_interval_order!(normalized)
+        normalized
+      end
+
       def self.normalize_dependency(dependency)
         return normalize_job_dependency(dependency) if dependency.is_a?(ActiveJob::Base)
         return normalize_hash_dependency(dependency) if dependency.is_a?(Hash)
@@ -55,10 +67,12 @@ module ActiveJob
         normalized = {}
         job_id = hash_value(dependency, :job_id)
         workflow_id = hash_value(dependency, :workflow_id)
+        run_id = hash_value(dependency, :run_id)
         job_class = hash_value(dependency, :job_class)
 
         normalized[:job_id] = normalize_id(job_id, "job_id") if job_id
         normalized[:workflow_id] = normalize_id(workflow_id, "workflow_id") if workflow_id
+        normalized[:run_id] = normalize_id(run_id, "run_id") if run_id
         normalized[:job_class] = normalize_job_class(job_class) if job_class
 
         if normalized[:job_id].nil? && normalized[:workflow_id].nil?
@@ -97,36 +111,132 @@ module ActiveJob
       end
       private_class_method :hash_value
 
-      def set(options = {})
-        enqueue_options = options.dup
-        dependencies_configured = enqueue_options.key?(:depends_on)
-        failure_policy_configured = enqueue_options.key?(:on_dependency_failure)
+      def self.normalize_wait_option_key(key)
+        normalized_key = key.to_sym
+        return normalized_key if WAIT_OPTION_KEYS.include?(normalized_key)
 
-        normalized_dependencies = if dependencies_configured
-                                    DependencyOptions.normalize(enqueue_options.delete(:depends_on))
-                                  end
-        normalized_failure_policy = normalize_dependency_failure_policy(
-          enqueue_options.delete(:on_dependency_failure),
-          failure_policy_configured
-        )
+        raise ArgumentError, "dependency_wait supports: #{WAIT_OPTION_KEYS.join(', ')}"
+      rescue NoMethodError
+        raise ArgumentError, "dependency_wait supports: #{WAIT_OPTION_KEYS.join(', ')}"
+      end
+      private_class_method :normalize_wait_option_key
+
+      def self.normalize_wait_option_value(key, value)
+        return normalize_wait_backoff(value) if key == :backoff
 
-        if failure_policy_configured && !dependencies_configured && normalized_dependencies.nil?
-          raise ArgumentError, "on_dependency_failure requires depends_on"
+        normalize_wait_duration(value, key)
+      end
+      private_class_method :normalize_wait_option_value
+
+      def self.normalize_wait_duration(value, key)
+        unless value.is_a?(Numeric) || value.is_a?(ActiveSupport::Duration)
+          raise ArgumentError, "dependency_wait #{key} must be a duration"
         end
 
+        seconds = value.to_f
+        raise ArgumentError, "dependency_wait #{key} must be positive" unless seconds.positive?
+
+        seconds
+      end
+      private_class_method :normalize_wait_duration
+
+      def self.normalize_wait_backoff(value)
+        backoff = Float(value)
+        raise ArgumentError, "dependency_wait backoff must be greater than or equal to 1" if backoff < 1.0
+
+        backoff
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "dependency_wait backoff must be greater than or equal to 1"
+      end
+      private_class_method :normalize_wait_backoff
+
+      def self.validate_wait_interval_order!(wait_options)
+        initial_interval = wait_options[:initial_interval]
+        max_interval = wait_options[:max_interval]
+        return unless initial_interval && max_interval
+        return if max_interval >= initial_interval
+
+        raise ArgumentError, "dependency_wait max_interval must be greater than or equal to initial_interval"
+      end
+      private_class_method :validate_wait_interval_order!
+
+      def set(options = {})
+        enqueue_options = options.dup
+        dependency_options = normalize_dependency_set_options(enqueue_options)
+        validate_dependency_set_options!(dependency_options)
+
         super(enqueue_options).tap do
-          @temporal_dependencies = normalized_dependencies if dependencies_configured
-          @temporal_dependency_failure_policy = normalized_failure_policy || :fail if dependencies_configured
+          apply_dependency_set_options(dependency_options)
         end
       end
 
       private
 
+      def normalize_dependency_set_options(enqueue_options)
+        dependencies_configured = enqueue_options.key?(:depends_on)
+        failure_policy_configured = enqueue_options.key?(:on_dependency_failure)
+        dependency_wait_configured = enqueue_options.key?(:dependency_wait)
+
+        {
+          dependencies_configured: dependencies_configured,
+          failure_policy_configured: failure_policy_configured,
+          dependency_wait_configured: dependency_wait_configured,
+          dependencies: normalize_dependencies(enqueue_options, dependencies_configured),
+          failure_policy: normalize_dependency_failure_policy(
+            enqueue_options.delete(:on_dependency_failure),
+            failure_policy_configured
+          ),
+          dependency_wait: normalize_dependency_wait(enqueue_options, dependency_wait_configured)
+        }
+      end
+
+      def normalize_dependencies(enqueue_options, configured)
+        return unless configured
+
+        DependencyOptions.normalize(enqueue_options.delete(:depends_on))
+      end
+
+      def normalize_dependency_wait(enqueue_options, configured)
+        return unless configured
+
+        DependencyOptions.normalize_wait_options(enqueue_options.delete(:dependency_wait))
+      end
+
       def normalize_dependency_failure_policy(policy, configured)
         return unless configured
 
         DependencyOptions.normalize_failure_policy(policy)
       end
+
+      def validate_dependency_set_options!(dependency_options)
+        dependencies_configured = dependency_options[:dependencies_configured]
+        validate_dependency_requirement!(
+          dependency_options[:failure_policy_configured],
+          dependencies_configured,
+          "on_dependency_failure requires depends_on"
+        )
+        validate_dependency_requirement!(
+          dependency_options[:dependency_wait_configured],
+          dependencies_configured,
+          "dependency_wait requires depends_on"
+        )
+      end
+
+      def validate_dependency_requirement!(configured, dependencies_configured, message)
+        return if !configured || dependencies_configured
+
+        raise ArgumentError, message
+      end
+
+      def apply_dependency_set_options(dependency_options)
+        if dependency_options[:dependencies_configured]
+          @temporal_dependencies = dependency_options[:dependencies]
+          @temporal_dependency_failure_policy = dependency_options[:failure_policy] || :fail
+        end
+        return unless dependency_options[:dependency_wait_configured]
+
+        @temporal_dependency_wait = dependency_options[:dependency_wait]
+      end
     end
   end
 end

data/lib/activejob/temporal/health_check_server.rb

@@ -6,17 +6,21 @@ require "socket"
 
 require_relative "connection_worker_pool"
 require_relative "bind_policy"
+require_relative "http_request_failure_handling"
 require_relative "http_line_reader"
 
 module ActiveJob
   module Temporal
     class HealthCheckServer
       include HttpLineReader
+      include HttpRequestFailureHandling
 
       DEFAULT_BIND_ADDRESS = "127.0.0.1"
       READ_TIMEOUT_SECONDS = 1
       CONNECTION_WORKERS = 4
       CONNECTION_QUEUE_SIZE = 16
+      REQUEST_FAILURE_EVENT = "health_check_request_failed"
+      REQUEST_FAILURE_FORMAT = :json
 
       attr_reader :port, :bind_address
 
@@ -84,25 +88,24 @@ module ActiveJob
           connection_pool.enqueue(server.accept)
         rescue IOError, Errno::EBADF
           break
+        rescue SystemCallError => e
+          # Transient accept failures (fd exhaustion, aborted connections) must not kill the listener.
+          ActiveJob::Temporal::Logger.error(
+            "health_check_accept_failed", error_class: e.class.name, message: e.message.to_s
+          )
+          sleep 0.05
         end
       ensure
         @mutex.synchronize { @running = false if @server }
       end
 
-      def serve_client(client)
-        handle_client(client)
-      rescue IOError, SystemCallError
-        nil
-      ensure
-        client&.close
-      end
-
       def handle_client(client)
-        request_line = read_line(client)
+        deadline = request_deadline
+        request_line = read_line(client, deadline)
         return unless request_line
 
         method, path = request_line.split.first(2)
-        drain_headers(client)
+        drain_headers(client, deadline)
 
         unless method && path
           write_json(client, 400, { error: "bad_request" })
@@ -128,13 +131,6 @@ module ActiveJob
         payload[:worker_running] ? 200 : 503
       end
 
-      def drain_headers(client)
-        loop do
-          line = read_line(client)
-          break if line.nil? || line == "\r\n" || line == "\n"
-        end
-      end
-
       def write_json(client, status, payload, body: true)
         json = JSON.generate(payload)
         response = "HTTP/1.1 #{status} #{reason_phrase(status)}\r\n"
@@ -151,6 +147,7 @@ module ActiveJob
           400 => "Bad Request",
           404 => "Not Found",
           405 => "Method Not Allowed",
+          500 => "Internal Server Error",
           503 => "Service Unavailable"
         }.fetch(status)
       end

data/lib/activejob/temporal/http_line_reader.rb

@@ -2,11 +2,21 @@
 
 module ActiveJob
   module Temporal
+    # Bounded line reading for the embedded HTTP endpoints: one deadline for the
+    # whole request plus caps on line length and header count, so a slow or
+    # oversized client cannot hold a connection worker.
     module HttpLineReader
+      MAX_LINE_BYTES = 8_192
+      MAX_HEADER_LINES = 100
+
       private
 
-      def read_line(client)
-        deadline = monotonic_time + self.class.const_get(:READ_TIMEOUT_SECONDS)
+      # @return [Float] monotonic deadline covering an entire request
+      def request_deadline
+        monotonic_time + self.class.const_get(:READ_TIMEOUT_SECONDS)
+      end
+
+      def read_line(client, deadline)
         buffer = +""
 
         loop do
@@ -24,10 +34,18 @@ module ActiveJob
           else
             buffer << chunk
             return buffer if chunk == "\n"
+            return if buffer.bytesize >= MAX_LINE_BYTES
           end
         end
       end
 
+      def drain_headers(client, deadline)
+        MAX_HEADER_LINES.times do
+          line = read_line(client, deadline)
+          break if line.nil? || line == "\r\n" || line == "\n"
+        end
+      end
+
       def monotonic_time
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end

data/lib/activejob/temporal/http_request_failure_handling.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Temporal
+    module HttpRequestFailureHandling
+      private
+
+      def serve_client(client)
+        handle_client(client)
+      rescue IOError, SystemCallError
+        nil
+      rescue StandardError => e
+        log_request_failure(e)
+        write_failure_response(client)
+      ensure
+        client&.close
+      end
+
+      def write_failure_response(client)
+        case self.class::REQUEST_FAILURE_FORMAT
+        when :json
+          write_json(client, 500, { error: "internal_server_error" })
+        when :text
+          write_text(client, 500, "internal_server_error\n")
+        end
+      rescue IOError, SystemCallError
+        nil
+      end
+
+      def log_request_failure(error)
+        ActiveJob::Temporal::Logger.error(
+          self.class::REQUEST_FAILURE_EVENT,
+          error_class: error.class.name,
+          message: error.message.to_s
+        )
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/activejob/temporal/inspect.rb

@@ -2,13 +2,13 @@
 
 require "temporalio/client/workflow_execution_status"
 require "temporalio/error"
+require_relative "job_id_validation"
 require_relative "visibility_query"
 require_relative "workflow_id_builder"
 
 module ActiveJob
   module Temporal
     module Inspect
-      UUID_REGEX = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
       JOB_CLASS_NAME_PATTERN = /\A[A-Z]\w*(?:::[A-Z]\w*)*\z/
       WORKFLOW_STATES = {
         Temporalio::Client::WorkflowExecutionStatus::RUNNING => :running,
@@ -26,7 +26,8 @@ module ActiveJob
           validate_job_id!(job_id)
 
           client = ActiveJob::Temporal.client
-          describe_default_workflow(client, job_class, job_id) ||
+          describe_schedule_execution_workflow(client, job_id) ||
+            describe_default_workflow(client, job_class, job_id) ||
             describe_search_attribute_workflow(client, job_class, job_id)
         rescue ArgumentError
           raise
@@ -40,7 +41,9 @@ module ActiveJob
         def completed?(job_class, job_id) = workflow_state?(job_class, job_id, :completed)
 
         def failed?(job_class, job_id) = workflow_state?(job_class, job_id, :failed)
+      end
 
+      class << self
         private
 
         def workflow_state?(job_class, job_id, state)
@@ -58,11 +61,7 @@ module ActiveJob
         end
 
         def validate_job_id!(job_id)
-          return if job_id.is_a?(String) && job_id.match?(UUID_REGEX)
-
-          raise ArgumentError,
-                "Invalid job_id format: expected UUID (e.g., '550e8400-e29b-41d4-a716-446655440000'), " \
-                "got: #{job_id.inspect}"
+          JobIdValidation.validate!(job_id)
         end
 
         def describe_default_workflow(client, job_class, job_id)
@@ -73,6 +72,17 @@ module ActiveJob
           nil
         end
 
+        def describe_schedule_execution_workflow(client, job_id)
+          workflow_reference = JobIdValidation.schedule_execution_reference(job_id)
+          return unless workflow_reference
+
+          describe_workflow(client, workflow_reference)
+        rescue StandardError => e
+          raise unless rpc_not_found?(e)
+
+          nil
+        end
+
         def describe_search_attribute_workflow(client, job_class, job_id)
           workflow_reference = find_workflow_reference(client, job_class, job_id)
           return unless workflow_reference

data/lib/activejob/temporal/job_id_validation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "workflow_id_builder"
+
+module ActiveJob
+  module Temporal
+    module JobIdValidation
+      MAX_JOB_ID_LENGTH = WorkflowIdBuilder::MAX_WORKFLOW_ID_LENGTH
+      CONTROL_CHARACTER_PATTERN = WorkflowIdBuilder::CONTROL_CHARACTER_PATTERN
+      SCHEDULE_WORKFLOW_ID_PREFIX = "ajschwf:"
+
+      module_function
+
+      def validate!(job_id)
+        unless job_id.is_a?(String)
+          raise ArgumentError, "job_id must be a String, got #{job_id.class}: #{job_id.inspect}"
+        end
+
+        raise ArgumentError, "job_id must be valid UTF-8" unless job_id.valid_encoding?
+        raise ArgumentError, "job_id must not be blank" if job_id.strip.empty?
+
+        if job_id.length > MAX_JOB_ID_LENGTH
+          raise ArgumentError, "job_id maximum length is #{MAX_JOB_ID_LENGTH} characters (got #{job_id.length})"
+        end
+
+        return unless job_id.match?(CONTROL_CHARACTER_PATTERN)
+
+        raise ArgumentError, "job_id control characters are not allowed (got #{job_id.inspect})"
+      end
+
+      def schedule_execution_reference(job_id)
+        return unless job_id.start_with?(SCHEDULE_WORKFLOW_ID_PREFIX)
+
+        workflow_id, separator, run_id = job_id.rpartition(":")
+        return if separator.empty? || workflow_id.empty? || run_id.empty?
+
+        { workflow_id: workflow_id, run_id: run_id }
+      end
+    end
+  end
+end

data/lib/activejob/temporal/job_payload_dependencies.rb

@@ -16,6 +16,7 @@ module ActiveJob
         payload[:dependencies] = dependencies.map { |dependency| enrich_dependency(dependency) }
         policy = job.respond_to?(:temporal_dependency_failure_policy) ? job.temporal_dependency_failure_policy : :fail
         payload[:dependency_failure_policy] = policy.to_s
+        payload[:dependency_wait] = dependency_wait_options(job)
       end
 
       def enrich_dependency(dependency)
@@ -35,6 +36,28 @@ module ActiveJob
         WorkflowIdBuilder.validate!(workflow_id)
         workflow_id
       end
+
+      def dependency_wait_options(job)
+        default_dependency_wait_options.merge(job_dependency_wait_options(job))
+      end
+
+      def default_dependency_wait_options
+        {
+          timeout: @config.dependency_wait_timeout.to_f,
+          initial_interval: @config.dependency_wait_initial_interval.to_f,
+          max_interval: @config.dependency_wait_max_interval.to_f,
+          backoff: @config.dependency_wait_backoff.to_f
+        }
+      end
+
+      def job_dependency_wait_options(job)
+        return {} unless job.respond_to?(:temporal_dependency_wait)
+
+        dependency_wait = job.temporal_dependency_wait
+        return {} unless dependency_wait.is_a?(Hash)
+
+        dependency_wait
+      end
     end
   end
 end

data/lib/activejob/temporal/locales/en.yml

@@ -101,18 +101,30 @@ en:
               not_a_duration: "must be a duration (e.g., 1.day or 6.hours), got: %{value}"
               duration_not_positive: "must be positive (got: %{seconds} seconds). Use values like 1.hour or 7.days"
 
+            dependency_wait_timeout:
+              not_a_duration: "must be a duration (e.g., 10.minutes or 1.day), got: %{value}"
+              duration_not_positive: "must be positive (got: %{seconds} seconds). Use values like 1.minute or 1.day"
+
+            dependency_wait_initial_interval:
+              not_a_duration: "must be a duration (e.g., 5.seconds or 1.minute), got: %{value}"
+              duration_not_positive: "must be positive (got: %{seconds} seconds). Use values like 5.seconds or 1.minute"
+
+            dependency_wait_max_interval:
+              not_a_duration: "must be a duration (e.g., 30.seconds or 5.minutes), got: %{value}"
+              duration_not_positive: "must be positive (got: %{seconds} seconds). Use values like 30.seconds or 5.minutes"
+
             tls_cert_path:
               requires_key_path: "requires tls_key_path so the client certificate and private key rotate together"
               invalid_path: "must be a non-empty file path, got: %{value}"
-              unreadable_path: "must point to a readable, non-symlink file, got: %{value}"
+              unreadable_path: "must resolve to a readable regular file, got: %{value}"
 
             tls_key_path:
               invalid_path: "must be a non-empty file path, got: %{value}"
-              unreadable_path: "must point to a readable, non-symlink file, got: %{value}"
+              unreadable_path: "must resolve to a readable regular file, got: %{value}"
 
             tls_server_root_ca_cert_path:
               invalid_path: "must be a non-empty file path, got: %{value}"
-              unreadable_path: "must point to a readable, non-symlink file, got: %{value}"
+              unreadable_path: "must resolve to a readable regular file, got: %{value}"
 
             tls_domain:
               blank: "must be present when configured"
@@ -124,3 +136,18 @@ en:
             tls_reload_signal:
               blank: "must be present when configured"
               invalid: "must be a signal name like HUP or USR1, got: %{value}"
+
+            api_key_file:
+              invalid_path: "must be a non-empty file path, got: %{value}"
+              unreadable_path: "must resolve to a readable regular file, got: %{value}"
+
+            api_key_watch:
+              not_boolean: "must be true or false, got: %{value}"
+              requires_path: "requires api_key_file to watch"
+
+            worker_activejob_workloads:
+              not_boolean: "must be true or false, got: %{value}"
+              requires_activities: "requires worker_activities when disabled - the worker would have nothing to register"
+
+            graceful_shutdown_period:
+              graceful_shutdown_period_negative: "must be >= 0 seconds, got: %{value}"

data/lib/activejob/temporal/metrics_server.rb

@@ -5,18 +5,22 @@ require "socket"
 
 require_relative "connection_worker_pool"
 require_relative "bind_policy"
+require_relative "http_request_failure_handling"
 require_relative "http_line_reader"
 
 module ActiveJob
   module Temporal
     class MetricsServer
       include HttpLineReader
+      include HttpRequestFailureHandling
 
       DEFAULT_BIND_ADDRESS = "127.0.0.1"
       READ_TIMEOUT_SECONDS = 1
       CONTENT_TYPE = "text/plain; version=0.0.4"
       CONNECTION_WORKERS = 4
       CONNECTION_QUEUE_SIZE = 16
+      REQUEST_FAILURE_EVENT = "metrics_request_failed"
+      REQUEST_FAILURE_FORMAT = :text
 
       attr_reader :port, :bind_address
 
@@ -86,25 +90,24 @@ module ActiveJob
           connection_pool.enqueue(server.accept)
         rescue IOError, Errno::EBADF
           break
+        rescue SystemCallError => e
+          # Transient accept failures (fd exhaustion, aborted connections) must not kill the listener.
+          ActiveJob::Temporal::Logger.error(
+            "metrics_accept_failed", error_class: e.class.name, message: e.message.to_s
+          )
+          sleep 0.05
         end
       ensure
         @mutex.synchronize { @running = false if @server }
       end
 
-      def serve_client(client)
-        handle_client(client)
-      rescue IOError, SystemCallError
-        nil
-      ensure
-        client&.close
-      end
-
       def handle_client(client)
-        request_line = read_line(client)
+        deadline = request_deadline
+        request_line = read_line(client, deadline)
         return unless request_line
 
         method, path = request_line.split.first(2)
-        drain_headers(client)
+        drain_headers(client, deadline)
 
         unless method && path
           write_text(client, 400, "bad_request\n")
@@ -121,13 +124,6 @@ module ActiveJob
         end
       end
 
-      def drain_headers(client)
-        loop do
-          line = read_line(client)
-          break if line.nil? || line == "\r\n" || line == "\n"
-        end
-      end
-
       def write_text(client, status, payload, body: true)
         response = "HTTP/1.1 #{status} #{reason_phrase(status)}\r\n"
         response << "Content-Type: #{CONTENT_TYPE}\r\n"
@@ -142,7 +138,8 @@ module ActiveJob
           200 => "OK",
           400 => "Bad Request",
           404 => "Not Found",
-          405 => "Method Not Allowed"
+          405 => "Method Not Allowed",
+          500 => "Internal Server Error"
         }.fetch(status)
       end
     end

data/lib/activejob/temporal/middleware/chain.rb

@@ -16,6 +16,13 @@ module ActiveJob
           entries.each { |entry| add(entry) }
         end
 
+        def initialize_copy(original)
+          super
+          @entries = original.instance_variable_get(:@entries).dup
+          @entry_indexes_by_key = original.instance_variable_get(:@entry_indexes_by_key).dup
+          @compiled_call_chain = compile_call_chain
+        end
+
         def add(middleware, *args, **kwargs, &block)
           key = entry_key(middleware, args, kwargs, block)
           callable = build_callable(middleware, args, kwargs, block)

data/lib/activejob/temporal/observability.rb

@@ -164,6 +164,13 @@ module ActiveJob
 
         def initialize
           @adapters = []
+          @stop_replaced_adapters = true
+        end
+
+        def initialize_copy(original)
+          super
+          @adapters = original.adapters.dup
+          @stop_replaced_adapters = false
         end
 
         def use(name, **)
@@ -185,7 +192,7 @@ module ActiveJob
         end
 
         def reset!
-          adapters.each(&:stop!)
+          adapters.each(&:stop!) if @stop_replaced_adapters
           adapters.clear
         end
 
@@ -193,11 +200,16 @@ module ActiveJob
           adapters.each(&:validate!)
         end
 
+        def finalize_configuration_copy!
+          @stop_replaced_adapters = true
+          self
+        end
+
         private
 
         def replace_adapter(adapter)
           previous_adapter = self.adapter(adapter.name)
-          previous_adapter&.stop!
+          previous_adapter&.stop! if @stop_replaced_adapters
           adapters.delete(previous_adapter)
           adapters << adapter
         end