fiber_audit 0.3.0 → 0.3.1

data/lib/fiber_audit/operation_semantics.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module FiberAudit
+  # rubocop:disable Metrics/ModuleLength
+  module OperationSemantics
+    CAPABILITIES = %i[block kernel_sleep io_select process_wait address_resolve].freeze
+    CATEGORIES = %i[
+      creation replacement waiting detach stream thread_wait synchronization
+      nonblocking_try thread_state io_select socket_allocation socket_resolve_connect
+      socket_local_connect socket_constructor_unknown http_io unknown
+    ].freeze
+
+    Profile = Data.define(:category, :wait_possible, :inventory_only, :scheduler_capability) do
+      def initialize(category:, wait_possible:, inventory_only:, scheduler_capability: nil)
+        normalized_category = category.to_sym if category.respond_to?(:to_sym)
+        unless CATEGORIES.include?(normalized_category)
+          raise RuntimeContractError, "unknown operation semantic category: #{category.inspect}"
+        end
+
+        [[:wait_possible, wait_possible], [:inventory_only, inventory_only]].each do |name, value|
+          next if value.nil? || [true, false].include?(value)
+
+          raise RuntimeContractError, "#{name} must be a Boolean or nil"
+        end
+
+        capability = scheduler_capability&.to_sym
+        unless capability.nil? || CAPABILITIES.include?(capability)
+          raise RuntimeContractError, "unknown scheduler capability: #{scheduler_capability.inspect}"
+        end
+
+        super(category: normalized_category, wait_possible: wait_possible,
+              inventory_only: inventory_only, scheduler_capability: capability)
+      end
+
+      def known? = category != :unknown
+      def scheduler_capability_required? = !scheduler_capability.nil?
+    end
+
+    UNKNOWN = Profile.new(category: :unknown, wait_possible: nil, inventory_only: nil).freeze
+    SOCKET_SUBCLASS = Profile.new(
+      category: :socket_constructor_unknown,
+      wait_possible: true,
+      inventory_only: false
+    ).freeze
+
+    TABLE = {
+      'Kernel.spawn' => Profile.new(category: :creation, wait_possible: false, inventory_only: true),
+      'Process.spawn' => Profile.new(category: :creation, wait_possible: false, inventory_only: true),
+      'Kernel.exec' => Profile.new(category: :replacement, wait_possible: false, inventory_only: true),
+      'Process.exec' => Profile.new(category: :replacement, wait_possible: false, inventory_only: true),
+      'Kernel.system' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                     scheduler_capability: :process_wait),
+      'Process.wait' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                    scheduler_capability: :process_wait),
+      'Process.wait2' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                     scheduler_capability: :process_wait),
+      'Process.waitpid' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                       scheduler_capability: :process_wait),
+      'Process.waitpid2' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                        scheduler_capability: :process_wait),
+      'Process.waitall' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                       scheduler_capability: :process_wait),
+      'Process::Status.wait' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                            scheduler_capability: :process_wait),
+      'Open3.capture2' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                      scheduler_capability: :process_wait),
+      'Open3.capture2e' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                       scheduler_capability: :process_wait),
+      'Open3.capture3' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                      scheduler_capability: :process_wait),
+      'Open3.pipeline' => Profile.new(category: :waiting, wait_possible: true, inventory_only: false,
+                                      scheduler_capability: :process_wait),
+      'Process.detach' => Profile.new(category: :detach, wait_possible: false, inventory_only: true),
+      'IO.popen' => Profile.new(category: :stream, wait_possible: true, inventory_only: false),
+      'Thread.join' => Profile.new(category: :thread_wait, wait_possible: true, inventory_only: false,
+                                   scheduler_capability: :block),
+      'Thread.value' => Profile.new(category: :thread_wait, wait_possible: true, inventory_only: false,
+                                    scheduler_capability: :block),
+      'Mutex#lock' => Profile.new(category: :synchronization, wait_possible: true, inventory_only: false,
+                                  scheduler_capability: :block),
+      'Mutex#synchronize' => Profile.new(category: :synchronization, wait_possible: true, inventory_only: false,
+                                         scheduler_capability: :block),
+      'Mutex#try_lock' => Profile.new(category: :nonblocking_try, wait_possible: false, inventory_only: false),
+      'ConditionVariable#wait' => Profile.new(category: :synchronization, wait_possible: true,
+                                              inventory_only: false, scheduler_capability: :kernel_sleep),
+      'Monitor#synchronize' => Profile.new(category: :synchronization, wait_possible: true,
+                                           inventory_only: false, scheduler_capability: :block),
+      'MonitorMixin#synchronize' => Profile.new(category: :synchronization, wait_possible: true,
+                                                inventory_only: false, scheduler_capability: :block),
+      'Thread.thread_variable_get' => Profile.new(category: :thread_state, wait_possible: false,
+                                                  inventory_only: true),
+      'Thread.thread_variable_set' => Profile.new(category: :thread_state, wait_possible: false,
+                                                  inventory_only: true),
+      'IO.select' => Profile.new(category: :io_select, wait_possible: true, inventory_only: false,
+                                 scheduler_capability: :io_select),
+      'Kernel.select' => Profile.new(category: :io_select, wait_possible: true, inventory_only: false,
+                                     scheduler_capability: :io_select),
+      'Socket.new' => Profile.new(category: :socket_allocation, wait_possible: false, inventory_only: true),
+      'IPSocket.new' => Profile.new(category: :socket_allocation, wait_possible: false, inventory_only: true),
+      'UDPSocket.new' => Profile.new(category: :socket_allocation, wait_possible: false, inventory_only: true),
+      'TCPSocket.new' => Profile.new(category: :socket_resolve_connect, wait_possible: true, inventory_only: false,
+                                     scheduler_capability: :address_resolve),
+      'TCPServer.new' => Profile.new(category: :socket_resolve_connect, wait_possible: true, inventory_only: false,
+                                     scheduler_capability: :address_resolve),
+      'UNIXSocket.new' => Profile.new(category: :socket_local_connect, wait_possible: true, inventory_only: false),
+      'UNIXServer.new' => Profile.new(category: :socket_allocation, wait_possible: false, inventory_only: true),
+      'Net::HTTP.get' => Profile.new(category: :http_io, wait_possible: true, inventory_only: false,
+                                     scheduler_capability: :address_resolve),
+      'Net::HTTP.get_response' => Profile.new(category: :http_io, wait_possible: true, inventory_only: false,
+                                              scheduler_capability: :address_resolve),
+      'Net::HTTP.start' => Profile.new(category: :http_io, wait_possible: true, inventory_only: false,
+                                       scheduler_capability: :address_resolve),
+      'Net::HTTP.request' => Profile.new(category: :http_io, wait_possible: true, inventory_only: false,
+                                         scheduler_capability: :address_resolve),
+      'URI.open' => Profile.new(category: :http_io, wait_possible: true, inventory_only: false,
+                                scheduler_capability: :address_resolve),
+      'OpenURI.open_uri' => Profile.new(category: :http_io, wait_possible: true, inventory_only: false,
+                                        scheduler_capability: :address_resolve)
+    }.freeze
+
+    FA1001_CATEGORIES = TABLE.slice(
+      'Kernel.spawn', 'Process.spawn', 'Kernel.exec', 'Process.exec', 'Kernel.system',
+      'Process.wait', 'Process.wait2', 'Process.waitpid', 'Process.waitpid2',
+      'Process.waitall', 'Process::Status.wait', 'Open3.capture2', 'Open3.capture2e',
+      'Open3.capture3', 'Open3.pipeline', 'Process.detach', 'IO.popen'
+    ).transform_values(&:category).freeze
+
+    module_function
+
+    def resolve(operation)
+      TABLE.fetch(normalize_operation(operation), UNKNOWN)
+    end
+
+    def resolve_socket_constructor(operation)
+      resolve_with_socket_fallback(operation)
+    end
+
+    # Runtime callers are the controlled targeted-probe registry; the only
+    # canonical dynamic `<Class>.new` operations it emits are proven IPSocket
+    # subclasses from Probes::Socket.
+    def resolve_runtime_operation(operation)
+      resolve_with_socket_fallback(operation)
+    end
+
+    def known?(operation) = resolve(operation).known?
+
+    def normalize_operation(value)
+      unless value.is_a?(String) && !value.empty? && value.valid_encoding? && value.bytesize <= 240
+        raise RuntimeContractError, 'operation must be a non-empty UTF-8 String of at most 240 bytes'
+      end
+
+      value
+    end
+    private_class_method :normalize_operation
+
+    def resolve_with_socket_fallback(operation)
+      normalized = normalize_operation(operation)
+      TABLE.fetch(normalized) do
+        socket_constructor_operation?(normalized) ? SOCKET_SUBCLASS : UNKNOWN
+      end
+    end
+    private_class_method :resolve_with_socket_fallback
+
+    def socket_constructor_operation?(operation)
+      operation.match?(/\A[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*\.new\z/)
+    end
+    private_class_method :socket_constructor_operation?
+  end
+  # rubocop:enable Metrics/ModuleLength
+end

data/lib/fiber_audit/runtime/active_operations.rb

@@ -7,7 +7,7 @@ require_relative 'validation'
 
 module FiberAudit
   module Runtime
-    # Bounded process-local registry shared by the watchdog and future probes.
+    # Bounded process-local registry shared by runtime observers.
     class ActiveOperations
       MAX_ENTRIES = 10_000
       MAX_SNAPSHOT = 100
@@ -23,6 +23,20 @@ module FiberAudit
         :started_monotonic_ns,
         :scheduler_snapshot
       )
