fiber_audit 0.2.1 → 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/operation_vocabulary.rb

@@ -7,7 +7,8 @@ module FiberAudit
       'Kernel' => %i[system exec spawn].freeze,
       'Open3' => %i[capture2 capture2e capture3 pipeline].freeze,
       'IO' => %i[popen].freeze,
-      'Process' => %i[waitall detach].freeze
+      'Process' => %i[spawn exec wait wait2 waitpid waitpid2 waitall detach].freeze,
+      'Process::Status' => %i[wait].freeze
     }.freeze
     FA1001_KERNEL_METHODS = %i[system exec spawn].freeze
 

data/lib/fiber_audit/runtime/active_operations.rb

@@ -2,11 +2,12 @@
 
 require_relative 'event'
 require_relative 'location'
+require_relative 'scheduler_snapshot'
 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
@@ -19,8 +20,23 @@ module FiberAudit
         :operation,
         :location,
         :execution_context,
-        :started_monotonic_ns
+        :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)
@@ -38,7 +54,8 @@ module FiberAudit
         location: nil,
         execution_context: :unknown,
         thread: Thread.current,
-        fiber: Fiber.current
+        fiber: Fiber.current,
+        scheduler_snapshot: nil
       )
         ensure_current_process!
         values = normalize_entry(
@@ -47,7 +64,8 @@ module FiberAudit
           execution_context: execution_context,
           monotonic_ns: monotonic_ns,
           thread: thread,
-          fiber: fiber
+          fiber: fiber,
+          scheduler_snapshot: scheduler_snapshot
         )
 
         @mutex.synchronize do
@@ -73,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
 
@@ -90,7 +111,7 @@ module FiberAudit
 
       private
 
-      def normalize_entry(operation:, location:, execution_context:, monotonic_ns:, thread:, fiber:)
+      def normalize_entry(operation:, location:, execution_context:, monotonic_ns:, thread:, fiber:, scheduler_snapshot: nil)
         canonical_operation = Validation.operation(operation)
         unless location.nil? || location.is_a?(Location)
           raise RuntimeContractError, 'location must be a FiberAudit::Runtime::Location or nil'
@@ -109,10 +130,17 @@ module FiberAudit
           operation: canonical_operation,
           location: location,
           execution_context: normalized_context,
-          started_monotonic_ns: Validation.integer(monotonic_ns, 'monotonic_ns')
+          started_monotonic_ns: Validation.integer(monotonic_ns, 'monotonic_ns'),
+          scheduler_snapshot: normalize_scheduler_snapshot(scheduler_snapshot)
         }
       end
 
+      def normalize_scheduler_snapshot(value)
+        return value if value.nil? || value.is_a?(SchedulerSnapshot)
+
+        raise RuntimeContractError, 'scheduler_snapshot must be a FiberAudit::Runtime::SchedulerSnapshot or nil'
+      end
+
       def ensure_current_process!
         pid = current_pid
         reset_for_process!(pid) unless pid == @owner_pid
@@ -133,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/execution_context.rb

@@ -4,73 +4,85 @@ require_relative '../execution_context'
 
 module FiberAudit
   module Runtime
-    # Fiber-local execution context stack.
-    # Uses fiber instance variables for isolation without Thread#[] visibility.
-    # PID-aware to handle fork correctly.
+    # Fiber-local execution context with propagation to child fibers.
+    # Uses Ruby Fiber storage (Fiber[]) for fiber-local state that is
+    # inherited by child fibers at creation, enabling automatic context
+    # propagation across Fiber boundaries.
+    #
+    # Frames are immutable (frozen Data objects) forming a linked list.
+    # Each +with+ call creates a new frame pointing to the parent frame.
+    #
+    # Semantics:
+    # - Child fibers inherit the parent fiber's current context at creation
+    # - Child fiber overrides do not alter parent context
+    # - +clear!+ removes context for the current fiber only
+    # - +clear!+ inside nested +with+ is not undone by the enclosing ensure
+    #   (ensure restores only when its own frame is still the active one)
+    # - Thread isolation is maintained even though Ruby copies Fiber storage to a
+    #   newly created Thread's root Fiber
+    # - PID mismatch (after fork) is treated as empty context
+    # - MAX_DEPTH overflow exposes :unknown rather than stale outer context
     module ExecutionContext
       MAX_DEPTH = 32
