bitfab 0.65.4 → 0.65.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd7bdd7dbd520e06041d5250b0b291f90b3a22d0b92ed6c43bc29b2d869f6135
-  data.tar.gz: b2a722780ca027f97c46433e6b2bba6db6223bc70122dba24e141a5b868a3c81
+  metadata.gz: 614f7adf31df970f2961c5ce1bd647d0e875e7e0324e3cad4279846b6a0a2393
+  data.tar.gz: 9dff87903a5c97d9cf0ea9cc705840b6015c21ee0a03d2f89943a76e694d4226
 SHA512:
-  metadata.gz: f79740fe5b1fcae3ffb8d5926b4ecb7852988dcd36671c8b18486480b1de8b818c96f36621b2606dfc2c057b12dd7718fdaf5efa026b2102dac4cd92c9dd3e4e
-  data.tar.gz: 6e71b00586519e4edf32ee3b8c984adfcf3fa39e77b23a1dc79c6890419a3d0dda12dd9bce72bac02645fe3281e618b38d7960a9e531e09b54305f1dea9e5ed9
+  metadata.gz: a49875ee7ef5769bd78e1a6faf8095fc25c67aa2edb54dfc945c33dc26788881182204ccc21f9799c060fbba3c6f582293863f459beb3a0eab476fde47ee7979
+  data.tar.gz: f78dc742e2b597b173a7270d9c49486bbccff14f1439e54f6d9406b67c78fcf88838125ce8d480065f54ccf9d5783381455204ef96b50ab1bc5ffdaf38d39580

data/lib/bitfab/client.rb

@@ -58,7 +58,8 @@ module Bitfab
       @resolved_api_key = nil
       @api_key_warned = false
       @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?)
+      @http_client.configure_simulation_plan(enabled: simulation_plan, start: !api_key_resolved_lazily?,
+        can_read: -> { simulation_plan_readable? })
       @datasets = Datasets.new(@http_client)
       @categories = Categories.new(@http_client)
       @organization_members = OrganizationMembers.new(@http_client)
@@ -853,6 +854,13 @@ module Bitfab
       !resolve_api_key.nil?
     end
 
+    def simulation_plan_readable?
+      recording = capture_configured? || ReplayContext.current || SeedContext.current
+      recording && !lookup_api_key.nil?
+    rescue
+      false
+    end
+
     def tracing_enabled?
       return false unless capture_configured?
 

data/lib/bitfab/cloudReplay.py

@@ -154,6 +154,7 @@ CODE_CHANGE_PATH_ENV = "BITFAB_CODE_CHANGE_PATH"
 CODE_CHANGE_MAX_FILES = 60
 CODE_CHANGE_MAX_FILE_BYTES = 500_000
 CODE_CHANGE_MAX_TOTAL_BYTES = 2_000_000
+BRANCH_WALK_LIMIT = 1000
 CHECK_ARGUMENTS_SECONDS = 300
 CHECK_ARGUMENTS_FLAG = "--check-arguments"
 REPLAY_ARGUMENTS_FLAG = "--replay-arguments"
@@ -933,6 +934,98 @@ def current_branch(root):
         return None
 
 
+def quiet_git(root, *args):
+    try:
+        return git(root, *args)
+    except CommandError:
+        return ""
+
+
+def default_branch(root):
+    origin_head = quiet_git(root, "rev-parse", "--abbrev-ref", "origin/HEAD")
+    candidates = [
+        origin_head if origin_head and origin_head != "origin/HEAD" else None,
+        "origin/main",
+        "origin/master",
+        "main",
+        "master",
+    ]
+    return next(
+        (
+            ref
+            for ref in dict.fromkeys(filter(None, candidates))
+            if quiet_git(root, "rev-parse", "--verify", "-q", f"{ref}^{{commit}}")
+        ),
+        None,
+    )
+
+
+def current_branch_refs(root):
+    branch = current_branch(root)
+    if not branch:
+        return set()
+    return {f"refs/heads/{branch}"} | {
+        f"refs/remotes/{remote}/{branch}"
+        for remote in quiet_git(root, "remote").split()
+    }
+
+
+def own_branch_refs(root):
+    upstream = quiet_git(root, "rev-parse", "--symbolic-full-name", "@{upstream}")
+    own = current_branch_refs(root)
+    if upstream:
+        own.add(upstream)
+    return own
+
+
+def on_default_branch(root, default):
+    full_name = quiet_git(root, "rev-parse", "--symbolic-full-name", default)
+    return bool(full_name) and full_name in current_branch_refs(root)
+
+
+def branch_tips(root):
+    own = own_branch_refs(root)
+    listing = quiet_git(
+        root,
+        "for-each-ref",
+        "--format=%(objectname) %(refname)",
+        "refs/heads",
+        "refs/remotes",
+    )
+    tips = {}
+    for line in listing.splitlines():
+        sha, _, ref = line.partition(" ")
+        if ref and ref not in own and not ref.endswith("/HEAD"):
+            tips.setdefault(
+                sha, ref.removeprefix("refs/heads/").removeprefix("refs/remotes/")
+            )
+    return tips
+
+
+def branch_point(root):
+    head = quiet_git(root, "rev-parse", "HEAD")
+    if not head:
+        return None
+    default = default_branch(root)
+    if default and on_default_branch(root, default):
+        return None
+    default_base = quiet_git(root, "merge-base", "HEAD", default) if default else ""
+    walk = ["rev-list", "--first-parent", f"--max-count={BRANCH_WALK_LIMIT}", "HEAD"]
+    if default_base:
+        walk.append(f"^{default_base}")
+    tips = branch_tips(root)
+    for sha in quiet_git(root, *walk).split()[1:]:
+        if sha in tips:
+            return {"sha": sha, "ref": tips[sha]}
+    if default_base and default_base != head:
+        return {"sha": default_base, "ref": default}
+    return None
+
+
+def replay_artifact(path):
+    return path == ".bitfab" or path.startswith(".bitfab/")
+
+
 def sensitive(path):
     parts = Path(path).parts
     name = Path(path).name.lower()