+      Snapshot = Data.define(:entries, :total_count) do
+        def initialize(entries:, total_count:)
+          unless entries.is_a?(Array) && entries.all?(Entry)
+            raise RuntimeContractError, 'snapshot entries must be ActiveOperations::Entry values'
+          end
+
+          super(
+            entries: entries.dup.freeze,
+            total_count: Validation.integer(total_count, 'active operation total count')
+          )
+        end
+
+        def truncated? = total_count > entries.size
+      end
 
       def initialize(pid_source: Process.method(:pid), capacity: MAX_ENTRIES, snapshot_limit: MAX_SNAPSHOT)
         validate_source!(pid_source)
@@ -77,13 +91,16 @@ module FiberAudit
         @mutex.synchronize { @entries.delete(handle) }
       end
 
-      def snapshot(thread_id: nil)
+      def snapshot(thread_id: nil) = snapshot_with_metadata(thread_id: thread_id).entries
+
+      def snapshot_with_metadata(thread_id: nil)
         ensure_current_process!
         normalized_thread_id = Validation.integer(thread_id, 'thread_id', allow_nil: true)
         @mutex.synchronize do
           entries = @entries.values
           entries = entries.select { |entry| entry.thread_id == normalized_thread_id } if normalized_thread_id
-          entries.sort_by(&:sequence).first(@snapshot_limit).freeze
+          ordered = entries.sort_by(&:sequence)
+          Snapshot.new(entries: ordered.first(@snapshot_limit), total_count: ordered.size)
         end
       end
 
