selective-ruby-core 0.2.8-aarch64-linux → 0.2.10-aarch64-linux

data/lib/selective/ruby/core/controller.rb

@@ -16,15 +16,17 @@ module Selective
           "platform" => "SELECTIVE_PLATFORM",
           "run_id" => "SELECTIVE_RUN_ID",
           "run_attempt" => "SELECTIVE_RUN_ATTEMPT",
-          "branch" => "SELECTIVE_BRANCH"
+          "branch" => "SELECTIVE_BRANCH",
+          "sha" => "SELECTIVE_SHA",
+          "git_repo_full_name" => "SELECTIVE_GIT_REPO",
+          "git_provider" => "SELECTIVE_GIT_PROVIDER"
         }.freeze
 
         def initialize(runner_class, runner_args, debug: false, log: false)
           @debug = debug
+          @log = log
           @runner = runner_class.new(runner_args, method(:test_case_callback))
           @retries = 0
-          @runner_id = safe_filename(get_runner_id)
-          @logger = init_logger(log)
         end
 
         def start(reconnect: false)
@@ -64,7 +66,19 @@ module Selective
 
         private
 
-        attr_reader :runner, :pipe, :transport_pid, :retries, :logger, :runner_id, :diff
+        attr_reader :runner, :pipe, :transport_pid, :retries, :diff
+
+        # Resolved on first use rather than in the constructor: `selective
+        # exec` (the plain framework run behind the manifest dry-run) never
+        # connects, so it must not require the CI environment that naming a
+        # runner validates.
+        def runner_id
+          @runner_id ||= safe_filename(get_runner_id)
+        end
+
+        def logger
+          @logger ||= init_logger(@log)
+        end
 
         def get_runner_id
           runner_id = build_env["runner_id"]
@@ -87,7 +101,7 @@ module Selective
             message = pipe.read
             response = JSON.parse(message, symbolize_names: true)
 
-            @logger.info("Received Command: #{response}")
+            logger.info("Received Command: #{response}")
             break if handle_command(response) == :break
           end
         end
@@ -137,6 +151,13 @@ module Selective
               "framework" => runner.framework,
               "framework_version" => runner.framework_version,
               "framework_wrapper_version" => runner.wrapper_version,
+              "runtime_version" => RUBY_VERSION,
+              # "record", "select" or "0": whether this runner can record a
+              # test map, only run selected subsets, or neither.
+              "test_map" => TestMap.capability,
+              # Forces this run to record (e.g. a nightly full run), however
+              # fresh the current map is.
+              "test_map_record" => ENV["SELECTIVE_TEST_MAP_RECORD"].to_s
             }.merge(metadata: metadata.to_json)
           end
         end
@@ -268,8 +289,11 @@ module Selective
 
         def handle_test_manifest(_data)
           self.class.restore_reporting!
-          @logger.info("Sending Response: test_manifest")
+          logger.info("Sending Response: test_manifest")
           data = {test_cases: runner.manifest["examples"] || runner.manifest["test_cases"]}
+          if TestMap.tree_requested? && (tree = test_map_tree)
+            data[:test_map_tree] = tree
+          end
           num_commits = build_env["num_commits"] || 1000
           if (diff = get_diff(num_commits))
             data[:modified_test_files] = modified_test_files(diff)
@@ -278,6 +302,22 @@ module Selective
           write({type: "test_manifest", data: data})
         end
 
+        # Sent by servers that support test maps, before any tests are
+        # assigned. `tree: true` asks for a file-hash snapshot with the
+        # manifest; `record: true` turns on tracing for every test this runner
+        # executes.
+        def handle_configure_test_map(data)
+          recorder = TestMap.configure(
+            record: data[:record] == true,
+            tree: data[:tree] == true,
+            allocations: data[:allocations] != false
+          )
+          logger.info("Test map configured: record=#{!recorder.nil?} tree=#{TestMap.tree_requested?}")
+          if data[:record] == true && recorder.nil?
+            print_warning("Selective asked this runner to record a test map, but the native tracer isn't available. Tests will run normally.")
+          end
+        end
+
         def handle_run_test_cases(data)
           runner.run_test_cases(data[:test_case_ids])
         end
@@ -304,6 +344,8 @@ module Selective
             runner.finish unless exit_status.is_a?(Integer)
           end
 