@@ -1033,12 +1126,20 @@ def snapshot(
         }
         if preview:
             return summary
+        code_change_base = request.get("codeChangeBase") or {}
+        extra_parent = (
+            ["-p", code_change_base["sha"]]
+            if not any(not replay_artifact(path) for _, path in changes)
+            and SHA.fullmatch(str(code_change_base.get("sha", "")))
+            else []
+        )
         sha = git(
             root,
             "commit-tree",
             tree,
             "-p",
             head,
+            *extra_parent,
             input=f"{snapshot_subject(request['id'], on_push)}\n\n{json.dumps(request)}\n",
         )
         return {**summary, "sha": sha}
@@ -1360,6 +1461,9 @@ def submit(root, repo, workflow, parsed, path):
     branch = current_branch(root)
     if branch:
         request["branch"] = branch
+    code_change_base = branch_point(root)
+    if code_change_base:
+        request["codeChangeBase"] = code_change_base
     check_arguments(parsed["replay"])
     allowed = allowed_files(root, parsed)
     if "--cloud-preview" in parsed["switches"]:
@@ -2067,7 +2171,9 @@ def changed_paths(root, base, commit):
         yield status, before_path, path
 
 
-def snapshot_code_change(root, base, commit, name):
+def snapshot_code_change(
+    root, base, commit, name, against="uncommitted (vs HEAD)", subject_ref=None
+):
     files, total = [], 0
     for status, before_path, path in changed_paths(root, base, commit):
         if len(files) >= CODE_CHANGE_MAX_FILES:
@@ -2083,14 +2189,34 @@ def snapshot_code_change(root, base, commit, name):
         files.append({"path": path, "before": before, "after": after})
     if not files:
         return None
-    head = (name or "").strip() or git(root, "log", "-1", "--format=%s", base)
+    head = (name or "").strip() or git(
+        root, "log", "-1", "--format=%s", subject_ref or base
+    )
     word = "file" if len(files) == 1 else "files"
     return {
-        "description": f"{head or 'Working-tree change'} ({len(files)} {word} changed uncommitted (vs HEAD))",
+        "description": f"{head or 'Working-tree change'} ({len(files)} {word} changed {against})",
         "files": files,
     }
 
 
+def branch_code_change(root, base, commit, request):
+    code_change_base = request.get("codeChangeBase")
+    if not isinstance(code_change_base, dict):
+        return None
+    sha, ref = code_change_base.get("sha"), code_change_base.get("ref")
+    if not (
+        isinstance(sha, str)
+        and SHA.fullmatch(sha)
+        and isinstance(ref, str)
+        and BRANCH_NAME.fullmatch(ref)
+        and quiet_git(root, "rev-parse", "--verify", "-q", f"{commit}^2") == sha
+    ):
+        return None
+    return snapshot_code_change(
+        root, sha, commit, replay_name(request["args"]), f"vs {ref}", base
+    )
+
+
 def write_code_change(change):
     handle, path = tempfile.mkstemp(
         prefix="bitfab-code-change-",
@@ -2127,6 +2253,7 @@ def execute():
         None
         if explicit_change or base is None
         else snapshot_code_change(root, base, commit, replay_name(request["args"]))
+        or branch_code_change(root, base, commit, request)
     )
     run_environment = dict(environment)
     if change:

data/lib/bitfab/http_client.rb

@@ -56,8 +56,8 @@ module Bitfab
       @close_condition = ConditionVariable.new
     end
 
-    def configure_simulation_plan(enabled: true, start: true)
-      @simulation_plan = SimulationPlan.new(self, enabled:)
+    def configure_simulation_plan(enabled: true, start: true, can_read: nil)
+      @simulation_plan = SimulationPlan.new(self, enabled:, can_read:)
       @simulation_plan.refresh if start
       @simulation_plan
     end

data/lib/bitfab/replay.rb

@@ -598,6 +598,7 @@ module Bitfab
     CC_MAX_FILES = 60
     CC_MAX_FILE_BYTES = 500_000
     CC_MAX_TOTAL_BYTES = 2_000_000
+    CC_MAX_BRANCH_WALK = 1000
 
     def resolve_skip_assertion_judging(skip_assertion_judging, judge_assertions)
       return skip_assertion_judging if judge_assertions.nil?
@@ -658,7 +659,9 @@ module Bitfab
     # 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 of the working tree vs HEAD (or vs the
-    # merge-base with BITFAB_CODE_CHANGE_BASE). Best-effort: any failure yields nil.
+    # merge-base with BITFAB_CODE_CHANGE_BASE). A clean working tree falls back to
+    # the point where HEAD split from the default branch, so committed branch work
+    # still shows. 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"]
@@ -711,6 +714,73 @@ module Bitfab
       cc_ref_exists?(root, "HEAD") ? ["HEAD", "uncommitted (vs HEAD)"] : nil
     end
 
