bitfab 0.51.8 → 0.51.10

data/lib/bitfab/subtree.rb

@@ -6,6 +6,8 @@ require "time"
 
 module Bitfab
   # Captures Ruby method calls beneath one traced root via TracePoint.
+  class MixedTracingError < StandardError; end
+
   module Subtree
     DEFAULT_MAX_DEPTH = 30
     DEFAULT_MAX_SPANS = 500
@@ -46,11 +48,115 @@ module Bitfab
       :kwargs,
       :started_at,
       :error,
+      :span_type,
+      :test_run_id,
+      :span_data,
       keyword_init: true
     )
 
     module_function
 
+    def assert_surface!(surface)
+      enclosing = current_session ? :trace : SpanContext.current&.dig(:surface)
+      return unless enclosing && enclosing != surface
+
+      raise MixedTracingError,
+        "opt-in and opt-out tracing cannot be mixed: #{surface} entered inside #{enclosing}. " \
+        "Use bitfab_node inside bitfab_trace, or use bitfab_span throughout the workflow."
+    rescue MixedTracingError
+      raise
+    rescue
+      nil
+    end
+
+    def nested_root_suppressed?
+      current_session && (ReplayContext.current || (defined?(SeedContext) && SeedContext.current))
+    end
+
+    def qualified_name(receiver, method_name)
+      owner = receiver.is_a?(Module) ? receiver.name : receiver.class.name
+      (owner && !owner.empty? && owner != "Object") ? "#{owner}.#{method_name}" : method_name.to_s
+    end
+
+    class ConfiguredCall
+      attr_reader :span_data, :owner
+
+      def initialize(receiver:, method_name:, name:, type:, args:, kwargs:, test_run_id: nil,
+        nested_trace_key: nil)
+        @receiver = receiver
+        @method_name = method_name
+        @nested_trace_key = nested_trace_key
+        @span_data = {}
+        @completed = false
+        @records = Subtree.active_sessions.map do |session|
+          omitted = session.excluded?(method_name)
+          entry = unless omitted
+            session.configured_entry(name:, type:, args:, kwargs:, test_run_id:)
+          end
+          [session, entry, !omitted]
+        end
+        @owner = @records.find { |_, entry, _| entry }&.first unless nested_trace_key
+      end
+
+      def start(trace_id:, span_id:)
+        @records.each do |session, entry, _|
+          next unless entry
+
+          if session.equal?(@owner)
+            entry.span_id = span_id
+            session.discard_configured(entry)
+          elsif @nested_trace_key
+            entry.span_data = {
+              "nested_trace_id" => trace_id,
+              "nested_trace_function_key" => @nested_trace_key,
+              "nested_root_span_id" => span_id
+            }
+          end
+        end
+        if @nested_trace_key && (enclosing = @records.find { |_, entry, _| entry })
+          session, entry = enclosing
+          @span_data.merge!(
+            "enclosing_trace_id" => session.trace_id,
+            "enclosing_trace_function_key" => session.trace_function_key,
+            "enclosing_span_id" => entry.span_id
+          )
+        end
+      end
+
+      def run
+        boundaries = @records.filter_map do |session, entry, counts_toward_depth|
+          next if session.equal?(@owner)
+
+          [session, session.push_boundary(
+            receiver: @receiver, method_name: @method_name,
+            span_id: entry&.span_id, counts_toward_depth:
+          )]
+        end
+        yield
+      ensure
+        boundaries&.reverse_each { |session, boundary| session.pop_boundary(boundary) }
+      end
+
+      def with_owner_parent(&body)
+        return yield unless @owner
+
+        SpanContext.with_span(trace_id: @owner.trace_id,
+          span_id: @owner.current_parent_span_id, surface: :trace, &body)
+      end
+
+      def complete(result:, error:, ended_at:)
+        return if @completed
+
+        @completed = true
+        @records.each do |session, entry, _|
+          next if !entry || session.equal?(@owner)
+
+          entry.error = error
+          session.emit_configured(entry, result:)
+        end
+      end
+    end
+
     def prepare(root_source:, exclude:)
       path = root_source[0]
       root = first_party_root(path)
@@ -64,7 +170,7 @@ module Bitfab
     end
 
     def capture(client:, trace_function_key:, config:, max_depth:, max_spans:, include_wrappers:,
-      root_receiver:, root_method_name:)
+      root_receiver:, root_method_name:, mock_on_replay_default: false)
       return yield unless config.root
 
       span = SpanContext.current || ReplayContext.current_span
