bitfab 0.57.8 → 0.58.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 187464e848086662f6d74efe91dfe95476bdae7284d7ba5668f49b2a4af4c606
-  data.tar.gz: 16fce40beaf7dc062e5d6d31624d6393730847b1eaee578b60459b5f0d27897a
+  metadata.gz: 49c5627d0b0880adf5971614d2b017bf97a1886313776b757996d1bdab1d1f92
+  data.tar.gz: cce67f5a022711dc884d9b391d2daa4547b5fc11fdff1ab159c7a5b82fb404bf
 SHA512:
-  metadata.gz: 7a5f7f9cac1900dca07228819c1c40965cf020deb5adba9f9827c36c76265911e79c5ce3aca16db5e486c354a436f63e9ac487896af9c2cf522581886424887d
-  data.tar.gz: 560d27de6a0766f9625b82bcf33053ebfffd3792dbaf2a21cd59ddd7a129742d265965d086d68138566dee51a5ba02893fdcf0bf67a95ebc8d24bc4d37ecf6ff
+  metadata.gz: 28f813f00802eda3f55615bf5acba0264d6e9a80130117522436eefb943be3fbd17753289a6a2f7e6295ed9772380221a89a9c3e8477041b974f5d3f4cde917f
+  data.tar.gz: a15a81f27f2ef548b854a7b53cdd32a813583b31066a0cba8a40aa364c1bdf9e771f9534bd0aab8b5355bc146fbff18ec0a1cfb9a417634e28ab9691e6cdc6c7

data/README.md

