bitfab 0.64.25 → 0.65.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6be3e712951d897d0cd849ae85155eb7276e170799228d7d84b190d40f376b3c
-  data.tar.gz: fd8221b81baa82065582036be59042b2b0faff64e09e173b6f754ca4b3c592c5
+  metadata.gz: 9ed49d0b493c83442f21b1fc0ec1598cc675ce438601c357d9e3b16173c9e06d
+  data.tar.gz: fde85c743c635b053536c67ede3cced56eb560f92e13ed4014851399ef0f9fa1
 SHA512:
-  metadata.gz: de63a2a365d14b3bc59d6cf3b4e427203f56d2963d760732444cee78bdc03d45e57f4da9b7ffd26fb30ad71f7f0d5d9d7df35fad9873bf5a7d8e59de12ba1f13
-  data.tar.gz: fd21103ff0706e5e3200c35a8cd1fa65b4df2404882f9d6a35c4676d790e9d512bb2dae4aabb0aec4c2ff8820901b74bd0632d953367fc3c029bdcd26495f8fc
+  metadata.gz: ed71773a0f5eb1b56f7245e6b77add9c61119ed38dabb2271f322e07b7cbda014d22f9167d52631ebdb99452f64916c1713ec0808042c43db8c1a37184ad5a34
+  data.tar.gz: 4539a52a91412534ef12b06ac326b14280ed09b241f203783c731c9ab5b8c4879f623b977ab71124ac2d1c90b4e8e29e27dbbdf7e6ba94ef3a14afe0d9599327

data/lib/bitfab/assertions.rb

@@ -4,22 +4,39 @@ require "uri"
 
 module Bitfab
   class Traces
+    CATEGORY_ID_KEYS = ["category_id", :category_id].freeze
+    DEPRECATED_CATEGORY_ID_KEYS = ["category_assertion_id", :category_assertion_id].freeze
+    private_constant :CATEGORY_ID_KEYS, :DEPRECATED_CATEGORY_ID_KEYS
+
     def initialize(http_client)
       @http_client = http_client
     end
 
+    # Each returned assertion carries "category_id" and, with the same value,
+    # the deprecated "category_assertion_id".
     def get_assertions(trace_id)
-      @http_client.get(assertions_path(trace_id))
+      response = @http_client.get(assertions_path(trace_id))
+      return response unless response.is_a?(Hash) && response["assertions"].is_a?(Array)
+
+      response.merge("assertions" => response["assertions"].map { |assertion| with_both_category_keys(assertion) })
     end
 
+    # Assertion hashes take "category_id": omit it to keep the assignment, or
+    # pass nil to clear it. The deprecated "category_assertion_id" is still
+    # accepted and sent as "category_id"; "category_id" wins when both are set.
     def save_assertions(trace_id, assertions, source: "agent")
       save_assertions_all([{"traceId" => trace_id, "assertions" => assertions}], source:)
     end
 
+    # Same assertion hash keys as {#save_assertions}, for several traces at once.
     def save_assertions_all(updates, source: "agent")
       return [] if updates.empty?
 
-      @http_client.request("/api/sdk/traces/assertions", {"updates" => updates, "source" => source})["assertions"]
+      saved = @http_client.request(
+        "/api/sdk/traces/assertions",
+        {"updates" => updates.map { |update| with_new_category_key(update) }, "source" => source}
+      )["assertions"]
+      saved.is_a?(Array) ? saved.map { |assertion| with_both_category_keys(assertion) } : saved
     end
 
     def archive_assertions(trace_id, assertion_ids)
@@ -31,5 +48,39 @@ module Bitfab
     def assertions_path(trace_id, suffix = "")
       "/api/sdk/traces/#{URI.encode_www_form_component(trace_id).gsub("+", "%20")}/assertions#{suffix}"
     end