@@ -83,6 +189,7 @@ module Bitfab
           max_depth:,
           max_spans:,
           include_wrappers:,
+          mock_on_replay_default:,
           root_receiver:,
           root_method_name:
         )
@@ -294,7 +401,7 @@ module Bitfab
     end
 
     class Session
-      attr_reader :client, :parent_session, :trace_function_key, :trace_id, :deferred_frames
+      attr_reader :client, :parent_session, :trace_function_key, :trace_id, :deferred_frames, :mock_on_replay_default
 
       def active? = @active
       def deferred? = @deferred
@@ -305,7 +412,8 @@ module Bitfab
 
       def initialize(client:, trace_function_key:, trace_id:, root_span_id:, test_run_id:,
         input_source_span_id:, config:, max_depth:, max_spans:, include_wrappers:,
-        root_receiver:, root_method_name:)
+        root_receiver:, root_method_name:, mock_on_replay_default: false)
+        @mock_on_replay_default = mock_on_replay_default
         @client = client
         @trace_function_key = trace_function_key
         @trace_id = trace_id
@@ -322,6 +430,7 @@ module Bitfab
         @exclude = config.exclude
         @include_wrappers = include_wrappers
         @stacks = {}
+        @configured_entries = {}
         @fiber_parents = {}
         @suppressed_depths = {}
         @owned_paths = {}
@@ -419,6 +528,29 @@ module Bitfab
         true
       end
 
+      def configured_entry(name:, type:, args:, kwargs:, test_run_id:)
+        return unless reserve_node
+
+        entry = OpenSpan.new(
+          span_id: SecureRandom.uuid,
+          parent_span_id: current_parent_span_id,
+          name:, span_type: type, args:, kwargs:, test_run_id:, started_at: now,
+          span_data: {}
+        )
+        @configured_entries[entry.object_id] = entry
+        entry
+      end
+
+      def discard_configured(entry)
+        @configured_entries.delete(entry.object_id)
+      end
+
+      def emit_configured(entry, result:)
+        return unless discard_configured(entry)
+
+        emit(entry, result:)
+      end
+
       def current_parent_span_id
         stack = @stacks[Fiber.current.object_id] || []
         stack.reverse_each.find { |entry| entry.span_id }&.span_id ||
@@ -465,6 +597,11 @@ module Bitfab
       private
 
       def finish_open_spans
+        @configured_entries.each_value do |entry|
+          entry.error ||= "Subtree capture ended before the call returned"
+          emit(entry, result: nil)
+        end
+        @configured_entries.clear
         @stacks.each_value do |stack|
           stack.reverse_each do |entry|
             next unless entry.is_a?(OpenSpan)
@@ -590,7 +727,9 @@ module Bitfab
           span_id: entry.span_id,
           parent_span_id: entry.parent_span_id,
           span_name: entry.name,
-          span_type: "function",
+          span_type: entry.span_type || "function",
+          instrumentation: "trace",
+          span_data: entry.span_data || {},
           function_name: entry.name,
           contexts: nil,
           prompt: nil,
@@ -600,7 +739,7 @@ module Bitfab
           error: entry.error,
           started_at: entry.started_at,
           ended_at: now,
-          test_run_id: @test_run_id,
+          test_run_id: entry.test_run_id || @test_run_id,
           input_source_span_id: @input_source_span_id
         )
       rescue Exception # rubocop:disable Lint/RescueException