-      IVAR_KEY = :@__fiber_audit_execution_context__
-      IVAR_PID_KEY = :@__fiber_audit_execution_context_pid__
+      FRAME_KEY = :__fiber_audit_execution_context_frame__
+
+      # Immutable frame in the context chain. Process and Thread ownership keep
+      # inherited storage from crossing fork or Thread boundaries.
+      Frame = Data.define(:context, :parent, :depth, :pid, :thread_id)
+      private_constant :Frame
 
       class << self
         def current
-          state = current_state
-          return Context::UNKNOWN unless state
-
-          state[:stack].last || Context::UNKNOWN
+          frame = current_frame
+          frame ? frame.context : Context::UNKNOWN
         end
 
         def with(context)
           normalized = validate_context(context)
-          state = ensure_state
-          return yield if state[:stack].size >= MAX_DEPTH
-
-          state[:stack].push(normalized)
+          parent = current_frame
+
+          new_depth = parent ? parent.depth + 1 : 1
+          effective = new_depth > MAX_DEPTH ? Context::UNKNOWN : normalized
+          frame = Frame.new(
+            context: effective,
+            parent: parent,
+            depth: new_depth,
+            pid: Process.pid,
+            thread_id: Thread.current.object_id
+          )
+
+          Fiber[FRAME_KEY] = frame
           begin
             yield
           ensure
-            state[:stack].pop
+            # Only restore if our frame is still the active one.
+            # If clear! was called (or another with replaced it), skip restore.
+            Fiber[FRAME_KEY] = parent if Fiber[FRAME_KEY].equal?(frame)
           end
         end
 
+        def clear!
+          Fiber[FRAME_KEY] = nil
+        end
+
+        # Compatibility alias for clear!.
         def reset!
-          fiber = Fiber.current
-          fiber.remove_instance_variable(IVAR_KEY) if fiber.instance_variable_defined?(IVAR_KEY)
-          fiber.remove_instance_variable(IVAR_PID_KEY) if fiber.instance_variable_defined?(IVAR_PID_KEY)
+          clear!
         end
 
+        # Clear context after fork.
         def after_fork!
-          reset!
+          clear!
         end
 
         private
 
-        def current_state
-          fiber = Fiber.current
-          return nil unless fiber.instance_variable_defined?(IVAR_KEY)
-
-          pid = fiber.instance_variable_defined?(IVAR_PID_KEY) ? fiber.instance_variable_get(IVAR_PID_KEY) : nil
-          return nil unless pid == Process.pid
-
-          { stack: fiber.instance_variable_get(IVAR_KEY), pid: pid }
-        end
-
-        def ensure_state
-          fiber = Fiber.current
-          pid = Process.pid
-
-          if fiber.instance_variable_defined?(IVAR_KEY)
-            stored_pid = fiber.instance_variable_defined?(IVAR_PID_KEY) ? fiber.instance_variable_get(IVAR_PID_KEY) : nil
-            return { stack: fiber.instance_variable_get(IVAR_KEY), pid: pid } if stored_pid == pid
-
-            # PID mismatch - reset
-            reset!
-          end
+        def current_frame
+          frame = Fiber[FRAME_KEY]
+          return nil unless frame&.pid == Process.pid
+          return nil unless frame.thread_id == Thread.current.object_id
 
-          stack = []
-          fiber.instance_variable_set(IVAR_KEY, stack)
-          fiber.instance_variable_set(IVAR_PID_KEY, pid)
-          { stack: stack, pid: pid }
+          frame
         end
 
         def validate_context(value)