@@ -107,8 +124,6 @@ module FiberAudit
           raise RuntimeContractError, 'thread and fiber identities are invalid'
         end
 
-        normalized_snapshot = normalize_scheduler_snapshot(scheduler_snapshot)
-
         {
           thread_id: Validation.integer(thread.object_id, 'thread_id'),
           fiber_id: Validation.integer(fiber.object_id, 'fiber_id'),
@@ -116,13 +131,12 @@ module FiberAudit
           location: location,
           execution_context: normalized_context,
           started_monotonic_ns: Validation.integer(monotonic_ns, 'monotonic_ns'),
-          scheduler_snapshot: normalized_snapshot
+          scheduler_snapshot: normalize_scheduler_snapshot(scheduler_snapshot)
         }
       end
 
       def normalize_scheduler_snapshot(value)
-        return value if value.nil?
-        return value if value.is_a?(SchedulerSnapshot)
+        return value if value.nil? || value.is_a?(SchedulerSnapshot)
 
         raise RuntimeContractError, 'scheduler_snapshot must be a FiberAudit::Runtime::SchedulerSnapshot or nil'
       end
@@ -147,7 +161,9 @@ module FiberAudit
       end
 
       def validate_source!(source)
-        raise RuntimeContractError, 'pid_source must respond to call' unless source.respond_to?(:call)
+        return if source.respond_to?(:call)
+
+        raise RuntimeContractError, 'pid_source must respond to call'
       end
 
       def validate_limit!(value, name, maximum)