data/lib/bitfab/thread_propagation.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Bitfab
+  module ThreadPropagation
+    ORIGIN_KEY = :__bitfab_submit_origin
+    SDK_PATH = File.expand_path(__dir__) + File::SEPARATOR
+    @installed = false
+    @mutex = Mutex.new
+
+    module_function
+
+    def install
+      @mutex.synchronize do
+        Thread.singleton_class.prepend(ThreadMethods) unless Thread.singleton_class.ancestors.include?(ThreadMethods)
+        @installed = true
+      end
+      begin
+        require "concurrent-ruby"
+        Concurrent::ThreadPoolExecutor.prepend(PoolMethods) unless Concurrent::ThreadPoolExecutor.ancestors.include?(PoolMethods)
+      rescue LoadError
+        nil
+      end
+    end
+
+    def installed?
+      @installed
+    end
+
+    def uninstall
+      @installed = false
+    end
+
+    def runtime
+      current = Thread.current
+      data = {"thread_id" => current.object_id, "thread_name" => current.name || ((current == Thread.main) ? "main" : "thread-#{current.object_id}")}
+      if (origin = current.thread_variable_get(ORIGIN_KEY))
+        data["parent_thread_id"] = origin["thread_id"]
+        data["submit_thread_id"] = origin["thread_id"]
+        data["submit_thread_name"] = origin["thread_name"]
+      end
+      data
+    end
+
+    def bind(block)
+      stack = SpanContext.stack.dup
+      stack << SpanContext.current if stack.empty? && SpanContext.current
+      replay = ReplayContext.current
+      seed = SeedContext.current
+      return block if stack.empty? && replay.nil? && seed.nil?
+
+      origin = runtime.slice("thread_id", "thread_name")
+      lambda do |*args, **kwargs|
+        current = Thread.current
+        previous_stack = current[SpanContext::STACK_KEY]
+        previous_bridge = current.thread_variable_get(SpanContext::FIBER_BRIDGE_STACK_KEY)
+        previous_replay = current.thread_variable_get(REPLAY_CONTEXT_KEY)
+        previous_seed = current.thread_variable_get(SeedContext::KEY)
+        previous_origin = current.thread_variable_get(ORIGIN_KEY)
+        local_replay = replay&.merge(span_stack: replay.fetch(:span_stack, []).dup)
+        current[SpanContext::STACK_KEY] = stack.dup
+        current.thread_variable_set(SpanContext::FIBER_BRIDGE_STACK_KEY, [])
+        current.thread_variable_set(REPLAY_CONTEXT_KEY, local_replay)
+        current.thread_variable_set(SeedContext::KEY, seed)
+        current.thread_variable_set(ORIGIN_KEY, origin)
+        begin
+          block.call(*args, **kwargs)
+        ensure
+          replay[:db_snapshot_accessed] = true if replay && local_replay[:db_snapshot_accessed]
+          current[SpanContext::STACK_KEY] = previous_stack
+          current.thread_variable_set(SpanContext::FIBER_BRIDGE_STACK_KEY, previous_bridge)
+          current.thread_variable_set(REPLAY_CONTEXT_KEY, previous_replay)
+          current.thread_variable_set(SeedContext::KEY, previous_seed)
+          current.thread_variable_set(ORIGIN_KEY, previous_origin)
+        end
+      end
+    end
+
+    def internal?(block)
+      path = block.source_location&.first
+      path && (path.start_with?(SDK_PATH) || path.include?("/opentelemetry") || path.include?("/concurrent-ruby"))
+    end
+
+    module ThreadMethods
+      %i[new start fork].each do |method_name|
+        define_method(method_name) do |*args, &block|
+          return super(*args, &block) if !ThreadPropagation.installed? || block.nil? || ThreadPropagation.internal?(block)
+
+          bound = begin
+            ThreadPropagation.bind(block)
+          rescue
+            block
+          end
+          super(*args, &bound)
+        end
+      end
+    end
+
+    module PoolMethods
+      def post(*args, &block)
+        return super unless ThreadPropagation.installed? && block
+
+        bound = begin
+          ThreadPropagation.bind(block)
+        rescue
+          block
+        end
+        super(*args, &bound)
+      end
+    end
+  end
+end

data/lib/bitfab/traceable.rb

@@ -53,32 +53,28 @@ module Bitfab
     #   preserve the bound client through the fluent wrapper, matching Python's
     #   `BitfabFunction.span()` and TypeScript's `BitfabFunction.withSpan()`.
     def self.wrap(klass, method_name, trace_function_key:, name: nil, type: "custom",
-      capture_when: "always", mock_on_replay: false, client: nil)
-      span_name = name || method_name.to_s
+      capture_when: "always", mock_on_replay: false, finalize: nil, test_run_id: nil, client: nil)
       method_name_str = method_name.to_s
       bound_client = client
-
       wrapper = Module.new do
         define_method(method_name) do |*args, **kwargs, &block|
-          target_client = bound_client || Bitfab.client
+          target_client = bound_client || Bitfab.client_or_nil
+          next super(*args, **kwargs, &block) unless target_client
+
+          Subtree.assert_surface!(:span) if target_client.send(:should_record?)
           target_client.send(:execute_span,
             trace_function_key:,
-            span_name:,
-            span_type: type,
-            function_name: method_name_str,
-            args:,
-            kwargs:,
-            capture_when:,
-            mock_on_replay:,
-            explicit_span_receiver: self,
-            explicit_span_method_name: method_name) do
+            span_name: name || Subtree.qualified_name(self, method_name),
+            span_type: type, function_name: method_name_str, args:, kwargs:,
+            capture_when:, mock_on_replay:, finalize:, test_run_id:, surface: :span,
+            explicit_span_receiver: self, explicit_span_method_name: method_name) do
             super(*args, **kwargs, &block)
           end
         end
       end