+
+    def with_new_category_key(update)
+      return update unless update.is_a?(Hash)
+
+      key = ["assertions", :assertions].find { |candidate| update[candidate].is_a?(Array) }
+      return update if key.nil?
+
+      update.merge(key => update[key].map { |assertion| rename_category_key(assertion) })
+    end
+
+    def rename_category_key(assertion)
+      return assertion unless assertion.is_a?(Hash)
+
+      old_key = DEPRECATED_CATEGORY_ID_KEYS.find { |candidate| assertion.key?(candidate) }
+      return assertion if old_key.nil?
+
+      Bitfab.warn_once("category-assertion-id-deprecated",
+        "category_assertion_id is deprecated; use category_id instead.")
+      renamed = assertion.except(*DEPRECATED_CATEGORY_ID_KEYS)
+      renamed["category_id"] = assertion[old_key] unless CATEGORY_ID_KEYS.any? { |candidate| assertion.key?(candidate) }
+      renamed
+    end
+
+    def with_both_category_keys(assertion)
+      return assertion unless assertion.is_a?(Hash)
+
+      if assertion.key?("category_id")
+        assertion.key?("category_assertion_id") ? assertion : assertion.merge("category_assertion_id" => assertion["category_id"])
+      elsif assertion.key?("category_assertion_id")
+        assertion.merge("category_id" => assertion["category_assertion_id"])
+      else
+        assertion
+      end
+    end
   end
 end

data/lib/bitfab/{assertion_categories.rb → categories.rb}

@@ -3,8 +3,9 @@
 require "uri"
 
 module Bitfab
-  class AssertionCategories
-    PATH = "/api/sdk/assertionCategories"
+  # The organization's categories, which group assertions and scenarios.
+  class Categories
+    PATH = "/api/sdk/categories"
     private_constant :PATH
 
     def initialize(http_client)
@@ -36,4 +37,7 @@ module Bitfab
       URI.encode_www_form_component(value).gsub("+", "%20")
     end
   end
+
+  # @deprecated Use {Categories}.
+  AssertionCategories = Categories
 end

data/lib/bitfab/client.rb

@@ -37,7 +37,13 @@ module Bitfab
 
     attr_reader :service_url
 
-    attr_reader :datasets, :assertion_categories, :organization_members, :traces, :spans, :labels, :graders, :experiments
+    attr_reader :datasets, :categories, :organization_members, :traces, :spans, :labels, :graders, :experiments
+
+    # @deprecated Use {#categories}. Returns the same object.
+    def assertion_categories
+      Bitfab.warn_once("assertion-categories-deprecated", "assertion_categories is deprecated; use categories instead.")
+      @categories
+    end
 
     def initialize(api_key: nil, service_url: nil, capture_enabled: nil, enabled: nil, strict: false, simulation_plan: true, timeout: 120, trace_across_threads: nil, env_vars: nil, baml_client: nil, db_snapshot: nil)
       @db_snapshot = DbSnapshot.normalize_config(db_snapshot)
@@ -54,7 +60,7 @@ module Bitfab
       @http_client = HttpClient.new(api_key: -> { resolve_api_key }, service_url: @service_url, timeout:)
       @http_client.configure_simulation_plan(enabled: simulation_plan, start: !api_key_resolved_lazily?)
       @datasets = Datasets.new(@http_client)
-      @assertion_categories = AssertionCategories.new(@http_client)
+      @categories = Categories.new(@http_client)
       @organization_members = OrganizationMembers.new(@http_client)
       @traces = Traces.new(@http_client)
       @spans = Spans.new(@http_client)

data/lib/bitfab/scenarios.rb

@@ -21,8 +21,13 @@ module Bitfab
     # {"summary" => String, "actions" => [{"name", "details", "result", "failed", "at"}], "source" => Hash or nil}
     # and replaces the saved value whole. Passing nil clears it. Leaving it out keeps it.
     #
+    # category_ids: files the scenario under those categories and replaces its whole set of categories.
+    # Leave it out to keep the current set, and pass an empty array to clear it. The returned hash lists the
+    # scenario's categories under "categories", each {"id", "title", "description"}, sorted by title.
+    #
     # Raises ArgumentError before any request when nothing is passed, or when data: and append_data: are both passed.
-    def save_scenario(trace_id, name: nil, description: nil, trigger: nil, data: nil, append_data: nil, actual_outcome: UNSET)
+    def save_scenario(trace_id, name: nil, description: nil, trigger: nil, data: nil, append_data: nil, actual_outcome: UNSET,
+      category_ids: nil)
       if !data.nil? && !append_data.nil?
         raise ArgumentError, "Pass data or append_data, not both: data replaces the saved data whole."
       end