+    def cc_list_changes(root, base)
+      tracked = git(root, ["diff", "--name-status", "--find-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, p] }
+      entries
+    end
+
+    def cc_default_branch_candidates(root)
+      origin_head = (git(root, ["rev-parse", "--abbrev-ref", "origin/HEAD"]) || "").strip
+      origin_head = nil if origin_head.empty? || origin_head == "origin/HEAD"
+      [origin_head, "origin/main", "origin/master", "main", "master"].compact.uniq
+    end
+
+    def cc_default_branch(root)
+      cc_default_branch_candidates(root).find { |ref| cc_ref_exists?(root, ref) }
+    end
+
+    def cc_current_branch_refs(root)
+      branch = (git(root, ["symbolic-ref", "--short", "-q", "HEAD"]) || "").strip
+      return [] if branch.empty?
+
+      ["refs/heads/#{branch}"] + (git(root, ["remote"]) || "").split.map { |remote| "refs/remotes/#{remote}/#{branch}" }
+    end
+
+    def cc_own_branch_refs(root)
+      upstream = (git(root, ["rev-parse", "--symbolic-full-name", "@{upstream}"]) || "").strip
+      own = cc_current_branch_refs(root)
+      own << upstream unless upstream.empty?
+      own
+    end
+
+    def cc_on_default_branch?(root, default)
+      full_name = (git(root, ["rev-parse", "--symbolic-full-name", default]) || "").strip
+      !full_name.empty? && cc_current_branch_refs(root).include?(full_name)
+    end
+
+    def cc_branch_tips(root)
+      own = cc_own_branch_refs(root)
+      listing = git(root, ["for-each-ref", "--format=%(objectname) %(refname)", "refs/heads", "refs/remotes"]) || ""
+      listing.each_line.with_object({}) do |line, tips|
+        sha, ref = line.strip.split(" ", 2)
+        next if ref.nil? || own.include?(ref) || ref.end_with?("/HEAD") || tips.key?(sha)
+
+        tips[sha] = ref.sub(%r{\Arefs/(heads|remotes)/}, "")
+      end
+    end
+
+    def cc_resolve_branch_point(root)
+      head = (git(root, ["rev-parse", "HEAD"]) || "").strip
+      return nil if head.empty?
+
+      default = cc_default_branch(root)
+      return nil if default && cc_on_default_branch?(root, default)
+
+      default_base = default ? (git(root, ["merge-base", "HEAD", default]) || "").strip : ""
+      walk = ["rev-list", "--first-parent", "--max-count=#{CC_MAX_BRANCH_WALK}", "HEAD"]
+      walk << "^#{default_base}" unless default_base.empty?
+      tips = cc_branch_tips(root)
+      (git(root, walk) || "").split.drop(1).each do |sha|
+        return [sha, "vs #{tips[sha]}"] if tips.key?(sha)
+      end
+      return [default_base, "vs #{default}"] unless default_base.empty? || default_base == head
+
+      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
@@ -732,15 +802,18 @@ module Bitfab
       resolved = cc_resolve_base(root)
       return nil if resolved.nil?
 
-      base, against = resolved
-
-      tracked = git(root, ["diff", "--name-status", "--find-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, p] }
+      entries = cc_list_changes(root, resolved[0])
+      if entries.empty? && resolved[0] == "HEAD"
+        branch_point = cc_resolve_branch_point(root)
+        if branch_point
+          resolved = branch_point
+          entries = cc_list_changes(root, branch_point[0])
+        end
+      end
       return nil if entries.empty?
 
+      base, against = resolved
+
       files = []
       total = 0
       entries.each do |status, before_path, path|

data/lib/bitfab/simulation_plan.rb

@@ -42,9 +42,10 @@ module Bitfab
       end
     end
 
-    def initialize(reader, enabled: true)
+    def initialize(reader, enabled: true, can_read: nil)
       @reader = reader
       @enabled = enabled
+      @can_read = can_read
       @pid = Process.pid
       @mutex = Mutex.new
       @condition = ConditionVariable.new
@@ -56,25 +57,26 @@ module Bitfab
       @stopped = false
       @first_read_finished = false
       @first_read_deadline = nil
+      @read_started = false
       self.class.register(self)
     end
 
     def disabled?
-      !@enabled || !ENV.fetch("BITFAB_DISABLE_SIM_PLAN", "").strip.empty?
+      switched_off? || (!@read_started && !readable?)
     end
 
     def refresh
       reset_after_fork
-      return if disabled? || @stopped
+      return if disabled?
 
-      @mutex.synchronize { start_reader(0) if @thread.nil? && now >= @refresh_after }
+      refresh_for_record
     end
 
     def send_span(payload, declared_node: false, discard: nil, &submit)
-      refresh
+      refresh_for_record
       data = payload.dig("rawSpan", "span_data")
       key = payload["rootTraceFunctionKey"] || payload["traceFunctionKey"]
-      if disabled? || key.nil? || !data.is_a?(Hash) || framework?(payload)
+      if switched_off? || key.nil? || !data.is_a?(Hash) || framework?(payload)
         submit.call(payload)
         return
       end
@@ -84,11 +86,11 @@ module Bitfab
     end
 
     def send_trace(payload, &submit)
-      refresh
+      refresh_for_record
       entry = [payload, nil, submit]
       ready = @mutex.synchronize do
         id = trace_id(payload)
-        if !disabled? && !@stopped && id && (@draining.include?(id) || @held.any? { |held| held[1] && trace_id(held[0]) == id })
+        if !switched_off? && !@stopped && id && (@draining.include?(id) || @held.any? { |held| held[1] && trace_id(held[0]) == id })
           hold(entry)
         else
           entry
@@ -172,6 +174,21 @@ module Bitfab
 
     private
 
+    def refresh_for_record
+      reset_after_fork
+      return if switched_off? || @stopped
+
+      @mutex.synchronize { start_reader(0) if @thread.nil? && now >= @refresh_after }
+    end
+
+    def switched_off?
+      !@enabled || !ENV.fetch("BITFAB_DISABLE_SIM_PLAN", "").strip.empty?
+    end
+
+    def readable?
+      @can_read.nil? || @can_read.call == true
+    end
+
     def now
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
@@ -194,7 +211,7 @@ module Bitfab
 
     def hold(entry)
       @held << entry
-      start_reader([@refresh_after - now, 0].max) if @thread.nil? && !@stopped && !disabled?
+      start_reader([@refresh_after - now, 0].max) if @thread.nil? && !@stopped && !switched_off?
       @held.shift if @held.length > MAX_HELD
     end
 
@@ -210,7 +227,7 @@ module Bitfab
     end
 
     def prepare(payload, key)
-      return payload if key.nil? || disabled?
+      return payload if key.nil? || switched_off?
       return apply(payload, key) if @mutex.synchronize { @content_off }
 
       without_unread_content(payload)
@@ -232,6 +249,7 @@ module Bitfab
     end
 
     def start_reader(delay)
+      @read_started = true
       @first_read_deadline ||= now + delay + READ_TIMEOUT
       @thread = Thread.new { read_until_loaded(delay) }
       @thread.name = "bitfab-sim-plan"
@@ -270,7 +288,7 @@ module Bitfab
 
     def read_until_loaded(delay)
       pause(delay) if delay.positive?
-      parsed = (disabled? || @stopped) ? nil : read_once
+      parsed = (switched_off? || @stopped) ? nil : read_once
       entries = @mutex.synchronize do
         @first_read_finished = true
         @content_off = parsed if parsed

data/lib/bitfab/version.rb

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

metadata

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