-
       wrapper.instance_variable_set(:@bitfab_span_method, method_name_str)
       wrapper.instance_variable_set(:@bitfab_span_key, trace_function_key)
+      preserve_visibility(klass, wrapper, method_name)
       klass.prepend(wrapper)
     end
 
@@ -87,44 +83,45 @@ module Bitfab
     # beneath it record automatically as function spans.
     def self.trace(klass, method_name, trace_function_key:, name: nil, type: "custom",
       max_depth: Subtree::DEFAULT_MAX_DEPTH, max_spans: Subtree::DEFAULT_MAX_SPANS,
-      exclude: [], include_wrappers: false, client: nil)
-      source = source_of(klass, method_name)
-      capture_config = Subtree.prepare(root_source: source, exclude:)
-      span_name = name || method_name.to_s
+      exclude: [], include_wrappers: false, mock_on_replay_default: false, client: nil)
+      capture_config = Subtree.prepare(root_source: source_of(klass, method_name), exclude:)
       method_name_str = method_name.to_s
       bound_client = client
-
       wrapper = Module.new do
         define_method(method_name) do |*args, **kwargs, &block|
-          if Subtree.active_trace?(trace_function_key)
-            next super(*args, **kwargs, &block)
+          target_client = bound_client || Bitfab.client_or_nil
+          next super(*args, **kwargs, &block) unless target_client&.send(:should_record?)
+
+          Subtree.assert_surface!(:trace)
+          next super(*args, **kwargs, &block) if Subtree.nested_root_suppressed?
+
+          span_name = name || Subtree.qualified_name(self, method_name)
+          managed = SpanContext.current&.dig(:recording_override)
+          if managed && managed.empty? && (ReplayContext.current || SeedContext.current)
+            managed.merge!(name: span_name, type:, function_name: method_name_str, instrumentation: "trace")
+            SpanContext.current[:surface] = :trace
+            next Subtree.capture(
+              client: target_client, trace_function_key:, config: capture_config,
+              max_depth:, max_spans:, include_wrappers:, mock_on_replay_default:,
+              root_receiver: self, root_method_name: method_name
+            ) { super(*args, **kwargs, &block) }
           end
-
-          target_client = bound_client || Bitfab.client
-          target_client.send(
-            :execute_span,
-            trace_function_key:,
-            span_name:,
-            span_type: type,
-            function_name: method_name_str,
-            args:,
-            kwargs:,
-            independent_root: true
-          ) do
+          call = Subtree::ConfiguredCall.new(receiver: self, method_name:, name: span_name,
+            type:, args:, kwargs:, nested_trace_key: trace_function_key)
+          target_client.send(:execute_span,
+            trace_function_key:, span_name:, span_type: type,
+            function_name: method_name_str, args:, kwargs:, independent_root: true,
+            surface: :trace, span_data: call.span_data,
+            on_start: call.method(:start), on_complete: call.method(:complete),
+            around_body: call.method(:run)) do
             Subtree.capture(
-              client: target_client,
-              trace_function_key:,
-              config: capture_config,
-              max_depth:,
-              max_spans:,
-              include_wrappers:,
-              root_receiver: self,
-              root_method_name: method_name
+              client: target_client, trace_function_key:, config: capture_config,
+              max_depth:, max_spans:, include_wrappers:, mock_on_replay_default:,
+              root_receiver: self, root_method_name: method_name
             ) { super(*args, **kwargs, &block) }
           end
         end
       end
-
       wrapper.instance_variable_set(:@bitfab_span_method, method_name_str)
       wrapper.instance_variable_set(:@bitfab_span_key, trace_function_key)
       preserve_visibility(klass, wrapper, method_name)
@@ -134,55 +131,42 @@ module Bitfab
     # Configure an existing method only when it is discovered beneath a
     # bitfab_trace root. Outside subtree capture the method runs unchanged.
     def self.node(klass, method_name, name: nil, type: "custom", capture: true,
-      test_run_id: nil, mock_on_replay: false, finalize: nil, client: nil)
+      test_run_id: nil, mock_on_replay: nil, finalize: nil, client: nil)
       validate_node_options!(capture:, mock_on_replay:)
