bitfab 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1711bd0806a246ec36f15e2bedd0b31d8fe8c9df0aacc922d7ad15a20badf629
-  data.tar.gz: 2e619cf976e2909bdf1bf629cb350e6b761115d4ec9d8372beaacfe5b46adbbf
+  metadata.gz: 8d85c35718e6138d5095d4d20278fdac5f3c6f31858684622cb3a68bad6b5416
+  data.tar.gz: 1de8519b600a8ea4a29593a82f938669d8aa9e9ec616c95102c0abe6d06045c6
 SHA512:
-  metadata.gz: 88d118025460c8aed53e48d4ca16815133c67aa04986688bf1ed84ed506a16c41f11e76fd012cb9c18f6ee06a44f1b42e7de811e78834da737b9e4b260d5a024
-  data.tar.gz: 6c0e746e23dfdf5995c502e3a40cc12c03888c5e783b924049d2cd4152660c8a226b9ce852532440687630449fe84f027a75082602f175619fbe28e38121e9ba
+  metadata.gz: 0c6d45ca5bbaedfd2a162e2d05c4bef6da21b31c482db91d5539fb46b79be936aa4600e2ea5d0875ecf0e608907ee92a028660edbcd08dc367ce942003658538
+  data.tar.gz: db3e762b1ce6b7cb60f4996f4642d6e2a3d5e6a7e6b886a14c319b98ae198f0f210e7af857fda35c53d4e2a49339283ae929f6338d1bae3f64f9be6b97023acc

data/lib/bitfab/client.rb

@@ -114,12 +114,12 @@ module Bitfab
     # @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, grader_ids: nil, mock: "marked",
-      adapt_inputs: nil, mock_override: nil, environment: nil, on_progress: nil)
+      adapt_inputs: nil, mock_override: nil, environment: nil, db_branch: 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:, grader_ids:, mock:, adapt_inputs:,
-        mock_override:, environment:,
+        mock_override:, environment:, db_branch:,
         on_progress:
       )
     end

data/lib/bitfab/http_client.rb

@@ -118,7 +118,7 @@ module Bitfab
     #   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,
-      grader_ids: nil)
+      grader_ids: nil, db_branch_settings: nil)
       payload = {
         "traceFunctionKey" => trace_function_key
       }
@@ -133,6 +133,7 @@ module Bitfab
       payload["includeDbBranchLease"] = true if include_db_branch_lease
       payload["datasetId"] = dataset_id unless dataset_id.nil?
       payload["graderIds"] = grader_ids unless grader_ids.nil?
+      payload["dbBranchSettings"] = db_branch_settings unless db_branch_settings.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"
@@ -134,7 +136,7 @@ module Bitfab
     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, grader_ids: nil, mock: "marked",
-      adapt_inputs: nil, mock_override: nil, environment: nil, on_progress: nil)
+      adapt_inputs: nil, mock_override: nil, environment: nil, db_branch: nil, on_progress: nil)
       unless MOCK_STRATEGIES.include?(mock.to_s)
         raise ArgumentError, "Invalid mock strategy '#{mock}'. Must be one of: #{MOCK_STRATEGIES.join(", ")}"
       end
@@ -179,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,
@@ -189,7 +204,8 @@ module Bitfab
         experiment_group_id:,
         include_db_branch_lease:,
         dataset_id:,
-        grader_ids:
+        grader_ids:,
+        db_branch_settings: db_branch_settings(db_branch)
       )
       test_run_id = replay_data["testRunId"]
       test_run_url = replay_data["testRunUrl"]
@@ -295,6 +311,202 @@ 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
+
+    # Convert the caller's +db_branch+ options to the wire shape, or nil when
+    # nothing was set. Dropping the key entirely keeps the request identical to
+    # what older SDKs send.
+    #
+    # Keys: :min_cu and :max_cu are the branch compute's autoscaling floor and
+    # ceiling in Neon Compute Units (equal values pin the size, keeping items
+    # comparable); :warmup_sql is appended to the branch's readiness check so it
+    # warms the cache before the replayed function sees the lease.
+    def db_branch_settings(db_branch)
+      return nil if db_branch.nil? || db_branch.empty?
+
+      # Symbol or string keys, matching normalize_code_change_files: a hash
+      # loaded from JSON or YAML would otherwise be read as empty, leaving the
+      # branch on the mirror's defaults with no error to notice.
+      min_cu = db_branch[:min_cu] || db_branch["min_cu"]
+      max_cu = db_branch[:max_cu] || db_branch["max_cu"]
+      warmup_sql = db_branch[:warmup_sql] || db_branch["warmup_sql"]
+
+      settings = {}
+      settings["minCu"] = min_cu unless min_cu.nil?
+      settings["maxCu"] = max_cu unless max_cu.nil?
+      settings["warmupSql"] = warmup_sql unless warmup_sql.nil?
+      settings.empty? ? nil : settings
+    end
+
+    # 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?
@@ -413,9 +625,19 @@ module Bitfab
       # (only when include_db_branch_lease was sent). Release it in the +ensure+
       # below so any raise (span fetch, mock-tree build, or the replayed
       # method) frees the Neon resource. Items whose source trace had no
-      # snapshot ref, or whose resolve failed server-side, arrive without a
-      # lease (env.active? is false for those).
+      # snapshot ref arrive without a lease (env.active? is false), and
+      # replaying those against the live database is correct.
       lease = include_db_branch_lease ? server_item["dbBranchLease"] : nil
+      # A resolve that was ATTEMPTED and failed is different: the caller asked
+      # for a branch, so running their method against live data would produce a
+      # result that looks valid and is not. Fail the item instead, loudly.
+      lease_error = include_db_branch_lease ? server_item["dbBranchLeaseError"] : nil
+      if lease_error
+        raise "Replay requested a database branch for trace #{original_trace_id} but it " \
+          "could not be resolved (#{lease_error["code"]}): #{lease_error["message"]}. " \
+          "The method was not run, because replaying it against the live database would " \
+          "produce a result that looks valid but did not use the historical data you asked for."
+      end
 
       span = http_client.get_external_span(original_span_id)
       item_data = extract_span_data(span)

data/lib/bitfab/replay_environment.rb

@@ -44,6 +44,13 @@ module Bitfab
       require_snapshot[:read_only]
     end
 
+    # The branch's region, e.g. "aws-us-east-1". A compute runs in its
+    # project's region, so a replay runner elsewhere pays that round trip on
+    # every query.
+    def region
+      require_snapshot[:region]
+    end
+
     # The historical trace ID that produced the input for this replay item.
     def trace_id
       require_snapshot.fetch(:trace_id)
@@ -95,6 +102,7 @@ module Bitfab
         expires_at: lease["expiresAt"],
         provider_console_url: lease["providerConsoleUrl"],
         read_only: lease["readOnly"],
+        region: lease["region"],
         trace_id:
       }
     end

data/lib/bitfab/version.rb

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

metadata

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