data/lib/fiber_audit/runtime/boot.rb

@@ -25,9 +25,13 @@ module FiberAudit
           watchdog_policy = if environment.key?(Environment::WATCHDOG_SETTINGS_KEY)
                               Environment.load_watchdog_policy(environment)
                             end
+          operation_liveness_policy = if environment.key?(Environment::OPERATION_LIVENESS_SETTINGS_KEY)
+                                        Environment.load_operation_liveness_policy(environment)
+                                      end
           @lifecycle = Lifecycle.start(
             settings: settings,
             watchdog_policy: watchdog_policy,
+            operation_liveness_policy: operation_liveness_policy,
             probes_enabled: Environment.probes_enabled?(environment),
             clock: clock,
             session_id_source: session_id_source,

data/lib/fiber_audit/runtime/environment.rb

@@ -7,6 +7,7 @@ require 'securerandom'
 require_relative 'policy'
 require_relative 'validation'
 require_relative 'watchdog_policy'
+require_relative 'operation_liveness_policy'
 
 module FiberAudit
   module Runtime
@@ -17,10 +18,12 @@ module FiberAudit
       SETTINGS_KEY = 'FIBER_AUDIT_RUNTIME_SETTINGS'
       FAILURE_MODE_KEY = 'FIBER_AUDIT_RUNTIME_FAILURE_MODE'
       WATCHDOG_SETTINGS_KEY = 'FIBER_AUDIT_RUNTIME_WATCHDOG_SETTINGS'
+      OPERATION_LIVENESS_SETTINGS_KEY = 'FIBER_AUDIT_RUNTIME_OPERATION_LIVENESS_SETTINGS'
       PROBES_KEY = 'FIBER_AUDIT_RUNTIME_PROBES'
       BOOT_REQUIRE = '-rfiber_audit/runtime/boot'
       MAX_SETTINGS_BYTES = 16_384
       MAX_WATCHDOG_SETTINGS_BYTES = 1_024
+      MAX_OPERATION_LIVENESS_SETTINGS_BYTES = 1_024
       SETTINGS_KEYS = %w[protocol_version launch_id project_root output_directory policy].freeze
       POLICY_KEYS = %w[
         redaction sampling_rate max_events_per_second max_events_per_session
@@ -29,6 +32,9 @@ module FiberAudit
       WATCHDOG_KEYS = %w[
         protocol_version enabled heartbeat_interval_ms stall_threshold_ms max_frames
       ].freeze
+      OPERATION_LIVENESS_KEYS = %w[
+        protocol_version enabled poll_interval_ms long_active_threshold_ms
+      ].freeze
 
       Settings = Data.define(:protocol_version, :launch_id, :project_root, :output_directory, :policy) do
         def initialize(protocol_version:, launch_id:, project_root:, output_directory:, policy:)
@@ -146,6 +152,45 @@ module FiberAudit
         raise RuntimeContractError, "invalid runtime watchdog activation settings: #{e.message}"
       end
 
+      def dump_operation_liveness_policy(policy)
+        require_operation_liveness_policy!(policy)
+        payload = {
+          'protocol_version' => PROTOCOL_VERSION,
+          'enabled' => policy.enabled,
+          'poll_interval_ms' => policy.poll_interval_ms,
+          'long_active_threshold_ms' => policy.long_active_threshold_ms
+        }
+        encoded = JSON.generate(payload)
+        if encoded.bytesize > MAX_OPERATION_LIVENESS_SETTINGS_BYTES
+          raise RuntimeSafetyError, 'runtime operation-liveness activation settings are too large'
+        end
+
+        encoded.freeze
+      end
+
+      def load_operation_liveness_policy(environment = ENV)
+        value = environment[OPERATION_LIVENESS_SETTINGS_KEY]
+        return OperationLivenessPolicy::DISABLED if value.nil?
+        unless value.is_a?(String) && value.valid_encoding? &&
+               value.bytesize <= MAX_OPERATION_LIVENESS_SETTINGS_BYTES
+          raise RuntimeContractError, 'runtime operation-liveness activation settings are invalid'
+        end
+
+        payload = JSON.parse(value)
+        require_exact_keys!(payload, OPERATION_LIVENESS_KEYS, 'runtime operation-liveness activation settings')
+        unless payload.fetch('protocol_version') == PROTOCOL_VERSION
+          raise RuntimeContractError, "runtime operation-liveness activation protocol must be #{PROTOCOL_VERSION}"
+        end
+
+        OperationLivenessPolicy.new(
+          enabled: payload.fetch('enabled'),
+          poll_interval_ms: payload.fetch('poll_interval_ms'),
+          long_active_threshold_ms: payload.fetch('long_active_threshold_ms')
+        )
+      rescue JSON::ParserError, ArgumentError => e
+        raise RuntimeContractError, "invalid runtime operation-liveness activation settings: #{e.message}"
+      end
+
       def activated?(environment = ENV)
         marker = environment[ACTIVATION_KEY]
         return false if marker.nil?
@@ -173,12 +218,14 @@ module FiberAudit
       def child_environment(
         settings:,
         watchdog_policy: nil,
+        operation_liveness_policy: nil,
         probes_enabled: false,
         base_environment: ENV,
         library_path: default_library_path
       )
         require_settings!(settings)
         require_watchdog_policy!(watchdog_policy) if watchdog_policy
+        require_operation_liveness_policy!(operation_liveness_policy) if operation_liveness_policy
         raise RuntimeContractError, 'probes_enabled must be a Boolean' unless [true, false].include?(probes_enabled)
         raise RuntimeContractError, 'base_environment must be a Hash-like object' unless base_environment.respond_to?(:[])
 
@@ -190,6 +237,9 @@ module FiberAudit
           'RUBYLIB' => prepend_token(base_environment['RUBYLIB'], library_path, separator: File::PATH_SEPARATOR)
         }
         environment[WATCHDOG_SETTINGS_KEY] = dump_watchdog_policy(watchdog_policy) if watchdog_policy
+        if operation_liveness_policy
+          environment[OPERATION_LIVENESS_SETTINGS_KEY] = dump_operation_liveness_policy(operation_liveness_policy)
+        end
         environment[PROBES_KEY] = '1' if probes_enabled
         environment.transform_values(&:freeze).freeze
       end
@@ -255,6 +305,14 @@ module FiberAudit
       end
       private_class_method :require_watchdog_policy!
 
+      def require_operation_liveness_policy!(value)
+        return if value.is_a?(OperationLivenessPolicy)
+
+        raise RuntimeContractError,
+              'operation_liveness_policy must be FiberAudit::Runtime::OperationLivenessPolicy'
+      end
+      private_class_method :require_operation_liveness_policy!
+
       def require_exact_keys!(value, expected, path)
         raise RuntimeContractError, "#{path} must be an object" unless value.is_a?(Hash)
 

data/lib/fiber_audit/runtime/lifecycle.rb

@@ -14,6 +14,8 @@ require_relative 'scheduler_observer'
 require_relative 'session'
 require_relative 'watchdog'
 require_relative 'watchdog_policy'
+require_relative 'operation_liveness_monitor'
+require_relative 'operation_liveness_policy'
 
 module FiberAudit
   module Runtime
@@ -21,6 +23,7 @@ module FiberAudit
     class Lifecycle
       attr_reader :settings, :owner_pid, :output_path, :recorder,
                   :watchdog, :active_operations, :watchdog_policy,
+                  :operation_liveness_monitor, :operation_liveness_policy,
                   :redactor, :probe_registry, :execution_context_store,
                   :rails_integration
 
@@ -31,6 +34,7 @@ module FiberAudit
       def initialize(
         settings:,
         watchdog_policy: nil,
+        operation_liveness_policy: nil,
         probes_enabled: false,
         clock: Clock.new,
         session_id_source: SecureRandom.method(:uuid),
@@ -39,11 +43,12 @@ module FiberAudit
         random: Sampler::RANDOM_SOURCE
       )
         validate_dependencies!(
-          settings, watchdog_policy, probes_enabled, clock,
+          settings, watchdog_policy, operation_liveness_policy, probes_enabled, clock,
           session_id_source, pid_source, writer_factory, random
         )
         @settings = settings
         @watchdog_policy = watchdog_policy
+        @operation_liveness_policy = operation_liveness_policy
         @probes_enabled = probes_enabled
         @clock = clock
         @session_id_source = session_id_source
@@ -52,15 +57,7 @@ module FiberAudit
         @random = random
         @owner_pid = current_pid
         @state = :starting
-        @output_path = nil
-        @recorder = nil
-        @watchdog = nil
-        @scheduler_observer = nil
-        @active_operations = nil
-        @redactor = nil
-        @probe_registry = nil
-        @execution_context_store = nil
-        @rails_integration = nil
+        reset_process_components!
         start_process_session!
       rescue StandardError => e
         startup_failure!(e)
@@ -84,15 +81,7 @@ module FiberAudit
 
         abandon_inherited_runtime!
         @owner_pid = pid
-        @output_path = nil
-        @recorder = nil
-        @watchdog = nil
-        @scheduler_observer = nil
-        @active_operations = nil
-        @redactor = nil
-        @probe_registry = nil
-        @execution_context_store = nil
-        @rails_integration = nil
+        reset_process_components!
         @state = :starting
         # Reset fiber-local context after fork
         ExecutionContext.reset!
@@ -122,13 +111,18 @@ module FiberAudit
 
       private
 
-      def validate_dependencies!(candidate_settings, watchdog, probes, candidate_clock, session_ids, pids, writers, random)
+      def validate_dependencies!(candidate_settings, watchdog, liveness, probes, candidate_clock,
+                                 session_ids, pids, writers, random)
         unless candidate_settings.is_a?(Environment::Settings)
           raise RuntimeContractError, 'settings must be FiberAudit::Runtime::Environment::Settings'
         end
         unless watchdog.nil? || watchdog.is_a?(WatchdogPolicy)
           raise RuntimeContractError, 'watchdog_policy must be a FiberAudit::Runtime::WatchdogPolicy or nil'
         end
+        unless liveness.nil? || liveness.is_a?(OperationLivenessPolicy)
+          raise RuntimeContractError,
+                'operation_liveness_policy must be a FiberAudit::Runtime::OperationLivenessPolicy or nil'
+        end
         raise RuntimeContractError, 'probes_enabled must be a Boolean' unless [true, false].include?(probes)
         raise RuntimeContractError, 'clock must be a FiberAudit::Runtime::Clock' unless candidate_clock.is_a?(Clock)
 
@@ -142,6 +136,19 @@ module FiberAudit
         end
       end
 
+      def reset_process_components!
+        @output_path = nil
+        @recorder = nil
+        @watchdog = nil
+        @operation_liveness_monitor = nil
+        @scheduler_observer = nil
+        @active_operations = nil
+        @redactor = nil
+        @probe_registry = nil
+        @execution_context_store = nil
+        @rails_integration = nil
+      end
+
       def start_process_session!
         session_id = @session_id_source.call
         started_at = @clock.wall_time
@@ -175,6 +182,7 @@ module FiberAudit
         @redactor = Redactor.new(root: settings.project_root, policy: settings.policy)
         @execution_context_store = ExecutionContext if @probes_enabled
         setup_watchdog! if watchdog_policy
+        setup_operation_liveness! if @probes_enabled && operation_liveness_policy
         setup_rails_integration! if @probes_enabled
         setup_probes! if @probes_enabled
       rescue StandardError => e
@@ -202,6 +210,13 @@ module FiberAudit
         ensure
           @rails_integration = nil
         end
+        begin
+          @operation_liveness_monitor&.stop
+        rescue StandardError
+          nil
+        ensure
+          @operation_liveness_monitor = nil
+        end
         begin
           if @scheduler_observer
             SchedulerObserver.deactivate(@scheduler_observer)
@@ -215,6 +230,15 @@ module FiberAudit
         end
       end
 
+      def setup_operation_liveness!
+        @operation_liveness_monitor = OperationLivenessMonitor.new(
+          policy: operation_liveness_policy,
+          recorder: recorder,
+          active_operations: active_operations,
+          clock: @clock
+        )
+      end
+
       def setup_rails_integration!
         @rails_integration = RailsIntegration.activate(
           context_store: @execution_context_store,
@@ -272,44 +296,61 @@ module FiberAudit
       def abandon_inherited_runtime!
         recorder&.writer&.close
       ensure
-        @recorder = nil
-        @watchdog = nil
-        @scheduler_observer = nil
-        @active_operations = nil
-        @redactor = nil
-        @probe_registry = nil
-        @execution_context_store = nil
-        @rails_integration = nil
+        reset_process_components!
       end
 
       def stop_runtime_observers
         error = nil
-        begin
-          RailsIntegration.deactivate(@rails_integration) if @rails_integration
-        rescue StandardError => e
-          error ||= e
-        ensure
-          @rails_integration = nil
-        end
-        begin
-          Probes::Registry.deactivate(probe_registry) if probe_registry
-        rescue StandardError => e
-          error ||= e
-        ensure
-          @probe_registry = nil
-        end
-        begin
-          SchedulerObserver.deactivate(@scheduler_observer) if @scheduler_observer
-          watchdog&.stop
-        rescue StandardError => e
-          error ||= e
-        ensure
-          @scheduler_observer = nil
-        end
+        component_error = stop_rails_integration
+        error ||= component_error
+        component_error = stop_probe_registry
+        error ||= component_error
+        component_error = stop_operation_liveness_monitor
+        error ||= component_error
+        component_error = stop_watchdog
+        error ||= component_error
         recorder&.internal_error! if error
         error
       end
 
+      def stop_rails_integration
+        RailsIntegration.deactivate(@rails_integration) if @rails_integration
+        nil
+      rescue StandardError => e
+        e
+      ensure
+        @rails_integration = nil
+      end
+
+      def stop_probe_registry
+        Probes::Registry.deactivate(probe_registry) if probe_registry
+        nil
+      rescue StandardError => e
+        e
+      ensure
+        @probe_registry = nil
+      end
+
+      def stop_operation_liveness_monitor
+        operation_liveness_monitor&.stop
+        nil
+      rescue StandardError => e
+        e
+      ensure
+        @operation_liveness_monitor = nil
+      end
+
+      def stop_watchdog
+        SchedulerObserver.deactivate(@scheduler_observer) if @scheduler_observer
+        watchdog&.stop
+        nil
+      rescue StandardError => e
+        e
+      ensure
+        @scheduler_observer = nil
+        @watchdog = nil
+      end
+
       def startup_failure!(error)
         raise error unless defined?(@settings) && settings.policy.fail_open?