-      span_name = name || method_name.to_s
       method_name_str = method_name.to_s
       bound_client = client
-
       wrapper = Module.new do
         define_method(method_name) do |*args, **kwargs, &block|
+          Subtree.assert_surface!(:trace)
           session = Subtree.current_session
           if !session || (bound_client && !session.client.equal?(bound_client))
             next super(*args, **kwargs, &block)
           end
-
           unless capture
             next Subtree.with_suppressed_node(receiver: self, method_name:) do
               super(*args, **kwargs, &block)
             end
           end
 
-          if session.excluded?(method_name)
-            next Subtree.with_suppressed_node(receiver: self, method_name:, sessions: [session]) do
-              super(*args, **kwargs, &block)
-            end
+          span_name = name || Subtree.qualified_name(self, method_name)
+          call = Subtree::ConfiguredCall.new(receiver: self, method_name:, name: span_name,
+            type:, args:, kwargs:, test_run_id:)
+          unless call.owner
+            next call.run { super(*args, **kwargs, &block) }
           end
-
-          unless session.reserve_node
-            next Subtree.with_suppressed_node(receiver: self, method_name:, sessions: [session]) do
-              super(*args, **kwargs, &block)
-            end
+          policy = mock_on_replay.nil? ? call.owner.mock_on_replay_default : mock_on_replay
+          call.with_owner_parent do
+            call.owner.client.send(:execute_span,
+              trace_function_key: call.owner.trace_function_key,
+              span_name:, span_type: type, function_name: method_name_str,
+              args:, kwargs:, capture_when: "nested", mock_on_replay: policy,
+              explicit_span_receiver: self, explicit_span_method_name: method_name,
+              test_run_id:, finalize:, surface: :trace,
+              on_start: call.method(:start), on_complete: call.method(:complete),
+              around_body: call.method(:run)) { super(*args, **kwargs, &block) }
           end
-
-          session.client.send(
-            :execute_span,
-            trace_function_key: session.trace_function_key,
-            span_name:,
-            span_type: type,
-            function_name: method_name_str,
-            args:,
-            kwargs:,
-            capture_when: "nested",
-            mock_on_replay:,
-            explicit_span_receiver: self,
-            explicit_span_method_name: method_name,
-            test_run_id:,
-            finalize:
-          ) { super(*args, **kwargs, &block) }
         end
       end
-
       preserve_visibility(klass, wrapper, method_name)
       klass.prepend(wrapper)
     end
@@ -278,7 +262,7 @@ module Bitfab
       #   When true, `client.replay(...)` returns this span's
       #   historical output instead of executing the wrapped method.
       def bitfab_span(method_name, trace_function_key: nil, name: nil, type: "custom",
-        capture_when: "always", mock_on_replay: false)
+        capture_when: "always", mock_on_replay: false, finalize: nil, test_run_id: nil)
         trace_function_key ||= @bitfab_function_key
         unless trace_function_key
           raise "No trace function key provided. Pass `trace_function_key:` to `bitfab_span` " \
@@ -288,7 +272,7 @@ module Bitfab
         # If the method already exists (inline or after-method style), wrap it immediately
         if method_defined?(method_name) || private_method_defined?(method_name)
           _bitfab_wrap_method(
-            method_name, trace_function_key:, name:, type:, capture_when:, mock_on_replay:
+            method_name, trace_function_key:, name:, type:, capture_when:, mock_on_replay:, finalize:, test_run_id:
           )
         else
           # Method doesn't exist yet (before-method style) - register for method_added hook
@@ -298,7 +282,9 @@ module Bitfab
             name:,
             type:,
             capture_when:,
-            mock_on_replay:
+            mock_on_replay:,
+            finalize:,
+            test_run_id:
           }
         end
       end
@@ -307,7 +293,7 @@ module Bitfab
       # Descendants require no Bitfab declarations and record as function spans.
       def bitfab_trace(method_name, trace_function_key: nil, name: nil, type: "custom",
         max_depth: Subtree::DEFAULT_MAX_DEPTH, max_spans: Subtree::DEFAULT_MAX_SPANS,
-        exclude: [], include_wrappers: false)
+        exclude: [], include_wrappers: false, mock_on_replay_default: false)
         trace_function_key ||= @bitfab_function_key
         unless trace_function_key
           raise "No trace function key provided. Pass `trace_function_key:` to `bitfab_trace` " \