+          upload_test_map
+
           kill_transport
           pipe.delete_pipes
           exit(exit_status || runner.exit_status)
@@ -312,12 +354,40 @@ module Selective
           :break
         end
 
+        def test_map_tree
+          TestMap::Tree.snapshot
+        rescue => e
+          logger.warn("Could not snapshot the repository for test selection: #{e.message}")
+          nil
+        end
+
+        def upload_test_map
+          recorder = TestMap.recorder
+          return if recorder.nil? || recorder.empty?
+
+          uploader = TestMap::Uploader.new(
+            host: build_env["host"],
+            api_key: build_env["api_key"],
+            run_id: build_env["run_id"],
+            run_attempt: build_env["run_attempt"],
+            runner_id: runner_id,
+            logger: logger
+          )
+          if uploader.upload(recorder.to_h)
+            logger.info("Uploaded test map fragment: #{recorder.test_count} tests")
+          else
+            print_warning("Selective could not upload this runner's test map (#{uploader.last_error&.message}). Its tests will run on the next build rather than be skipped.")
+          end
+        rescue => e
+          logger.warn("Test map upload failed: #{e.class}: #{e.message}")
+        end
+
         def correlated_files(diff, num_commits)
           Selective::Ruby::Core::FileCorrelator.new(diff, num_commits, build_env["target_branch"]).correlate
         end
 
         def test_case_callback(test_case)
-          @logger.info("Sending Response: test_case_result: #{test_case[:id]}")
+          logger.info("Sending Response: test_case_result: #{test_case[:id]}")
           write({type: "test_case_result", data: test_case})
         end
 

