bitfab 0.64.5 → 0.64.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e630103d5c0c6c7a464df1503c3d925fc6959447cc32af5322419958cec8a952
-  data.tar.gz: 5a9577edbb17bc4a875d09296565f7d56d9f22ece2fddb6bd0045c87941510a4
+  metadata.gz: 1f867438c2e7008a72787a1bf61ad853c22964587223e98b73827dfbc0546675
+  data.tar.gz: 87130f50d01f7150a5fca9134c5aa444ad31884efbed998aeb3e575d4759d3c4
 SHA512:
-  metadata.gz: 674ddbab994afb29575d5595e07740e2093225fa0b720f2c7d2234fa3194047cf648cbd39e215474ff53a3c5ad7bf3e77e1b2e53e2977936268c1199a9ec50c1
-  data.tar.gz: 357a5c6a4ff73e20380887baeab80d7cb14c1cb6bc25904349140f0e4d2197a1fd8e1437368bdf4c67754365b1d5bb14fcf559e97de2daae2a5896d868c77340
+  metadata.gz: 71bf77c48e836cf432734391762cd0fcfa3f0f38efa7451919dc982a00b8d8f2332b34e5b08d980d044d778f8db2fc8ddacf2f88f754d061637b51452fe56e49
+  data.tar.gz: 364a28104d7c944b78bae89c93dacf459240cb877197ff9c4fca25f8d98cac82ddc9b8c418e9e208d6d0152e093789665fff7eba6ee177e8ab132c757ec3f8c8

data/lib/bitfab/cloudReplay.py

@@ -33,6 +33,8 @@ API_VERSION = "2026-03-10"
 REPLAY_COMMAND_ENV = "BITFAB_REPLAY_COMMAND"
 SDK_LANGUAGE_ENV = "BITFAB_SDK_LANGUAGE"
 CHECK_COMMAND_ENV = "BITFAB_REPLAY_CHECK"
+EXECUTION_TARGET_ENV = "BITFAB_REPLAY_EXECUTION_TARGET"
+HOSTED_EXECUTION_TARGET = "hosted"
 REQUEST_VERSION = 3
 OLDEST_DISPATCHED_VERSION = 2
 RESULT_LINE = "bitfab-replay-result "
@@ -169,6 +171,9 @@ fullOutput (true) match --cloud-timeout and --cloud-full-output. version and id
 optional: version names the request format (3 now, 2 still accepted), and id is the
 execution UUID, which must match an execution_id input when the workflow has one.
 
+The runner's job exits with the replay's exit code, so the Actions run fails when
+the replay does. Traces that errored fail it only under --fail-on-error.
+
 Follow a replay by the execution UUID it prints:
   --cloud-watch ID | --cloud-status ID | --cloud-cancel ID | --cloud-cleanup ID
 
@@ -1727,12 +1732,18 @@ def annotate(result):
     if result.get("stoppedEarly"):
         message = f"Replay stopped early: {result['stoppedEarly']}"
     elif result["exitCode"]:
-        message = f"Replay exited {result['exitCode']}; bitfab-replay --cloud reports it as its own exit code"
+        message = f"Replay exited {result['exitCode']}, so this job exits with it too"
     else:
         return
     print(f"::warning title=Bitfab replay::{message}", flush=True)
 
 
+def runner_exit_code(result):
+    if result.get("stoppedEarly"):
+        return result["exitCode"] or 1
+    return result["exitCode"]
+
+
 def summary_markdown(result):
     summary = result_summary(result["stdout"]) or {}
     counts = summary.get("counts", {})
@@ -1767,6 +1778,7 @@ def run_command(directory, args, timeout, experiment, *, summarize=True):
         with subprocess.Popen(
             args,
             cwd=directory,
+            env={**os.environ, EXECUTION_TARGET_ENV: HOSTED_EXECUTION_TARGET},
             stdout=output,
             stderr=subprocess.PIPE,
             stdin=subprocess.DEVNULL,
@@ -2200,8 +2212,9 @@ def main():
             print_json(configure_secrets(argv[1:]))
             return 0
         if argv == ["--cloud-execute"]:
-            annotate(execute())
-            return 0
+            result = execute()
+            annotate(result)
+            return runner_exit_code(result)
         if "-h" in argv or "--help" in argv:
             print(HELP, end="")
             return 0

data/lib/bitfab/http_client.rb

@@ -5,6 +5,7 @@ require "json"
 require "uri"
 
 require_relative "git_state"
+require_relative "replay_invocation"
 require_relative "compress"
 require_relative "connection_pool"
 require_relative "constants"
@@ -262,7 +263,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, notes: nil, metadata: nil, include_db_branch_lease: false, dataset_ids: nil,
-      grader_ids: nil, db_branch_settings: nil, attempts: 1, only_with_assertions: false, skip_assertion_judging: false, include_original_metadata: false, experimental_selective_replay: nil, dry_run: false)
+      grader_ids: nil, db_branch_settings: nil, attempts: 1, only_with_assertions: false, skip_assertion_judging: false, include_original_metadata: false, experimental_selective_replay: nil, dry_run: false, invocation: nil)
       payload = {
         "traceFunctionKey" => trace_function_key
       }