@@ -321,7 +307,8 @@ module Bitfab
           max_depth:,
           max_spans:,
           exclude:,
-          include_wrappers:
+          include_wrappers:,
+          mock_on_replay_default:
         }
         if method_defined?(method_name) || private_method_defined?(method_name)
           _bitfab_trace_method(method_name, **config)
@@ -334,7 +321,7 @@ module Bitfab
       # EXPERIMENTAL. Configure one method discovered beneath bitfab_trace.
       # The node inherits the active trace key and never traces by itself.
       def bitfab_node(method_name, name: nil, type: "custom", capture: true,
-        test_run_id: nil, mock_on_replay: false, finalize: nil)
+        test_run_id: nil, mock_on_replay: nil, finalize: nil)
         Traceable.send(:validate_node_options!, capture:, mock_on_replay:)
         config = {name:, type:, capture:, test_run_id:, mock_on_replay:, finalize:}
         if method_defined?(method_name) || private_method_defined?(method_name)
@@ -361,88 +348,16 @@ module Bitfab
         end
       end
 
-      def _bitfab_wrap_method(method_name, trace_function_key:, name: nil, type: "custom",
-        capture_when: "always", mock_on_replay: false)
-        span_name = name || method_name.to_s
-        method_name_str = method_name.to_s
-
-        wrapper = Module.new do
-          define_method(method_name) do |*args, **kwargs, &block|
-            # If Bitfab was never configured, run the real method untraced
-            # rather than raising a "not configured" error into the host app.
-            client = Bitfab.client_or_nil
-            return super(*args, **kwargs, &block) unless client
-
-            client.send(:execute_span,
-              trace_function_key:,
-              span_name:,
-              span_type: type,
-              function_name: method_name_str,
-              args:,
-              kwargs:,
-              capture_when:,
-              mock_on_replay:,
-              explicit_span_receiver: self,
-              explicit_span_method_name: method_name) do
-              super(*args, **kwargs, &block)
-            end
-          end
-        end
-
-        wrapper.instance_variable_set(:@bitfab_span_method, method_name_str)
-        wrapper.instance_variable_set(:@bitfab_span_key, trace_function_key)
-        prepend(wrapper)
+      def _bitfab_wrap_method(method_name, **options)
+        Traceable.wrap(self, method_name, **options)
       end
 
-      def _bitfab_trace_method(method_name, trace_function_key:, name: nil, type: "custom",
-        max_depth: Subtree::DEFAULT_MAX_DEPTH, max_spans: Subtree::DEFAULT_MAX_SPANS,
-        exclude: [], include_wrappers: false)
-        source = Traceable.send(:source_of, self, method_name)
-        capture_config = Subtree.prepare(root_source: source, exclude:)
-        span_name = name || method_name.to_s
-        method_name_str = method_name.to_s
-
-        wrapper = Module.new do
-          define_method(method_name) do |*args, **kwargs, &block|
-            if Subtree.active_trace?(trace_function_key)
-              next super(*args, **kwargs, &block)
-            end
-
-            client = Bitfab.client_or_nil
-            return super(*args, **kwargs, &block) unless client
-
-            client.send(
-              :execute_span,
-              trace_function_key:,
-              span_name:,
-              span_type: type,
-              function_name: method_name_str,
-              args:,
-              kwargs:,
-              independent_root: true
-            ) do
-              Subtree.capture(
-                client:,
-                trace_function_key:,
-                config: capture_config,
-                max_depth:,
-                max_spans:,
-                include_wrappers:,
-                root_receiver: self,
-                root_method_name: method_name
-              ) { super(*args, **kwargs, &block) }
-            end
-          end
-        end
-
-        wrapper.instance_variable_set(:@bitfab_span_method, method_name_str)
-        wrapper.instance_variable_set(:@bitfab_span_key, trace_function_key)
-        Traceable.send(:preserve_visibility, self, wrapper, method_name)
-        prepend(wrapper)
+      def _bitfab_trace_method(method_name, **options)
+        Traceable.trace(self, method_name, **options)
       end
 
       def _bitfab_node_method(method_name, name: nil, type: "custom", capture: true,
-        test_run_id: nil, mock_on_replay: false, finalize: nil)
+        test_run_id: nil, mock_on_replay: nil, finalize: nil)
         Traceable.node(
           self,
           method_name,

data/lib/bitfab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bitfab
-  VERSION = "0.51.8"
+  VERSION = "0.51.10"
 end