data/lib/selective/ruby/core/test_map/recorder.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Selective
+  module Ruby
+    module Core
+      module TestMap
+        # Accumulates "test id => files" for every test this runner executes and
+        # serialises it as a fragment. Paths are interned into a table so a
+        # fragment carries each path once, not once per test that touched it.
+        class Recorder
+          FORMAT_VERSION = 1
+
+          attr_reader :tracer
+
+          def initialize(tracer:)
+            @tracer = tracer
+            @paths = []
+            @path_index = {}
+            @tests = {}
+          end
+
+          # Retries and reruns can run a test twice in one process. Keep the
+          # union: a dependency seen on any attempt is a real dependency.
+          def record(test_id)
+            result, files = tracer.trace { yield }
+            indexes = (@tests[test_id] ||= Set.new)
+            files.each { |path| indexes << intern(path) }
+            result
+          end
+
+          def test_count
+            @tests.size
+          end
+
+          def empty?
+            @tests.empty?
+          end
+
+          def to_h
+            {
+              version: FORMAT_VERSION,
+              files: @paths,
+              tests: @tests.map { |id, indexes| {id: id, deps: indexes.to_a.sort} }
+            }
+          end
+
+          private
+
+          def intern(path)
+            @path_index[path] ||= begin
+              @paths << path
+              @paths.size - 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/test_map/tracer.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Selective
+  module Ruby
+    module Core
+      module TestMap
+        # Ruby face of the native tracer: decides which paths count as the
+        # project's own code, and turns what the tracer saw into sorted,
+        # repo-relative paths that line up with `git ls-tree`.
+        class Tracer
+          attr_reader :repo_root
+
+          def initialize(allocations: true, repo_root: Tree.repo_root, pwd: Dir.pwd)
+            @repo_root = repo_root || File.realpath(pwd)
+            @roots = unique_dirs([@repo_root, pwd])
+            # Only directories *inside* a root need ignoring (everything else is
+            # outside the roots already). An ancestor would ignore the whole
+            # project, e.g. GEM_HOME=/work with the repo at /work/app.
+            @ignored = unique_dirs(ignored_dirs).select do |dir|
+              @roots.any? { |root| dir.start_with?("#{root}/") }
+            end
+            @native = NativeTracer.new(roots: @roots, ignored: @ignored, allocations: allocations)
+            @relative_paths = {}
+            @class_files = {}.compare_by_identity
+          end
+
+          # Runs the block with tracing on and returns [result, files], where
+          # files is a Set of repo-relative paths.
+          def trace
+            @native.start
+            begin
+              result = yield
+            ensure
+              files, klasses = @native.stop
+            end
+            [result, collect(files, klasses)]
+          end
+
+          private
+
+          def collect(files, klasses)
+            paths = Set.new
+            files.each_key do |path|
+              rel = relative(path)
+              paths << rel if rel
+            end
+            klasses.each do |klass|
+              files_for_class(klass).each { |rel| paths << rel }
+            end
+            paths
+          end
+
+          # A class's own file, plus those of its project-defined ancestors: a
+          # test that builds a `User` depends on `ApplicationRecord` too.
+          def files_for_class(klass)
+            @class_files[klass] ||= klass.ancestors.filter_map do |mod|
+              name = mod.name
+              next if name.nil?
+
+              location = Object.const_source_location(name)&.first
+              location && relative(location)
+            rescue NameError, ArgumentError, TypeError
+              nil
+            end.uniq.freeze
+          end
+
+          def relative(path)
+            return @relative_paths[path] if @relative_paths.key?(path)
+
+            @relative_paths[path] = compute_relative(path)
+          end
+
+          def compute_relative(path)
+            abs = File.expand_path(path)
+            return nil if ignored?(abs)
+
+            rel = strip_root(abs)
+            if rel.nil? && File.exist?(abs)
+              real = File.realpath(abs)
+              rel = strip_root(real) unless ignored?(real)
+            end
+            rel
+          end
+
+          def strip_root(abs)
+            prefix = "#{@repo_root}/"
+            abs.start_with?(prefix) ? abs.delete_prefix(prefix) : nil
+          end
+
+          def ignored?(abs)
+            @ignored.any? { |dir| abs == dir || abs.start_with?("#{dir}/") }
+          end
+
+          # Code the project runs but doesn't own: installed gems (including a
+          # vendored bundle inside the repo) and Selective's own gems, which
+          # live inside the repo when developed through path/symlinks.
+          def ignored_dirs
+            dirs = [Gem.dir, *Gem.path]
+            dirs << Bundler.bundle_path.to_s if defined?(Bundler) && Bundler.respond_to?(:bundle_path)
+            Gem.loaded_specs.each do |name, spec|
+              dirs << spec.full_gem_path if name.start_with?("selective-ruby-")
+            end
+            extra = ENV["SELECTIVE_TEST_MAP_IGNORE"].to_s.split(",").map(&:strip).reject(&:empty?)
+            dirs.concat(extra.map { |d| File.expand_path(d) })
+          end
+
+          def unique_dirs(dirs)
+            dirs.compact.flat_map do |dir|
+              expanded = File.expand_path(dir.to_s)
+              real = File.exist?(expanded) ? File.realpath(expanded) : expanded
+              [expanded, real]
+            end.map { |d| d.chomp("/") }.reject(&:empty?).uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/test_map/tree.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Selective
+  module Ruby
+    module Core
+      module TestMap
+        # A content-hash snapshot of the repository: every file's git blob id.
+        #
+        # This is what makes selection independent of diffs. The server
+        # compares these hashes with the ones stored alongside the map, so there
+        # is no base commit to pick, no merge-base to compute and no fetch depth
+        # to get right. It works in a depth-1 clone, and for uncommitted edits
+        # (a developer or an agent running locally) it hashes what is actually
+        # on disk rather than what HEAD says.
+        module Tree
+          module_function
+
+          def repo_root
+            out, status = Open3.capture2e("git", "rev-parse", "--show-toplevel")
+            status.success? ? out.strip : nil
+          rescue SystemCallError
+            nil
+          end
+
+          # => {sha:, prefix:, files: {path => blob}, dirty: [paths]} or nil
+          # when the working directory isn't a git checkout.
+          def snapshot(pwd: Dir.pwd)
+            root = repo_root
+            return nil if root.nil?
+
+            files = committed_files(root)
+            return nil if files.nil?
+
+            dirty = apply_working_tree_changes(root, files)
+            {
+              sha: head_sha(root),
+              prefix: prefix_for(root, pwd),
+              files: files,
+              dirty: dirty
+            }
+          end
+
+          # Where the test command runs, relative to the repository root, e.g.
+          # "services/api/" in a monorepo. The server uses it to line manifest
+          # paths (relative to the command) up with tree paths (relative to the
+          # root).
+          def prefix_for(root, pwd)
+            real = File.realpath(pwd)
+            return "" if real == root
+
+            real.start_with?("#{root}/") ? "#{real.delete_prefix("#{root}/")}/" : ""
+          end
+
+          def head_sha(root)
+            git(root, "rev-parse", "HEAD")&.strip
+          end
+
+          def committed_files(root)
+            out = git(root, "ls-tree", "-r", "-z", "--full-tree", "HEAD")
+            return nil if out.nil?
+
+            out.split("\0").each_with_object({}) do |entry, files|
+              meta, path = entry.split("\t", 2)
+              next if path.nil?
+
+              _mode, _type, blob = meta.split(" ")
+              files[path] = blob
+            end
+          end
+
+          # Folds uncommitted edits to tracked files into the snapshot. Returns
+          # the dirty paths so the server can report that the run used a
+          # working tree.
+          #
+          # Untracked files are deliberately left out. They add nothing — a new
+          # test file is "new" to the map through the manifest, and a new app
+          # file can't be a recorded dependency — and they churn: runner logs,
+          # tmp/, coverage output. Hashing them made a local log file look like
+          # a changed file no test uses, which runs the whole suite.
+          def apply_working_tree_changes(root, files)
+            out = git(root, "status", "--porcelain=v1", "-z", "--untracked-files=no", "--no-renames")
+            return [] if out.nil? || out.empty?
+
+            changed = []
+            deleted = []
+            out.split("\0").each do |entry|
+              next if entry.length < 4
+
+              status = entry[0, 2]
+              path = entry[3..]
+              if status.include?("D") && !File.exist?(File.join(root, path))
+                files.delete(path)
+                deleted << path
+              else
+                changed << path
+              end
+            end
+
+            hash_objects(root, changed).each { |path, blob| files[path] = blob }
+            changed + deleted
+          end
+
+          def hash_objects(root, paths)
+            existing = paths.select { |p| File.file?(File.join(root, p)) }
+            return {} if existing.empty?
+
+            out, status = Open3.capture2("git", "-C", root, "hash-object", "--stdin-paths", stdin_data: existing.join("\n") + "\n")
+            return {} unless status.success?
+
+            existing.zip(out.split("\n")).to_h
+          end
+
+          def git(root, *args)
+            out, status = Open3.capture2("git", "-C", root, *args)
+            status.success? ? out : nil
+          rescue SystemCallError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/test_map/uploader.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "open3"
+require "rbconfig"
+require "tempfile"
+require "uri"
+require "zlib"
+
+module Selective
+  module Ruby
+    module Core
+      module TestMap
+        # Sends this runner's recorded fragment to the server over HTTPS.
+        #
+        # A map is far larger than anything else a runner sends (tests × files),
+        # so it doesn't go over the WebSocket. Upload failure never fails the
+        # build: the worst outcome is a map missing this runner's tests, and a
+        # test missing from the map is always run.
+        #
+        # The POST runs in a child Ruby process. The upload happens inside the
+        # test process, where suites commonly load WebMock or VCR, and those
+        # intercept every Net::HTTP request, this one included. A child started
+        # without Bundler's environment loads neither.
+        class Uploader
+          PATH = "/test_maps/fragments"
+          ATTEMPTS = 3
+
+          def initialize(host:, api_key:, run_id:, run_attempt:, runner_id:, logger: nil)
+            @uri = build_uri(host, run_id: run_id, run_attempt: run_attempt, runner_id: runner_id)
+            @api_key = api_key
+            @logger = logger
+          end
+
+          # Returns true on success.
+          def upload(fragment)
+            body = Zlib.gzip(JSON.generate(fragment))
+            attempt = 0
+            begin
+              attempt += 1
+              true if post(body)
+            rescue => e
+              @logger&.warn("Test map upload attempt #{attempt} failed: #{e.message}")
+              if attempt < ATTEMPTS
+                sleep(attempt)
+                retry
+              end
+              @last_error = e
+              false
+            end
+          end
+
+          attr_reader :last_error, :uri
+
+          private
+
+          # The request, as a standalone script for the child process. The API key
+          # arrives in the environment, never on the command line.
+          CHILD_SCRIPT = <<~RUBY
+            require "net/http"
+            require "uri"
+            uri = URI(ARGV.fetch(0))
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = uri.scheme == "https"
+            http.open_timeout = 10
+            http.read_timeout = 120
+            request = Net::HTTP::Post.new(uri.request_uri)
+            request["authorization"] = ENV.fetch("SELECTIVE_TEST_MAP_UPLOAD_KEY")
+            request["content-type"] = "application/gzip"
+            request.body = File.binread(ARGV.fetch(1))
+            response = http.request(request)
+            puts response.code
+            warn response.body.to_s[0, 200] unless response.is_a?(Net::HTTPSuccess)
+            exit(response.is_a?(Net::HTTPSuccess) ? 0 : 1)
+          RUBY
+
+          # Keeps Bundler (and whatever it would require) out of the child.
+          CLEAN_ENV = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_SETUP BUNDLER_VERSION GEM_HOME
+            GEM_PATH].to_h do |k|
+            [k, nil]
+          end
+
+          # Raises unless the server accepted the upload.
+          def post(body)
+            Tempfile.create(["selective-test-map", ".json.gz"], binmode: true) do |file|
+              file.write(body)
+              file.flush
+
+              env = CLEAN_ENV.merge("SELECTIVE_TEST_MAP_UPLOAD_KEY" => @api_key.to_s)
+              out, err, status = Open3.capture3(env, RbConfig.ruby, "-e", CHILD_SCRIPT, @uri.to_s, file.path)
+              raise "HTTP #{out.strip}: #{err.strip}" unless status.success?
+
+              true
+            end
+          end
+
+          # The runner is configured with the WebSocket host (ws:// or wss://);
+          # the upload goes to the same server over HTTP(S).
+          def build_uri(host, **params)
+            base = host.sub(%r{\Aws(s?)://}) { "http#{::Regexp.last_match(1)}://" }.chomp("/")
+            URI("#{base}#{PATH}?#{URI.encode_www_form(params)}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/test_map.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Selective
+  module Ruby
+    module Core
+      # Test maps let Selective skip tests a change can't affect.
+      #
+      # A *recording* run traces every test with the native tracer and uploads
+      # "test id => repo files it executed" when the runner finishes. A later
+      # run sends a snapshot of the repository's file hashes with its manifest,
+      # and the server skips a test only when every file it depends on is
+      # byte-for-byte what it was when the map was recorded.
+      #
+      # Everything here is inert unless the server asks for it
+      # (`configure_test_map`), and recording additionally needs the optional
+      # native extension. Without either, the suite runs exactly as before.
+      module TestMap
+        class << self
+          # True when the native tracer compiled and loads on this Ruby.
+          def available?
+            return @available if defined?(@available)
+
+            @available = if disabled?
+              false
+            else
+              begin
+                require "selective_tracer"
+                true
+              rescue LoadError
+                false
+              end
+            end
+          end
+
+          # SELECTIVE_TEST_MAP_DISABLE=1 is the escape hatch: the runner then
+          # never records and never takes part in selection.
+          def disabled?
+            ENV["SELECTIVE_TEST_MAP_DISABLE"].to_s.match?(/\A(1|true|yes)\z/i)
+          end
+
+          # What this runner can do, as advertised to the server. Selection
+          # needs only a git snapshot, so a runner without the native tracer
+          # (unsupported Ruby, failed compile) still runs selected subsets
+          # from maps recorded elsewhere; it just can't record one.
+          def capability
+            return "0" if disabled?
+
+            available? ? "record" : "select"
+          end
+
+          # Recording is one-way for the life of the process: a reconnect can
+          # make the server re-send its configuration, and dropping a recorder
+          # would throw away every test traced so far.
+          def configure(record: false, tree: false, allocations: true)
+            @tree_requested = tree
+            if record && available?
+              @recorder ||= Recorder.new(tracer: Tracer.new(allocations: allocations))
+            end
+            @recorder
+          end
+
+          def recording?
+            !@recorder.nil?
+          end
+
+          def tree_requested?
+            @tree_requested == true
+          end
+
+          # Wraps one test. Adapters call this around the framework's own
+          # "run this test" so setup, the test body and teardown are all traced.
+          def around(test_id)
+            recorder = @recorder
+            return yield if recorder.nil?
+
+            recorder.record(test_id) { yield }
+          end
+
+          attr_reader :recorder
+
+          def reset!
+            @recorder = nil
+            @tree_requested = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/selective/ruby/core/version.rb

@@ -3,7 +3,7 @@
 module Selective
   module Ruby
     module Core
-      VERSION = "0.2.8"
+      VERSION = "0.2.10"
     end
   end
 end