bitfab 0.29.1 → 0.30.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f26df032729a0c1fbad20c807e1581ec1c68bb9019e0b8f32a85237c785a6ed
-  data.tar.gz: 6acf7a7e153565cf4fb272b651f2740b4d3cb5722b67b6508552aa1b2e81d042
+  metadata.gz: 4a3e03384934c51dd57e27ac1213dca8f88b41ead5a0980c04bb10ba0ad464d8
+  data.tar.gz: da9c5574b00bd66ba481a78e0f1e0ce4f8e9336b35a7b2e9013498b475622237
 SHA512:
-  metadata.gz: 5fdcbb34b7174b5308d46405c95735d0a986db51f1af6ddbeb26613ebcdd9c35fade8a40553b1f88b78dc699261146d8cd9d4d7abffda560fbf06f40527717ce
-  data.tar.gz: ea2cd76d972b4b67f1554e1baf28b2aeeaf8560d1329eeff1f6df721273ce6f6e27193d20e0c0995ea77077544a5ab6f64cbb06908276eb8a27c6a6d590171b7
+  metadata.gz: 97f2755495103e92c94258f1763a1066bfc5a1944168e10dec1ad1e0bd24a58ca916791122cf3673f52326ca0d5b89b7ca8324071d40b6c408f3153167f6c95c
+  data.tar.gz: 61ba2d4b92cfa2c2665753319c6acf67dda2d48a547088d1ab47b2e9006835fe869185f3861d4e378f5c8e76167009f2580f385b5f6416467a24ae5b9dce8242

data/lib/bitfab/client.rb

@@ -83,6 +83,10 @@ module Bitfab
     #   replay runs into a single experiment batch
     # @param dataset_id [String, nil] optional UUID of the dataset this replay
     #   runs against, stored on the resulting experiment for durable attribution
+    # @param grader_ids [Array<String>, nil] optional UUIDs of graders attached
+    #   directly to this experiment, graded as the union with the dataset's
+    #   runnable graders at completion; each must be an active/live grader in the
+    #   same org and trace function or the server rejects the replay
     # @param mock [String] mock strategy for child spans: "marked" (default),
     #   "none", or "all". "marked" only mocks spans declared with
     #   mock_on_replay: true; "all" mocks every child span.
@@ -109,12 +113,12 @@ module Bitfab
     #   A raising callback never crashes the run.
     # @return [Hash] with :items, :test_run_id, :test_run_url
     def replay(receiver, method_name, trace_function_key:, limit: nil, trace_ids: nil, max_concurrency: 10,
-      name: nil, code_change_description: nil, code_change_files: nil, experiment_group_id: nil, dataset_id: nil, mock: "marked",
+      name: nil, code_change_description: nil, code_change_files: nil, experiment_group_id: nil, dataset_id: nil, grader_ids: nil, mock: "marked",
       adapt_inputs: nil, mock_override: nil, environment: nil, on_progress: nil)
       Replay.run(
         self, receiver, method_name,
         trace_function_key:, limit:, trace_ids:, name:, max_concurrency:,
-        code_change_description:, code_change_files:, experiment_group_id:, dataset_id:, mock:, adapt_inputs:,
+        code_change_description:, code_change_files:, experiment_group_id:, dataset_id:, grader_ids:, mock:, adapt_inputs:,
         mock_override:, environment:,
         on_progress:
       )

data/lib/bitfab/http_client.rb

@@ -112,8 +112,13 @@ module Bitfab
     #   experiment/test run
     # @param dataset_id [String, nil] optional UUID of the dataset this replay
     #   runs against, stored on the resulting experiment for durable attribution
+    # @param grader_ids [Array<String>, nil] optional UUIDs of graders attached
+    #   directly to this experiment, graded as the union with the dataset's
+    #   runnable graders at completion; each must be an active/live grader in the
+    #   same org and trace function or the server rejects the replay
     def start_replay(trace_function_key, limit, trace_ids: nil, code_change_description: nil,
-      code_change_files: nil, experiment_group_id: nil, name: nil, include_db_branch_lease: false, dataset_id: nil)
+      code_change_files: nil, experiment_group_id: nil, name: nil, include_db_branch_lease: false, dataset_id: nil,
+      grader_ids: nil)
       payload = {
         "traceFunctionKey" => trace_function_key
       }
@@ -127,6 +132,7 @@ module Bitfab
       payload["experimentGroupId"] = experiment_group_id unless experiment_group_id.nil?
       payload["includeDbBranchLease"] = true if include_db_branch_lease
       payload["datasetId"] = dataset_id unless dataset_id.nil?
+      payload["graderIds"] = grader_ids unless grader_ids.nil?
 
       # When DB branching is on, the server resolves a Neon preview branch per
       # item (snapshot + restore + poll), which can run several seconds each.

data/lib/bitfab/replay.rb

@@ -2,6 +2,8 @@
 
 require "fileutils"
 require "json"
+require "open3"
+require "timeout"
 
 require_relative "constants"
 require_relative "mock_override"