@@ -293,6 +294,7 @@ module Bitfab
       payload["includeOriginalMetadata"] = true if include_original_metadata
       payload["experimentalSelectiveReplay"] = experimental_selective_replay if experimental_selective_replay
       payload["dbBranchSettings"] = db_branch_settings unless db_branch_settings.nil?
+      payload["invocation"] = invocation unless invocation.nil?
       git_state = GitState.resolved
       payload["git"] = git_state if git_state
 

data/lib/bitfab/replay.rb

@@ -8,6 +8,7 @@ require "timeout"
 require_relative "constants"
 require_relative "git_command"
 require_relative "mock_override"
+require_relative "replay_invocation"
 require_relative "serialize"
 require_relative "selective_replay"
 require_relative "traceable"
@@ -142,6 +143,8 @@ module Bitfab
   # Replay historical traces through a traced method and create an experiment.
   module Replay
     CODE_CHANGE_UNSET = Object.new.freeze
+    UNSET_DEFAULT = Object.new.freeze
+    OPTION_DEFAULTS = {mock: "marked"}.freeze
     PERSISTENCE_TIMEOUT_SECONDS = 30.0
     PERSISTENCE_POLL_SECONDS = 0.1
     JUDGE_ASSERTIONS_DEPRECATION = "judge_assertions is deprecated. Assertion judging is on by default; " \
@@ -193,6 +196,13 @@ module Bitfab
       raise error, cause:
     end
 
+    def explicit_replay_options(options)
+      options.reject do |option, value|
+        value.nil? || value == false || value.equal?(ReplayConcurrency::UNSET) ||
+          value.equal?(CODE_CHANGE_UNSET) || value == OPTION_DEFAULTS.fetch(option, UNSET_DEFAULT)
+      end
+    end
+
     # Replay historical traces through a method and create an experiment.
     #
     # Fetches the last N traces for the given trace function key, re-runs each
@@ -289,6 +299,7 @@ module Bitfab
       dataset_id: nil, dataset_ids: nil, grader_ids: nil, mock: "marked", attempts: ReplayConcurrency::UNSET, only_with_assertions: false, skip_assertion_judging: false, judge_assertions: nil, dry_run: false,
       adapt_inputs: nil, mock_override: nil, db_branch: nil, on_item_start: nil, on_item_finish: nil, on_progress: nil,
       on_experiment_start: nil, experimental_selective_replay: nil)
+      explicit_options = method(:run).parameters.filter_map { |type, option| [option, binding.local_variable_get(option)] if type == :key }
       skip_assertion_judging = resolve_skip_assertion_judging(skip_assertion_judging, judge_assertions)
       concurrency_options = ReplayConcurrency.resolve(concurrency, attempts, max_concurrency)
       attempts = concurrency_options.attempts
@@ -396,6 +407,7 @@ module Bitfab
         include_original_metadata: !adapt_inputs.nil?,
         db_branch_settings: resolved_db_branch_settings,
         dry_run:,
+        invocation: ReplayInvocation.safe_build { ReplayInvocation.build(ReplayInvocation.current_cli_flags || ReplayInvocation.option_flag_entries(explicit_replay_options(explicit_options))) },
         **(experimental_selective_replay ? {experimental_selective_replay: SelectiveReplay.wire_options(experimental_selective_replay)} : {})
       )
       experiment_id = replay_data["experimentId"] || replay_data["testRunId"]