@@ -34,8 +39,9 @@ module Bitfab
       payload["data"] = data unless data.nil?
       payload["appendData"] = append_data unless append_data.nil?
       payload["actualOutcome"] = actual_outcome unless actual_outcome.equal?(UNSET)
+      payload["categoryIds"] = category_ids.to_a unless category_ids.nil?
       if payload.empty?
-        raise ArgumentError, "Pass at least one of name, description, trigger, data, append_data, or actual_outcome: there is nothing to save otherwise."
+        raise ArgumentError, "Pass at least one of name, description, trigger, data, append_data, actual_outcome, or category_ids: there is nothing to save otherwise."
       end
 
       @http_client.request(scenario_path(trace_id), payload)["scenario"]

data/lib/bitfab/subtree.rb

@@ -796,6 +796,8 @@ module Bitfab
       end
 
       def skip_boundary_call?(event)
+        return false if sdk_frame?(event.path)
+
         boundary = @stacks[Fiber.current.object_id]&.last
         if boundary.is_a?(Boundary) && boundary.skip_next_call &&
             boundary.receiver.equal?(event.self) && boundary.method_name == called_method_id(event)
@@ -819,6 +821,13 @@ module Bitfab
         true
       end
 
+      def sdk_frame?(path)
+        @sdk_frames ||= {}
+        @sdk_frames.fetch(path) do
+          @sdk_frames[path] = Subtree.realpath(path)&.start_with?(SDK_PREFIX) || false
+        end
+      end
+
       def passthrough_wrapper?(parameters)
         kinds = parameters.map(&:first)
         kinds.any? { |kind| kind == :rest || kind == :keyrest } &&

data/lib/bitfab/traceable.rb

@@ -108,7 +108,7 @@ module Bitfab
               client: target_client, trace_function_key:, config: capture_config,
               max_depth:, max_captured_subtree_spans:, include_wrappers:, mock_on_replay_default:,
               root_receiver: self, root_method_name: method_name
-            ) { super(*args, **kwargs, &block) }
+            ) { Traceable.send(:as_root_call, self, method_name) { super(*args, **kwargs, &block) } }
           end
           call = Subtree::ConfiguredCall.new(receiver: self, method_name:, name: span_name,
             type:, args:, kwargs:, nested_trace_key: trace_function_key)
@@ -122,12 +122,14 @@ module Bitfab
               client: target_client, trace_function_key:, config: capture_config,
               max_depth:, max_captured_subtree_spans:, include_wrappers:, mock_on_replay_default:,
               root_receiver: self, root_method_name: method_name