@@ -235,7 +235,7 @@ class OrderPipeline
 end
 ```
 
-Capture uses `TracePoint` only during the root call. It skips Ruby/runtime code, dependency gems, Bitfab SDK internals, blocks, lambdas, and forwarding wrappers. When the root belongs to an installed application gem, that gem is the first-party boundary; neighboring dependency gems remain excluded. It follows recursion, modules, inheritance, `define_method`, and same-thread child Fibers; aliases are recorded and excluded by the name that was invoked. Child Fibers created during capture inherit node policies, trace identity, parenting, and depth limits while retaining separate call stacks. Pre-existing Fibers, `Fiber.new(storage: nil)`, and child threads do not inherit subtree context. When an inner capture ends, child Fibers retain any still-active outer capture; inherited context expires once all enclosing captures end. While a root remains active, hitting a span limit stops new capture but allows already-open spans in every Fiber to finish. `max_depth:` (default `30`), `max_captured_subtree_spans:` (default `500`), `max_spans:` (default `10000`), `exclude:`, and `include_wrappers:` control the subtree. `max_spans:` is a strict cap on the total number of spans one trace root sends. It counts the root span itself, discovered calls, `bitfab_node` calls, nested trace roots, and spans whose capture is on or off, including spans sent without inputs and outputs because the sim plan could not be read. Nothing past it is sent. It must be at least 1, and a lower value raises `ArgumentError`. `max_captured_subtree_spans:` caps discovered calls sent with their inputs and outputs. It does not count `bitfab_node` calls, nested trace roots, or spans the loaded sim plan turned capture off for, so those keep recording past it up to `max_spans:`. Spans sent without inputs and outputs only because the sim plan could not be read still count toward it. Past it, further discovered calls with capture on record nothing. It is never higher than `max_spans:`. Once the plan has loaded, the SDK never builds the inputs or outputs of a span whose capture it turned off. The client starts reading the sim plan when it is built. A `bitfab_trace` root that starts while that first read is still running waits for it, for at most five seconds. Once the first read has finished, whether it succeeded or failed, no later root waits. Nested roots and the calls beneath a root never wait, and nothing waits when the plan is disabled. If that first read fails, spans other than each trace's root span are sent without inputs and outputs until a read succeeds, and they still count toward both limits. Automatically captured calls are not replay mock targets. Declare a call with `bitfab_node` when replay must substitute it. The configured node records once in each enclosing trace. Mixing explicit spans with subtree tracing raises `Bitfab::MixedTracingError`.
+Capture uses `TracePoint` only during the root call. It skips Ruby/runtime code, dependency gems, Bitfab SDK internals, blocks, lambdas, and forwarding wrappers. When the root belongs to an installed application gem, that gem is the first-party boundary; neighboring dependency gems remain excluded. It follows recursion, modules, inheritance, `define_method`, and same-thread child Fibers; aliases are recorded and excluded by the name that was invoked. Child Fibers created during capture inherit node policies, trace identity, parenting, and depth limits while retaining separate call stacks. Pre-existing Fibers, `Fiber.new(storage: nil)`, and child threads do not inherit subtree context. When an inner capture ends, child Fibers retain any still-active outer capture; inherited context expires once all enclosing captures end. While a root remains active, hitting a span limit stops new capture but allows already-open spans in every Fiber to finish. `max_depth:` (default `30`), `max_captured_subtree_spans:` (default `500`), `exclude:`, and `include_wrappers:` control the subtree. There is no cap on the total number of spans one trace root sends. `max_spans:` was removed, and passing it raises `ArgumentError`. `max_captured_subtree_spans:` caps discovered calls sent with their inputs and outputs. It does not count `bitfab_node` calls, nested trace roots, or spans the loaded sim plan turned capture off for, so those keep recording past it. Spans sent without inputs and outputs only because the sim plan could not be read still count toward it. Past it, further discovered calls with capture on record nothing. Once the plan has loaded, the SDK does not send a span whose capture it turned off, and that span's children move up to the nearest visible parent. The trace's root span, a framework integration span, and a span that recorded an error are still sent, and the SDK never builds their inputs or outputs. A `bitfab_node` call and a nested trace root ignore the plan and always keep their inputs and outputs. The client starts reading the sim plan when it is built. A `bitfab_trace` root that starts while that first read is still running waits for it, for at most five seconds. Once the first read has finished, whether it succeeded or failed, no later root waits. Nested roots and the calls beneath a root never wait, and nothing waits when the plan is disabled. If that first read fails, spans other than each trace's root span, `bitfab_node` calls, and nested trace roots are sent without inputs and outputs until a read succeeds, and they still count toward `max_captured_subtree_spans:`. Automatically captured calls are not replay mock targets. Declare a call with `bitfab_node` when replay must substitute it. The configured node records once in each enclosing trace. Mixing explicit spans with subtree tracing raises `Bitfab::MixedTracingError`.
 
 When capture ends, already-open automatic calls in suspended Fibers are emitted once with a nil output and `Subtree capture ended before the call returned` as the error, unless a real error was already observed. Their inputs and parenting are retained. The SDK does not resume Fibers, and later resumption cannot add spans to the ended capture. If hot reload moves the root to an unresolved source, the last valid first-party boundary and its exclusions remain in use.
 

data/lib/bitfab/client.rb

@@ -376,7 +376,7 @@ module Bitfab
       capture_when: "always", mock_on_replay: false, independent_root: false,
       explicit_span_receiver: nil, explicit_span_method_name: nil, test_run_id: nil, finalize: nil,
       surface: nil, on_start: nil, on_complete: nil, around_body: nil, span_data: {}, managed_root: false,
-      result_recorded_elsewhere: false)
+      result_recorded_elsewhere: false, declared_node: false)
       return yield unless should_record?
 
       @http_client.refresh_simulation_plan
@@ -477,7 +477,8 @@ module Bitfab
               test_run_id: resolved_test_run_id,
               input_source_span_id: resolved_input_source_span_id,
               mock_source:,
-              instrumentation: (surface == :trace) ? "trace" : "span"
+              instrumentation: (surface == :trace) ? "trace" : "span",
+              declared_node:
             )
             on_complete&.call(result: mocked_output, error: nil, ended_at: Bitfab.now_iso_timestamp)
             return mocked_output
@@ -509,6 +510,8 @@ module Bitfab
       @http_client.trace_completion.start(trace_id, span_id)
       recording_override = managed_root ? {} : nil
       content_withheld = lambda do
+        next false if declared_node
+
         instrumentation = recording_override&.dig(:instrumentation) || ((surface == :trace) ? "trace" : "span")
         content_off_by_simulation_plan?(
           trace_id:, trace_function_key:, span_name: recording_override&.dig(:name) || span_name, instrumentation:
@@ -544,6 +547,7 @@ module Bitfab
           send_span(
             span_data: content_off ? span_data.merge("content_off_by_simulation_plan" => true) : span_data,
             instrumentation: recorded_instrumentation,
+            declared_node:,
             trace_function_key:,
             trace_id:,
             span_id:,
@@ -921,7 +925,7 @@ module Bitfab
     def send_span(trace_function_key:, trace_id:, span_id:, parent_span_id:,
       span_name:, span_type:, function_name:, contexts:, prompt:, args:, kwargs:, result:, error:,
       started_at:, ended_at:, test_run_id: nil, input_source_span_id: nil, mocked: false,
-      mock_target: nil, mock_source: nil, span_data: {}, instrumentation: "span")
+      mock_target: nil, mock_source: nil, span_data: {}, instrumentation: "span", declared_node: false)
       extra_span_data = span_data
       # If drop() was called on this trace, suppress the span PAYLOAD upload for
       # every span that completes after the flag was set. The trace completion
@@ -933,9 +937,9 @@ module Bitfab
       # Human-readable JSON (input/output fields). The *_with_report variants
       # also report what could not be faithfully captured so a lossy span is
       # marked non-replayable below instead of shipping as if it round-trips.
-      content_off = extra_span_data["content_off_by_simulation_plan"] == true ||
+      content_off = !declared_node && (extra_span_data["content_off_by_simulation_plan"] == true ||
         content_off_by_simulation_plan?(trace_id:, trace_function_key:, span_name:, instrumentation:) ||
-        (!parent_span_id.nil? && simulation_plan_unavailable?(instrumentation:))
+        (!parent_span_id.nil? && simulation_plan_unavailable?(instrumentation:)))
       if content_off
         dropped = []
         span_data = {"name" => span_name, "type" => span_type, "function_name" => function_name}
@@ -1011,7 +1015,7 @@ module Bitfab
         }]
       end
 
-      @http_client.send_external_span(payload) # Returns the background thread
+      @http_client.send_external_span(payload, declared_node)
     end
 
     # Advance the per-(key, name) call counter when this invocation is a
@@ -1141,7 +1145,7 @@ module Bitfab
     # output as the result and no error.
     def send_mocked_span(trace_function_key:, trace_id:, span_id:, parent_span_id:,
       span_name:, span_type:, function_name:, args:, kwargs:, mocked_output:,
-      started_at:, test_run_id:, input_source_span_id:, mock_source:, instrumentation: "span")
+      started_at:, test_run_id:, input_source_span_id:, mock_source:, instrumentation: "span", declared_node: false)
       ended_at = Bitfab.now_iso_timestamp
       send_span(
         trace_function_key:,
@@ -1163,6 +1167,7 @@ module Bitfab
         input_source_span_id:,
         mocked: true,
         instrumentation:,
+        declared_node:,
         # Both paths short-circuit the call, so the target is always the
         # output; only where the value came from differs.
         mock_target: "output",
@@ -1223,7 +1228,7 @@ module Bitfab
 
     # Experimentally trace an existing method and its first-party call subtree.
     def trace(klass, method_name, name: nil, type: "custom",
-      max_depth: Subtree::DEFAULT_MAX_DEPTH, max_spans: Subtree::DEFAULT_MAX_SPANS,
+      max_depth: Subtree::DEFAULT_MAX_DEPTH,
       max_captured_subtree_spans: Subtree::DEFAULT_MAX_CAPTURED_SUBTREE_SPANS,
       exclude: [], include_wrappers: false, mock_on_replay_default: false)
       Bitfab::Traceable.trace(
@@ -1232,7 +1237,6 @@ module Bitfab
         name:,
         type:,
         max_depth:,
-        max_spans:,
         max_captured_subtree_spans:,
         exclude:,
         include_wrappers:,

data/lib/bitfab/http_client.rb

@@ -188,7 +188,7 @@ module Bitfab
     end
 
     # Queue an external span on this client's trace transport (fire-and-forget).
-    def send_external_span(payload)
+    def send_external_span(payload, declared_node = false)
       if (data = payload.dig("rawSpan", "span_data")).is_a?(Hash) && !data.key?("runtime")
         payload = payload.merge("rawSpan" => payload["rawSpan"].merge("span_data" => data.merge("runtime" => ThreadPropagation.runtime)))
       end
@@ -204,7 +204,11 @@ module Bitfab
           recorded_meta("external_span", record, ref)
         )
       }
-      @simulation_plan ? @simulation_plan.send_span(payload, &submit) : submit.call(payload)
+      discard = ->(record) {
+        ref = carrier_ref(record)
+        @trace_completion.discard(ref.trace_id, ref.span_id) if ref&.span_id
+      }
+      @simulation_plan ? @simulation_plan.send_span(payload, declared_node:, discard:, &submit) : submit.call(payload)
     end
 
     def send_internal_trace(function_id, payload)

data/lib/bitfab/simulation_plan.rb

@@ -69,7 +69,7 @@ module Bitfab
       @mutex.synchronize { start_reader(0) if @thread.nil? && now >= @refresh_after }
     end
 
-    def send_span(payload, &submit)
+    def send_span(payload, declared_node: false, discard: nil, &submit)
       refresh
       data = payload.dig("rawSpan", "span_data")
       key = payload["rootTraceFunctionKey"] || payload["traceFunctionKey"]
@@ -77,7 +77,7 @@ module Bitfab
         submit.call(payload)
         return
       end
-      entry = [payload, key, submit]
+      entry = [payload, key, submit, discard, declared_node]
       ready = @mutex.synchronize { reading? ? hold(entry) : entry }
       deliver(*ready) if ready
     end
@@ -164,6 +164,7 @@ module Bitfab
       names = @mutex.synchronize { @content_off&.fetch(key, nil) }
       data = payload.dig("rawSpan", "span_data")
       return payload unless data.is_a?(Hash) && names&.include?(data["name"])
+      return nil unless root?(payload) || data["error"]
 
       without_content(payload, data)
     end
@@ -196,12 +197,13 @@ module Bitfab
       @held.shift if @held.length > MAX_HELD
     end
 
-    def deliver(payload, key, submit)
-      submit.call(prepare(payload, key))
+    def deliver(payload, key, submit, discard = nil, declared_node = false)
+      record = declared_node ? payload : prepare(payload, key)
+      record ? submit.call(record) : discard&.call(payload)
     end
 
-    def deliver_safely(payload, key, submit)
-      deliver(payload, key, submit)
+    def deliver_safely(payload, key, submit, discard = nil, declared_node = false)
+      deliver(payload, key, submit, discard, declared_node)
     rescue => error
       Bitfab.warn_once("sim-plan-held-span-dropped", "Held record could not be sent: #{error}")
     end

data/lib/bitfab/subtree.rb

@@ -10,9 +10,8 @@ module Bitfab
 
   module Subtree
     DEFAULT_MAX_DEPTH = 30
-    DEFAULT_MAX_SPANS = 10_000
     DEFAULT_MAX_CAPTURED_SUBTREE_SPANS = 500
-    LIMIT_ORDER = %i[max_depth max_spans max_captured_subtree_spans].freeze
+    LIMIT_ORDER = %i[max_depth max_captured_subtree_spans].freeze
     SESSION_KEY = :bitfab_subtree_session
     DISPATCHER_KEY = :bitfab_subtree_dispatcher
     FIBER_CONTEXT_KEY = :bitfab_subtree_fiber_context
@@ -53,6 +52,7 @@ module Bitfab
       :span_type,
       :test_run_id,
       :span_data,
+      :declared_node,
       keyword_init: true
     )
 
@@ -175,7 +175,7 @@ module Bitfab
       CaptureConfig.new(root: nil, root_path: nil, exclude: {}.freeze).freeze
     end
 
-    def capture(client:, trace_function_key:, config:, max_depth:, max_spans:, include_wrappers:,
+    def capture(client:, trace_function_key:, config:, max_depth:, include_wrappers:,
       root_receiver:, root_method_name:, max_captured_subtree_spans: DEFAULT_MAX_CAPTURED_SUBTREE_SPANS, mock_on_replay_default: false)
       return yield unless config.root
 
@@ -193,7 +193,6 @@ module Bitfab
           input_source_span_id: replay&.dig(:input_source_span_id),
           config:,
           max_depth:,
-          max_spans:,
           max_captured_subtree_spans:,
           include_wrappers:,
           mock_on_replay_default:,
@@ -418,7 +417,7 @@ module Bitfab
       end
 
       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:,
+        input_source_span_id:, config:, max_depth:, include_wrappers:,
         root_receiver:, root_method_name:, max_captured_subtree_spans: DEFAULT_MAX_CAPTURED_SUBTREE_SPANS, mock_on_replay_default: false)
         @mock_on_replay_default = mock_on_replay_default
         @client = client
@@ -433,8 +432,7 @@ module Bitfab
         @root_method_name = root_method_name.to_sym
         @skip_root_call = true
         @max_depth = max_depth
-        @max_spans = max_spans
-        @max_captured_subtree_spans = [max_captured_subtree_spans, max_spans].min
+        @max_captured_subtree_spans = max_captured_subtree_spans
         @exclude = config.exclude
         @include_wrappers = include_wrappers
         @stacks = {}
@@ -443,7 +441,6 @@ module Bitfab
         @suppressed_depths = {}
         @owned_paths = {}
         @method_metadata = Hash.new { |owners, owner| owners[owner] = {} }
-        @spans_used = 1
         @captured_subtree_count = 0
         @limits_fired = Set.new
         @dropped_spans = 0
@@ -524,14 +521,9 @@ module Bitfab
 
       def reserve_node
         stack = current_stack(Fiber.current.object_id)
-        if captured_depth(stack) >= @max_depth
-          drop(:max_depth)
-          return false
-        end
-        return true if take_slot(discovered: false)
+        return true if captured_depth(stack) < @max_depth
 
-        drop(:max_spans)
-        @exhausted = true
+        drop(:max_depth)
         false
       end
 
@@ -547,7 +539,7 @@ module Bitfab
           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: {}
+          span_data: {}, declared_node: true
         )
         @configured_entries[entry.object_id] = entry
         entry
@@ -652,9 +644,9 @@ module Bitfab
           return
         end
         content_off = content_off?(metadata.name)
-        if (limit = limit_reached(discovered: true, content_off:))
-          drop(limit)
-          stop_discovery(fiber_id) unless limit == :max_captured_subtree_spans && content_off_names?
+        if !content_off && @captured_subtree_count >= @max_captured_subtree_spans
+          drop(:max_captured_subtree_spans)
+          stop_discovery(fiber_id) unless content_off_names?
           return
         end
 
@@ -665,7 +657,7 @@ module Bitfab
           return
         end
 
-        count_span(discovered: true, content_off:)
+        @captured_subtree_count += 1 unless content_off
         span_id = SecureRandom.uuid
         without_content = content_off || plan_unavailable?
         args, kwargs = without_content ? [[], {}] : inputs(event)
@@ -741,6 +733,7 @@ module Bitfab
           span_name: entry.name,
           span_type: entry.span_type || "function",
           instrumentation: "trace",
+          declared_node: entry.declared_node == true,
           span_data: entry.span_data || {},
           function_name: entry.name,
           contexts: nil,
@@ -890,24 +883,6 @@ module Bitfab
         @suppressed_depths[fiber_id] = 1
       end
 
-      def limit_reached(discovered:, content_off: false)
-        return :max_spans if @spans_used >= @max_spans
-
-        :max_captured_subtree_spans if discovered && !content_off && @captured_subtree_count >= @max_captured_subtree_spans
-      end
-
-      def take_slot(discovered:)
-        return false if limit_reached(discovered:)
-
-        count_span(discovered:, content_off: false)
-        true
-      end
-
-      def count_span(discovered:, content_off:)
-        @spans_used += 1
-        @captured_subtree_count += 1 if discovered && !content_off
-      end
-
       def stop_discovery(fiber_id)
         @exhausted = true
         if captured_calls_drained?
@@ -968,7 +943,7 @@ module Bitfab
         Bitfab.warn_once(
           "subtree-truncated:#{@trace_function_key}",
           "'#{@trace_function_key}' hit a subtree capture limit (max_depth=#{@max_depth}, " \
-          "max_captured_subtree_spans=#{@max_captured_subtree_spans}, max_spans=#{@max_spans}) and its trace is incomplete. " \
+          "max_captured_subtree_spans=#{@max_captured_subtree_spans}) and its trace is incomplete. " \
           "Raise the limits, add bitfab_node to the calls that matter, or narrow what is traced with exclude: [...]."
         )
       end

data/lib/bitfab/trace_completion.rb

@@ -31,6 +31,10 @@ module Bitfab
       end
     end
 
+    def discard(trace_id, span_id)
+      synchronize { @traces[trace_id]&.dig(:span_ids)&.delete(span_id) }
+    end
+
     def finish(trace_id, span_id)
       ready = synchronize do
         entry = @traces[trace_id]

data/lib/bitfab/traceable.rb

@@ -82,10 +82,9 @@ module Bitfab
     # The root records with the requested type; first-party Ruby methods called
     # 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,
+      max_depth: Subtree::DEFAULT_MAX_DEPTH,
       max_captured_subtree_spans: Subtree::DEFAULT_MAX_CAPTURED_SUBTREE_SPANS,
       exclude: [], include_wrappers: false, mock_on_replay_default: false, client: nil)
-      validate_trace_options!(max_spans:)
       capture_config = Subtree.prepare(root_source: source_of(klass, method_name), exclude:)
       method_name_str = method_name.to_s
       bound_client = client
@@ -106,7 +105,7 @@ module Bitfab
             SpanContext.current[:surface] = :trace
             next Subtree.capture(
               client: target_client, trace_function_key:, config: capture_config,
-              max_depth:, max_spans:, max_captured_subtree_spans:, include_wrappers:, mock_on_replay_default:,
+              max_depth:, max_captured_subtree_spans:, include_wrappers:, mock_on_replay_default:,
               root_receiver: self, root_method_name: method_name
             ) { super(*args, **kwargs, &block) }
           end
@@ -120,7 +119,7 @@ module Bitfab
             around_body: call.method(:run)) do
             Subtree.capture(
               client: target_client, trace_function_key:, config: capture_config,
-              max_depth:, max_spans:, max_captured_subtree_spans:, include_wrappers:, mock_on_replay_default:,
+              max_depth:, max_captured_subtree_spans:, include_wrappers:, mock_on_replay_default:,
               root_receiver: self, root_method_name: method_name
             ) { super(*args, **kwargs, &block) }
           end
@@ -165,7 +164,7 @@ module Bitfab
               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, result_recorded_elsewhere: call.recorded_elsewhere?,
+              test_run_id:, finalize:, surface: :trace, result_recorded_elsewhere: call.recorded_elsewhere?, declared_node: true,
               on_start: call.method(:start), on_complete: call.method(:complete),
               around_body: call.method(:run)) { super(*args, **kwargs, &block) }
           end
@@ -193,14 +192,6 @@ module Bitfab
     end
     private_class_method :preserve_visibility
 
-    def self.validate_trace_options!(max_spans:)
-      return if max_spans.is_a?(Integer) && max_spans >= 1
-
-      raise ArgumentError,
-        "bitfab_trace max_spans must be an integer of at least 1 because the root span takes one slot, got #{max_spans.inspect}."
-    end
-    private_class_method :validate_trace_options!
-
     def self.validate_node_options!(capture:, mock_on_replay:)
       return unless !capture && mock_on_replay
 
@@ -304,10 +295,9 @@ module Bitfab
       # EXPERIMENTAL. Trace a method and every first-party Ruby method it calls.
       # 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,
+        max_depth: Subtree::DEFAULT_MAX_DEPTH,
         max_captured_subtree_spans: Subtree::DEFAULT_MAX_CAPTURED_SUBTREE_SPANS,
         exclude: [], include_wrappers: false, mock_on_replay_default: false)
-        Traceable.send(:validate_trace_options!, max_spans:)
         trace_function_key ||= @bitfab_function_key
         unless trace_function_key
           raise "No trace function key provided. Pass `trace_function_key:` to `bitfab_trace` " \
@@ -319,7 +309,6 @@ module Bitfab
           name:,
           type:,
           max_depth:,
-          max_spans:,
           max_captured_subtree_spans:,
           exclude:,
           include_wrappers:,

data/lib/bitfab/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.57.8
+  version: 0.58.0
 platform: ruby
 authors:
 - Harvest Team