data/lib/bitfab/replay_invocation.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "version"
+
+module Bitfab
+  module ReplayInvocation
+    EXECUTION_TARGET_ENV = "BITFAB_REPLAY_EXECUTION_TARGET"
+    HOSTED_EXECUTION_TARGET = "hosted"
+    CI_ENV = "CI"
+    CI_TRUE_VALUES = %w[true 1].freeze
+    CI_PRESENCE_ENV_VARS = %w[GITHUB_ACTIONS GITLAB_CI CIRCLECI BUILDKITE JENKINS_URL TF_BUILD].freeze
+    MAX_FLAGS = 100
+    MAX_FLAG_NAME_LENGTH = 100
+    MAX_FLAG_STRING_LENGTH = 1_000
+    MAX_FLAG_LIST_LENGTH = 100
+    SECRET_FLAG_NAME = /key|token|secret|password/i
+    CLI_FLAGS_KEY = :bitfab_replay_cli_flags
+    UNSUPPORTED = Object.new.freeze
+    METADATA_FLAG = "metadata"
+    OPTION_FLAG_NAMES = {
+      max_concurrency: "concurrency",
+      dataset_id: "dataset-ids",
+      dataset_ids: "dataset-ids"
+    }.freeze
+
+    module_function
+
+    def environment
+      return "cloud_replay" if ENV[EXECUTION_TARGET_ENV] == HOSTED_EXECUTION_TARGET
+      return "ci" if CI_TRUE_VALUES.include?(ENV.fetch(CI_ENV, "").downcase)
+      return "ci" if CI_PRESENCE_ENV_VARS.any? { |name| !ENV.fetch(name, "").empty? }
+
+      "local"
+    end
+
+    def flag_scalar(value)
+      case value
+      when String then value[0, MAX_FLAG_STRING_LENGTH]
+      when true, false, nil then value
+      when Integer then value
+      when Float then value.finite? ? value : UNSUPPORTED
+      when Symbol then value.to_s[0, MAX_FLAG_STRING_LENGTH]
+      else UNSUPPORTED
+      end
+    end
+
+    def flag_value(value)
+      if value.is_a?(Array)
+        items = value.first(MAX_FLAG_LIST_LENGTH).map { |item| flag_scalar(item) }
+        return (items.any? { |item| item.equal?(UNSUPPORTED) }) ? true : items
+      end
+      scalar = flag_scalar(value)
+      scalar.equal?(UNSUPPORTED) || scalar
+    end
+
+    def option_flag_name(option)
+      OPTION_FLAG_NAMES.fetch(option.to_sym) { option.to_s.tr("_", "-") }
+    end
+
+    def option_flag_entries(options)
+      mapped, rest = options.to_a.partition { |option, _value| OPTION_FLAG_NAMES.key?(option.to_sym) }
+      (mapped + rest).map { |option, value| [option_flag_name(option), value] }
+    end
+
+    def metadata_keys(value)
+      keys = case value
+      when Hash then value.keys
+      when Array then value.map { |item| item.is_a?(Array) ? item.first : item.to_s.split("=", 2).first }
+      else return true
+      end
+      keys.map(&:to_s).uniq.sort
+    end
+
+    def flags(entries)
+      result = {}
+      entries.each do |name, value|
+        break if result.length >= MAX_FLAGS
+
+        name = name.to_s
+        next if name.empty? || result.key?(name) || name.length > MAX_FLAG_NAME_LENGTH || SECRET_FLAG_NAME.match?(name)
+
+        result[name] = flag_value((name == METADATA_FLAG) ? metadata_keys(value) : value)
+      end
+      result
+    end
+
+    def build(entries = {})
+      {
+        "flags" => flags(entries),
+        "sdk" => {"language" => "ruby", "version" => VERSION},
+        "environment" => environment
+      }
+    end
+
+    def safe_build
+      yield
+    rescue
+      nil
+    end
+
+    def current_cli_flags
+      Thread.current[CLI_FLAGS_KEY]
+    end
+
+    def with_cli_flags(cli_flags)
+      previous = Thread.current[CLI_FLAGS_KEY]
+      Thread.current[CLI_FLAGS_KEY] = cli_flags
+      yield
+    ensure
+      Thread.current[CLI_FLAGS_KEY] = previous
+    end
+  end
+end

data/lib/bitfab/replay_registry.rb

@@ -88,6 +88,7 @@ module Bitfab
   # Argument parsing and output for the SDK-owned replay command.
   module ReplayCli
     MAX_PINNED_TRACE_IDS = 100
+    CLI_INVOCATION_SKIPPED = %i[pipeline seed run from_trace].freeze
 
     class ItemsErroredError < StandardError; end
 
@@ -247,12 +248,14 @@ module Bitfab
         stderr.puts "[replay] Experiment #{experiment[:experiment_id]}: #{experiment[:experiment_url]}"
       end
       result = begin
-        registration.client.replay(
-          registration.receiver,
-          registration.method_name,
-          trace_function_key: registration.trace_function_key,
-          **options
-        )
+        ReplayInvocation.with_cli_flags(cli_invocation_flags(args)) do
+          registration.client.replay(
+            registration.receiver,
+            registration.method_name,
+            trace_function_key: registration.trace_function_key,
+            **options
+          )
+        end
       rescue ReplayError => error
         error.items.each do |item|
           item_error = item[:trace_error] || item[:replay_error] || item[:error]
@@ -273,6 +276,21 @@ module Bitfab
       result
     end
 
+    def cli_invocation_flags(args)
+      args.except(*CLI_INVOCATION_SKIPPED).each_with_object({}) do |(key, value), flags|
+        case key
+        when :param
+          flags["param"] = value.map { |raw| raw.split("=", 2).first }
+        when :max_concurrency
+          flags["concurrency"] = value
+        when :db_branch, :memory_throttle
+          flags["#{"no-" unless value}#{key.to_s.tr("_", "-")}"] = true
+        else
+          flags[key.to_s.tr("_", "-")] = value
+        end
+      end
+    end
+
     def fail_if_items_errored(result, dry_run:)
       items = result[:items].reject { |item| item[:carried_over] }
       errored = items.count { |item| item[:error] }

data/lib/bitfab/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitfab
 version: !ruby/object:Gem::Version
-  version: 0.64.5
+  version: 0.64.7
 platform: ruby
 authors:
 - Harvest Team
@@ -184,6 +184,7 @@ files:
 - lib/bitfab/replay_branch.rb
 - lib/bitfab/replay_cli.rb
 - lib/bitfab/replay_concurrency.rb
+- lib/bitfab/replay_invocation.rb
 - lib/bitfab/replay_memory.rb
 - lib/bitfab/replay_processes.rb
 - lib/bitfab/replay_registry.rb