@@ -104,6 +106,10 @@ module Bitfab
     #   replay runs into a single experiment batch
     # @param dataset_id [String, nil] optional UUID of the dataset this replay
     #   runs against, stored on the resulting experiment for durable attribution
+    # @param grader_ids [Array<String>, nil] optional UUIDs of graders attached
+    #   directly to this experiment, graded as the union with the dataset's
+    #   runnable graders at completion; each must be an active/live grader in the
+    #   same org and trace function or the server rejects the replay
     # @param mock [String] mock strategy for child spans: "marked" (default),
     #   "none", or "all". "marked" only mocks spans declared with
     #   mock_on_replay: true; "all" mocks every child span.
@@ -129,7 +135,7 @@ module Bitfab
     # @return [Hash] with :items, :test_run_id, :test_run_url
     def run(client, receiver, method_name, trace_function_key:, limit: nil, trace_ids: nil, name: nil,
       max_concurrency: 10, code_change_description: nil, code_change_files: nil, experiment_group_id: nil,
-      dataset_id: nil, mock: "marked",
+      dataset_id: nil, grader_ids: nil, mock: "marked",
       adapt_inputs: nil, mock_override: nil, environment: nil, on_progress: nil)
       unless MOCK_STRATEGIES.include?(mock.to_s)
         raise ArgumentError, "Invalid mock strategy '#{mock}'. Must be one of: #{MOCK_STRATEGIES.join(", ")}"
@@ -175,6 +181,19 @@ module Bitfab
 
       include_db_branch_lease = !environment.nil?
 
+      # An explicit code change always wins; only when the caller passed neither
+      # field do we fall back to the payload the replay wrapper captured from git
+      # and handed over via BITFAB_CODE_CHANGE_PATH. This is what makes an
+      # experiment show its diff even when the run happened outside the
+      # assistant's make-change rails.
+      if code_change_description.nil? && code_change_files.nil?
+        captured = resolve_auto_code_change(name)
+        unless captured.nil?
+          code_change_description = captured[0]
+          code_change_files = captured[1]
+        end
+      end
+
       replay_data = http_client.start_replay(
         trace_function_key,
         effective_limit,
@@ -184,7 +203,8 @@ module Bitfab
         code_change_files:,
         experiment_group_id:,
         include_db_branch_lease:,
-        dataset_id:
+        dataset_id:,
+        grader_ids:
       )
       test_run_id = replay_data["testRunId"]
       test_run_url = replay_data["testRunUrl"]
@@ -290,6 +310,177 @@ module Bitfab
       result
     end
 