-            ) { super(*args, **kwargs, &block) }
+            ) { Traceable.send(:as_root_call, self, 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)
+      wrapper.instance_variable_set(:@bitfab_trace_method, method_name_str)
+      wrapper.instance_variable_set(:@bitfab_trace_client, bound_client)
       preserve_visibility(klass, wrapper, method_name)
       klass.prepend(wrapper)
     end
@@ -142,9 +144,12 @@ module Bitfab
       bound_client = client
       wrapper = Module.new do
         define_method(method_name) do |*args, **kwargs, &block|
+          next super(*args, **kwargs, &block) if Traceable.send(:own_span_call?, self, method_name)
+
           Subtree.assert_surface!(:trace)
           session = Subtree.current_session
-          if !session || (bound_client && !session.client.equal?(bound_client))
+          if !session || (bound_client && !session.client.equal?(bound_client)) ||
+              Traceable.send(:root_handles_call?, self, method_name, wrapper)
             next super(*args, **kwargs, &block)
           end
           unless capture
@@ -176,6 +181,49 @@ module Bitfab
       klass.prepend(wrapper)
     end
 
+    ROOT_CALL_KEY = :bitfab_root_call
+
+    def self.as_root_call(receiver, method_name)
+      previous = Thread.current[ROOT_CALL_KEY]
+      Thread.current[ROOT_CALL_KEY] = [receiver, method_name.to_sym]
+      yield
+    ensure
+      Thread.current[ROOT_CALL_KEY] = previous
+    end
+    private_class_method :as_root_call
+
+    def self.root_handles_call?(receiver, method_name, node_wrapper)
+      marker = Thread.current[ROOT_CALL_KEY]
+      if marker && marker[0].equal?(receiver) && marker[1] == method_name.to_sym
+        Thread.current[ROOT_CALL_KEY] = nil
+        return true
+      end
+
+      trace_wrapper = inner_trace_wrapper(receiver, method_name, node_wrapper)
+      return false unless trace_wrapper
+
+      client = trace_wrapper.instance_variable_get(:@bitfab_trace_client) || Bitfab.client_or_nil
+      (client&.send(:should_record?) && !Subtree.nested_root_suppressed?) ? true : false
+    end
+    private_class_method :root_handles_call?
+
+    def self.own_span_call?(receiver, method_name)
+      span = SpanContext.current
+      return false unless span && span[:surface] == :span
+
+      span[:explicit_span_receiver].equal?(receiver) && span[:explicit_span_method_name] == method_name
+    end
+    private_class_method :own_span_call?
+
+    def self.inner_trace_wrapper(receiver, method_name, node_wrapper)
+      ancestors = receiver.is_a?(Module) ? receiver.singleton_class.ancestors : receiver.class.ancestors
+      name = method_name.to_s
+      ancestors.drop_while { |mod| !mod.equal?(node_wrapper) }.find do |mod|
+        mod.instance_variable_defined?(:@bitfab_trace_method) && mod.instance_variable_get(:@bitfab_trace_method) == name
+      end
+    end
+    private_class_method :inner_trace_wrapper
+
     def self.source_of(klass, method_name)
       path, line = klass.instance_method(method_name).source_location || [nil, nil]
       [path, line, method_name]
@@ -345,15 +393,14 @@ module Bitfab
 
       def method_added(method_name)
         super
+        if defined?(@_bitfab_pending_nodes) && @_bitfab_pending_nodes&.key?(method_name)
+          _bitfab_node_method(method_name, **@_bitfab_pending_nodes.delete(method_name))
+        end
         if defined?(@_bitfab_pending_spans) && @_bitfab_pending_spans&.key?(method_name)
-          config = @_bitfab_pending_spans.delete(method_name)
-          _bitfab_wrap_method(method_name, **config)
-        elsif defined?(@_bitfab_pending_traces) && @_bitfab_pending_traces&.key?(method_name)
-          config = @_bitfab_pending_traces.delete(method_name)
-          _bitfab_trace_method(method_name, **config)
-        elsif defined?(@_bitfab_pending_nodes) && @_bitfab_pending_nodes&.key?(method_name)
-          config = @_bitfab_pending_nodes.delete(method_name)
-          _bitfab_node_method(method_name, **config)
+          _bitfab_wrap_method(method_name, **@_bitfab_pending_spans.delete(method_name))
+        end
+        if defined?(@_bitfab_pending_traces) && @_bitfab_pending_traces&.key?(method_name)
+          _bitfab_trace_method(method_name, **@_bitfab_pending_traces.delete(method_name))
         end
       end
 

data/lib/bitfab/version.rb

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

data/lib/bitfab.rb

@@ -15,7 +15,7 @@ require_relative "bitfab/git_state"
 require_relative "bitfab/span_context"
 require_relative "bitfab/http_client"
 require_relative "bitfab/datasets"
-require_relative "bitfab/assertion_categories"
+require_relative "bitfab/categories"
 require_relative "bitfab/organization_members"
 require_relative "bitfab/traces"
 require_relative "bitfab/spans"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.64.25
+  version: 0.65.1
 platform: ruby
 authors:
 - Harvest Team
@@ -155,9 +155,9 @@ files:
 - exe/bitfab-replay
 - exe/bitfab-seed
 - lib/bitfab.rb
-- lib/bitfab/assertion_categories.rb
 - lib/bitfab/assertions.rb
 - lib/bitfab/baml.rb
+- lib/bitfab/categories.rb
 - lib/bitfab/client.rb
 - lib/bitfab/cloudReplay.py
 - lib/bitfab/cloud_replay_cli.rb