+    # Read the code-change payload the replay wrapper captured and pointed us at
+    # via BITFAB_CODE_CHANGE_PATH. Returns [description, files] or nil.
+    # Best-effort: any error (no env var, missing file, bad JSON) yields nil so
+    # the replay proceeds with no code change rather than raising.
+    TRUNK_CANDIDATES = ["origin/HEAD", "origin/main", "origin/master", "main", "master"].freeze
+    CC_MAX_FILES = 60
+    CC_MAX_FILE_BYTES = 500_000
+    CC_MAX_TOTAL_BYTES = 2_000_000
+
+    # Auto-capture the code change to attach when the caller passed none. Lives
+    # in replay() (the one call guaranteed to run on every replay) so it works no
+    # matter how the replay was launched. Precedence: a BITFAB_CODE_CHANGE_PATH
+    # override, else the git diff vs trunk. Best-effort: any failure yields nil.
+    # An explicit code_change_files always wins over this.
+    def resolve_auto_code_change(label = nil)
+      return nil if ENV["BITFAB_DISABLE_CODE_CHANGE_CAPTURE"]
+
+      from_env = read_code_change_file
+      return from_env unless from_env.nil?
+
+      capture_code_change_from_git(Dir.pwd, label)
+    end
+
+    def read_code_change_file
+      path = ENV["BITFAB_CODE_CHANGE_PATH"]
+      return nil if path.nil? || path.empty?
+
+      begin
+        parsed = JSON.parse(File.read(path))
+        files = parsed["files"]
+        # A malformed payload (non-array, or entries that aren't hashes) must
+        # yield no code change, never crash normalize_code_change_files.
+        files = nil unless files.is_a?(Array) && files.all?(Hash)
+        description = parsed["description"]
+        description = nil unless description.is_a?(String)
+        return nil if files.nil? && description.nil?
+
+        [description, files]
+      rescue
+        nil
+      end
+    end
+
+    def git(cwd, args)
+      # capture3 so git's stderr (e.g. "not a git repository") is swallowed, not
+      # leaked to the host process's console.
+      out, _err, status = Timeout.timeout(30) do
+        Open3.capture3("git", *args, chdir: cwd)
+      end
+      return nil unless status.success?
+
+      # Tag as UTF-8 and scrub invalid bytes so blob contents compare cleanly
+      # against the UTF-8 working-file reads and never break JSON.generate later
+      # (a non-UTF-8 file that slips past the null-byte check would otherwise
+      # abort the whole start-replay request).
+      out.force_encoding("UTF-8").scrub
+    rescue
+      nil
+    end
+
+    def cc_ref_exists?(root, ref)
+      !git(root, ["rev-parse", "--verify", "#{ref}^{object}"]).nil?
+    end
+
+    # Returns [base, from_trunk]; from_trunk is false on the HEAD fallback.
+    def cc_resolve_base(root)
+      forced = ENV["BITFAB_CODE_CHANGE_BASE"]
+      if forced && cc_ref_exists?(root, forced)
+        mb = git(root, ["merge-base", "HEAD", forced])
+        return [mb.strip, true] if mb && !mb.strip.empty?
+
+        rp = git(root, ["rev-parse", "--verify", forced])
+        return (rp && !rp.strip.empty?) ? [rp.strip, true] : nil
+      end
+      TRUNK_CANDIDATES.each do |candidate|
+        next unless cc_ref_exists?(root, candidate)
+
+        mb = git(root, ["merge-base", "HEAD", candidate])
+        return [mb.strip, true] if mb && !mb.strip.empty?
+      end
+      cc_ref_exists?(root, "HEAD") ? ["HEAD", false] : nil
+    end
+
+    def cc_blob_bytes(root, base, path)
+      out = git(root, ["cat-file", "-s", "#{base}:#{path}"])
+      (out && !out.strip.empty?) ? out.strip.to_i : 0
+    rescue
+      0
+    end
+
+    def cc_working_bytes(root, path)
+      File.size(File.join(root, path))
+    rescue
+      0
+    end
+
+    def capture_code_change_from_git(cwd, label = nil)
+      root = git(cwd, ["rev-parse", "--show-toplevel"])
+      return nil if root.nil? || root.strip.empty?
+
+      root = root.strip
+      resolved = cc_resolve_base(root)
+      return nil if resolved.nil?
+
+      base, from_trunk = resolved
+
+      tracked = git(root, ["diff", "--name-status", "--no-renames", "-z", base, "--", ":!.bitfab"]) || ""
+      untracked = git(root, ["ls-files", "--others", "--exclude-standard", "-z", "--", ":!.bitfab"]) || ""
+
+      entries = cc_parse_name_status_z(tracked)
+      untracked.split("\0").reject(&:empty?).each { |p| entries << ["A", p] }
+      return nil if entries.empty?
+
+      files = []
+      total = 0
+      entries.each do |status, path|
+        break if files.length >= CC_MAX_FILES
+
+        # Skip oversized files by size BEFORE reading their full contents, so a
+        # huge changed file can't OOM/stall replay just to be discarded.
+        before_bytes = (status == "A") ? 0 : cc_blob_bytes(root, base, path)
+        after_bytes = (status == "D") ? 0 : cc_working_bytes(root, path)
+        next if before_bytes > CC_MAX_FILE_BYTES || after_bytes > CC_MAX_FILE_BYTES
+
+        # Normalize CRLF -> LF on both sides: git's blob is already LF-normalized
+        # (autocrlf clean), so a raw CRLF working file would otherwise skew every
+        # line as changed. Comparing/storing LF keeps the diff meaningful.
+        before = (status == "A") ? "" : (git(root, ["show", "#{base}:#{path}"]) || "").gsub("\r\n", "\n")
+        after = (status == "D") ? "" : cc_read_working_file(root, path).gsub("\r\n", "\n")
+        next if before == after
+
+        size = before.bytesize + after.bytesize
+        next if total + size > CC_MAX_TOTAL_BYTES ||
+          cc_looks_binary?(before) || cc_looks_binary?(after)
+
+        total += size
+        files << {"path" => path, "before" => before, "after" => after}
+      end
+      return nil if files.empty?
+
+      subject = git(root, ["log", "-1", "--format=%s", "HEAD"])
+      subject = subject ? subject.strip : ""
+      head = ((label && !label.strip.empty?) ? label.strip : nil) || (subject.empty? ? nil : subject) || "Working-tree change"
+      word = (files.length == 1) ? "file" : "files"
+      against = from_trunk ? "vs trunk" : "uncommitted (vs HEAD)"
+      ["#{head} (#{files.length} #{word} changed #{against})", files]
+    rescue
+      nil
+    end
+
+    def cc_parse_name_status_z(raw)
+      parts = raw.split("\0").reject(&:empty?)
+      out = []
+      i = 0
+      while i + 1 < parts.length
+        out << [parts[i][0], parts[i + 1]]
+        i += 2
+      end
+      out
+    end
+
+    def cc_read_working_file(root, path)
+      File.read(File.join(root, path), encoding: "UTF-8")
+    rescue
+      ""
+    end
+
+    def cc_looks_binary?(str)
+      str[0, 8000].include?("\0")
+    end
+
     def write_replay_result_file(result)
       result_path = ENV["BITFAB_REPLAY_RESULT_PATH"]
       return if result_path.nil? || result_path.empty?

data/lib/bitfab/version.rb

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

metadata

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