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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 449df88a9c1971a298416d1a8572c35d9bd6ead7a76df9c7cdec29005f2bdb2f
-  data.tar.gz: e7052df2bbff8f5927bf93a255d9a7b54cabe6bbd38e0ede590d3482fdf26e61
+  metadata.gz: 52b12017e465ee18c005f6661d79d12ea3e23821111ebe8ce13999b88dbc93b3
+  data.tar.gz: b1c4bbae8c2c5eb6dbc22376d8c1b6fbd49441af39de0632489e49b448692821
 SHA512:
-  metadata.gz: 97cf8dc0e85104e3d6183f666e9ff6ec0ae1d54051f299fd8551097435b0cfa660cba823ad02067ba42a137d1760550c2743300dc42ed81ba450a9d82d33c47c
-  data.tar.gz: 54c27979b7cbfa15ef74dce92a3ae5c880327a02325ee0bb7d0494d4c304137e7518be749c7da6def9047d8290148a64f3500bef631df3f3a11749c846bbd3af
+  metadata.gz: '028d9d8ddbebf24ba288ea081d6cc2d06f8cca626258c514d120e0f8140578e9e92b54c4dcbb281c2734844ec7a2fb622346eef84ab8e5867602efa022266d5a'
+  data.tar.gz: 7edf81122e5c5978f16866b5b1848bfe7514762e7831bc7592b3311c1524727b4df29ba49c74f2f8e6e073b77b30464fae5ccd36a7a9f9afc5ade85b04dc340b

data/Rakefile

@@ -5,6 +5,26 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
+# Builds the optional test map tracer into lib/ for development and CI.
+# Installed gems build it through `spec.extensions` instead.
+desc "Compile the native test map tracer"
+task :compile do
+  require "fileutils"
+  require "rbconfig"
+  ext_dir = File.expand_path("ext/selective_tracer", __dir__)
+  build_dir = File.expand_path("tmp/selective_tracer", __dir__)
+  FileUtils.mkdir_p(build_dir)
+  Dir.chdir(build_dir) do
+    # extconf must not inherit this process's bundle; it only needs mkmf.
+    Bundler.with_unbundled_env do
+      sh RbConfig.ruby, File.join(ext_dir, "extconf.rb")
+      sh "make"
+    end
+    built = Dir["selective_tracer.{#{RbConfig::CONFIG["DLEXT"]},bundle,so}"].first
+    FileUtils.cp(built, File.expand_path("lib", __dir__)) if built
+  end
+end
+
 require "standard/rake"
 
 task default: %i[spec standard]

data/ext/selective_tracer/extconf.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# The tracer is optional. A customer without a C toolchain (or on an
+# unsupported Ruby) must still be able to install selective-ruby-core and run
+# their suite exactly as before, so any failed check writes a no-op Makefile
+# instead of failing `gem install`. That includes compiling the tracer itself
+# here first: an error in `make` would fail the install, so a Ruby whose
+# headers the source doesn't build against must be caught before it. At
+# runtime the missing library simply means "this runner can't record a test
+# map".
+
+require "mkmf"
+
+def write_noop_makefile(reason)
+  warn "selective_tracer: skipping native build (#{reason}); test map recording will be unavailable"
+  File.write("Makefile", <<~MAKE)
+    all:
+    \t@true
+    install:
+    \t@true
+    clean:
+    \t@true
+  MAKE
+end
+
+begin
+  if RUBY_ENGINE != "ruby"
+    write_noop_makefile("#{RUBY_ENGINE} is not supported")
+  elsif !have_header("ruby/debug.h") || !have_func("rb_profile_frames", "ruby/debug.h")
+    write_noop_makefile("required VM hook APIs are missing")
+  else
+    $CFLAGS << " -O2 -std=c99 -Wall -Wno-unused-parameter" # standard:disable Style/GlobalVars -- mkmf's interface
+    if try_compile(File.read(File.expand_path("selective_tracer.c", __dir__)))
+      create_makefile("selective_tracer")
+    else
+      write_noop_makefile("the tracer does not compile on Ruby #{RUBY_VERSION}; see mkmf.log")
+    end
+  end
+rescue => e
+  write_noop_makefile(e.message)
+end

data/ext/selective_tracer/selective_tracer.c

@@ -0,0 +1,336 @@
+// selective_tracer — records which source files a single test executes.
+//
+// A test map is built from one question asked of every test: "which files
+// did you run?". This extension answers it with two raw VM event hooks that
+// never call back into Ruby while the test runs:
+//
+//   * RUBY_EVENT_LINE | CALL | B_CALL, registered globally so work done on
+//     *any* thread is
+//     attributed to the running test. Capybara drives a Puma server thread;
+//     a hook scoped to the test's own thread (what rotoscope does) would map
+//     every system test to nothing and let selection skip them wrongly.
+//     Selective runs one test at a time per process, so "everything that ran
+//     between start and stop" is the right attribution. Stray background
+//     threads can only add files, which makes selection more conservative,
+//     never less. CALL and B_CALL are not redundant with LINE: an endless
+//     method (`def total = price * qty`) and a one-line block executed from
+//     another file emit no line event of their own, so a line-only hook never
+//     ties a test to the file they live in.
+//
+//   * RUBY_INTERNAL_EVENT_NEWOBJ (optional), which records the class of every
+//     plain object allocated. A class whose file only ran at boot — an
+//     ActiveRecord model with no methods of its own — executes no lines
+//     during a test, so line events alone would never tie the test to it.
+//     The classes are resolved to source files in Ruby after the test stops.
+//
+// Why not Ruby's Coverage module: it is process-global, so it cannot run next
+// to SimpleCov, and while it is enabled Bootsnap cannot use its compile cache.
+// Why not TracePoint from Ruby: every event re-enters the interpreter. The
+// design follows what Datadog learned building datadog-ci-rb (line hook with
+// pointer caching, allocation tracking for code-less classes), written for
+// Selective's needs: several project roots, several ignored prefixes, and no
+// Ruby API use inside the allocation hook.
+
+#include <ruby.h>
+#include <ruby/debug.h>
+#include <ruby/st.h>
+
+#include <stdbool.h>
+#include <string.h>
+
+#define PATH_CACHE_SIZE 1024   // power of two
+#define KLASS_CACHE_SIZE 4096  // power of two
+#define MAX_PREFIXES 32
+#define EXEC_EVENTS (RUBY_EVENT_LINE | RUBY_EVENT_CALL | RUBY_EVENT_B_CALL)
+
+struct prefix_list {
+  int count;
+  char *values[MAX_PREFIXES];
+  long lengths[MAX_PREFIXES];
+};
+
+struct tracer {
+  // { path(String) => true } for the test being recorded.
+  VALUE files;
+
+  // Absolute paths are kept only under one of `roots` and outside every
+  // `ignored` prefix (bundled gems, Selective's own gems, tmp dirs).
+  struct prefix_list roots;
+  struct prefix_list ignored;
+
+  // Consecutive line events almost always come from the same file, and the
+  // path pointer of an iseq is stable, so a pointer comparison settles most
+  // events. The strings are marked so a freed path's address can't be reused
+  // for a different file and wrongly treated as "already seen".
+  VALUE last_path;
+  VALUE path_cache[PATH_CACHE_SIZE];
+
+  bool allocations;
+  bool running;
+
+  // Classes allocated during the test. Keys are class VALUEs, pinned by mark.
+  st_table *klasses;
+  VALUE last_klass;
+  VALUE klass_cache[KLASS_CACHE_SIZE];
+};
+
+static int mark_klass_i(st_data_t key, st_data_t _value, st_data_t _arg) {
+  rb_gc_mark((VALUE)key);
+  return ST_CONTINUE;
+}
+
+static void tracer_mark(void *ptr) {
+  struct tracer *t = ptr;
+  rb_gc_mark(t->files);
+  rb_gc_mark(t->last_path);
+  for (int i = 0; i < PATH_CACHE_SIZE; i++) rb_gc_mark(t->path_cache[i]);
+  rb_gc_mark(t->last_klass);
+  for (int i = 0; i < KLASS_CACHE_SIZE; i++) rb_gc_mark(t->klass_cache[i]);
+  if (t->klasses) st_foreach(t->klasses, mark_klass_i, 0);
+}
+
+static void free_prefixes(struct prefix_list *list) {
+  for (int i = 0; i < list->count; i++) xfree(list->values[i]);
+  list->count = 0;
+}
+
+static void tracer_free(void *ptr) {
+  struct tracer *t = ptr;
+  // No hook cleanup needed: the VM marks every registered hook's data, so a
+  // tracer that is still running is reachable and can't be freed.
+  free_prefixes(&t->roots);
+  free_prefixes(&t->ignored);
+  if (t->klasses) st_free_table(t->klasses);
+  xfree(t);
+}
+
+static size_t tracer_memsize(const void *ptr) {
+  return sizeof(struct tracer);
+}
+
+static const rb_data_type_t tracer_type = {
+    .wrap_struct_name = "selective_tracer",
+    .function = {.dmark = tracer_mark, .dfree = tracer_free, .dsize = tracer_memsize},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY};
+
+static void reset_caches(struct tracer *t) {
+  t->last_path = Qnil;
+  for (int i = 0; i < PATH_CACHE_SIZE; i++) t->path_cache[i] = Qnil;
+  t->last_klass = Qnil;
+  for (int i = 0; i < KLASS_CACHE_SIZE; i++) t->klass_cache[i] = Qnil;
+}
+
+static VALUE tracer_alloc(VALUE klass) {
+  struct tracer *t;
+  VALUE self = TypedData_Make_Struct(klass, struct tracer, &tracer_type, t);
+  t->files = Qnil;
+  t->roots.count = 0;
+  t->ignored.count = 0;
+  t->allocations = false;
+  t->running = false;
+  t->klasses = NULL;
+  reset_caches(t);
+  t->files = rb_hash_new();
+  t->klasses = st_init_numtable();
+  return self;
+}
+
+static struct tracer *get_tracer(VALUE self) {
+  struct tracer *t;
+  TypedData_Get_Struct(self, struct tracer, &tracer_type, t);
+  return t;
+}
+
+static bool has_dir_prefix(const char *path, long path_len, const char *prefix, long prefix_len) {
+  if (prefix_len > path_len || memcmp(prefix, path, prefix_len) != 0) return false;
+  // "/app" must not match "/application"; a prefix given with a trailing
+  // slash already carries the boundary.
+  return prefix_len == path_len || prefix[prefix_len - 1] == '/' || path[prefix_len] == '/';
+}
+
+static bool path_included(struct tracer *t, const char *path, long len) {
+  if (len == 0) return false;
+
+  if (path[0] != '/') {
+    // Relative paths ("./spec/x_spec.rb" from `load`) are resolved and
+    // re-checked in Ruby. Pseudo-paths like "(eval at ...)" and
+    // "<internal:kernel>" are never project files.
+    return path[0] != '(' && path[0] != '<';
+  }
+
+  bool in_root = false;
+  for (int i = 0; i < t->roots.count; i++) {
+    if (has_dir_prefix(path, len, t->roots.values[i], t->roots.lengths[i])) {
+      in_root = true;
+      break;
+    }
+  }
+  if (!in_root) return false;
+
+  for (int i = 0; i < t->ignored.count; i++) {
+    if (has_dir_prefix(path, len, t->ignored.values[i], t->ignored.lengths[i])) return false;
+  }
+  return true;
+}
+
+static inline size_t cache_slot(uintptr_t ptr, size_t size) {
+  return ((ptr >> 4) ^ (ptr >> 12)) & (size - 1);
+}
+
+static void on_exec(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE klass) {
+  struct tracer *t = RTYPEDDATA_DATA(data);
+
+  const char *current = rb_sourcefile();
+  if (current == NULL) return;
+
+  if (t->last_path != Qnil && RSTRING_PTR(t->last_path) == current) return;
+
+  size_t slot = cache_slot((uintptr_t)current, PATH_CACHE_SIZE);
+  VALUE cached = t->path_cache[slot];
+  if (cached != Qnil && RSTRING_PTR(cached) == current) {
+    t->last_path = cached;
+    return;
+  }
+
+  // First time this test sees this file: fetch the frame's path String so
+  // the pointer we cache is owned by a marked object.
+  VALUE frame;
+  if (rb_profile_frames(0, 1, &frame, NULL) != 1) return;
+
+  VALUE path = rb_profile_frame_path(frame);
+  if (NIL_P(path) || !RB_TYPE_P(path, T_STRING)) return;
+
+  t->last_path = path;
+  t->path_cache[slot] = path;
+
+  if (path_included(t, RSTRING_PTR(path), RSTRING_LEN(path))) {
+    rb_hash_aset(t->files, path, Qtrue);
+  }
+}
+
+// Runs inside object allocation: no Ruby method calls and no Ruby object
+// allocation are allowed here. rb_obj_class, rb_mod_name and st_* do neither.
+static void on_newobj(VALUE data, rb_trace_arg_t *targ) {
+  VALUE obj = rb_tracearg_object(targ);
+  enum ruby_value_type type = rb_type(obj);
+  if (type != RUBY_T_OBJECT && type != RUBY_T_STRUCT) return;
+
+  VALUE klass = rb_obj_class(obj);
+  if (klass == 0 || NIL_P(klass)) return;
+
+  struct tracer *t = RTYPEDDATA_DATA(data);
+  if (t->last_klass == klass) return;
+
+  size_t slot = cache_slot((uintptr_t)klass, KLASS_CACHE_SIZE);
+  if (t->klass_cache[slot] == klass) {
+    t->last_klass = klass;
+    return;
+  }
+
+  t->last_klass = klass;
+  t->klass_cache[slot] = klass;
+
+  if (st_is_member(t->klasses, (st_data_t)klass)) return;
+  if (NIL_P(rb_mod_name(klass))) return;  // anonymous class: no file to resolve
+
+  st_insert(t->klasses, (st_data_t)klass, 1);
+}
+
+static void load_prefixes(struct prefix_list *list, VALUE ary, const char *name) {
+  if (NIL_P(ary)) return;
+  Check_Type(ary, T_ARRAY);
+  long n = RARRAY_LEN(ary);
+  if (n > MAX_PREFIXES) rb_raise(rb_eArgError, "at most %d %s are supported", MAX_PREFIXES, name);
+
+  for (long i = 0; i < n; i++) {
+    VALUE s = rb_ary_entry(ary, i);
+    Check_Type(s, T_STRING);
+    long len = RSTRING_LEN(s);
+    if (len == 0) continue;
+    char *copy = ALLOC_N(char, len + 1);
+    memcpy(copy, RSTRING_PTR(s), len);
+    copy[len] = '\0';
+    list->values[list->count] = copy;
+    list->lengths[list->count] = len;
+    list->count++;
+  }
+}
+
+// NativeTracer.new(roots: [...], ignored: [...], allocations: true/false)
+static VALUE tracer_initialize(int argc, VALUE *argv, VALUE self) {
+  VALUE opts;
+  rb_scan_args(argc, argv, "1", &opts);
+  Check_Type(opts, T_HASH);
+
+  struct tracer *t = get_tracer(self);
+  free_prefixes(&t->roots);
+  free_prefixes(&t->ignored);
+
+  load_prefixes(&t->roots, rb_hash_aref(opts, ID2SYM(rb_intern("roots"))), "roots");
+  load_prefixes(&t->ignored, rb_hash_aref(opts, ID2SYM(rb_intern("ignored"))), "ignored prefixes");
+  if (t->roots.count == 0) rb_raise(rb_eArgError, "roots must contain at least one path");
+
+  t->allocations = RTEST(rb_hash_aref(opts, ID2SYM(rb_intern("allocations"))));
+  return self;
+}
+
+static VALUE tracer_start(VALUE self) {
+  struct tracer *t = get_tracer(self);
+  if (t->running) rb_raise(rb_eRuntimeError, "tracer is already running");
+
+  rb_hash_clear(t->files);
+  st_clear(t->klasses);
+  reset_caches(t);
+
+  rb_add_event_hook2((rb_event_hook_func_t)on_exec, EXEC_EVENTS, self, RUBY_EVENT_HOOK_FLAG_SAFE);
+  if (t->allocations) {
+    rb_add_event_hook2((rb_event_hook_func_t)on_newobj, RUBY_INTERNAL_EVENT_NEWOBJ, self,
+                       RUBY_EVENT_HOOK_FLAG_SAFE | RUBY_EVENT_HOOK_FLAG_RAW_ARG);
+  }
+  t->running = true;
+  return self;
+}
+
+static int collect_klass_i(st_data_t key, st_data_t _value, st_data_t ary) {
+  rb_ary_push((VALUE)ary, (VALUE)key);
+  return ST_CONTINUE;
+}
+
+// Returns [files, classes]: the Hash of executed paths and the Array of named
+// classes allocated during the test. Both are fresh objects owned by Ruby.
+static VALUE tracer_stop(VALUE self) {
+  struct tracer *t = get_tracer(self);
+  if (!t->running) rb_raise(rb_eRuntimeError, "tracer is not running");
+
+  rb_remove_event_hook_with_data((rb_event_hook_func_t)on_exec, self);
+  if (t->allocations) rb_remove_event_hook_with_data((rb_event_hook_func_t)on_newobj, self);
+  t->running = false;
+
+  VALUE files = t->files;
+  t->files = rb_hash_new();
+
+  VALUE klasses = rb_ary_new_capa((long)t->klasses->num_entries);
+  st_foreach(t->klasses, collect_klass_i, (st_data_t)klasses);
+  st_clear(t->klasses);
+  reset_caches(t);
+
+  return rb_assoc_new(files, klasses);
+}
+
+static VALUE tracer_running_p(VALUE self) {
+  return get_tracer(self)->running ? Qtrue : Qfalse;
+}
+
+void Init_selective_tracer(void) {
+  VALUE mSelective = rb_define_module("Selective");
+  VALUE mRuby = rb_define_module_under(mSelective, "Ruby");
+  VALUE mCore = rb_define_module_under(mRuby, "Core");
+  VALUE mTestMap = rb_define_module_under(mCore, "TestMap");
+  VALUE cTracer = rb_define_class_under(mTestMap, "NativeTracer", rb_cObject);
+
+  rb_define_alloc_func(cTracer, tracer_alloc);
+  rb_define_method(cTracer, "initialize", tracer_initialize, -1);
+  rb_define_method(cTracer, "start", tracer_start, 0);
+  rb_define_method(cTracer, "stop", tracer_stop, 0);
+  rb_define_method(cTracer, "running?", tracer_running_p, 0);
+}

data/lib/bin/build_env.sh

@@ -1,6 +1,28 @@
 #!/bin/bash
 
-# Detect the platform (only GitHub Actions in this case)
+# Parse an "owner/repo" slug out of a git remote URL (SSH or HTTPS) that points
+# at github.com. Emits an empty string when the URL is not a github.com URL.
+parse_github_slug() {
+  local url="$1"
+  case "$url" in
+    git@github.com:*|git://github.com/*|https://github.com/*|http://github.com/*|ssh://git@github.com/*)
+      echo "$url" | sed -E 's#^(git@|(git|https?|ssh)://(git@)?)github\.com[:/]##; s#\.git/?$##'
+      ;;
+  esac
+}
+
+# Given a git remote URL, classify the provider as github|gitlab|bitbucket or
+# empty when unrecognized. Used for the git_provider hint.
+detect_git_provider_from_url() {
+  local url="$1"
+  case "$url" in
+    *github.com*)    echo "github" ;;
+    *gitlab.com*)    echo "gitlab" ;;
+    *bitbucket.org*) echo "bitbucket" ;;
+  esac
+}
+
+# Detect the platform
 if [ -n "$GITHUB_ACTIONS" ]; then
   platform=github_actions
   branch=${GITHUB_HEAD_REF:-$GITHUB_REF_NAME}
@@ -13,6 +35,24 @@ if [ -n "$GITHUB_ACTIONS" ]; then
   commit_message=$(git log --format=%s -n 1 $sha)
   committer_name=$(git show -s --format='%an' -n 1 $sha)
   committer_email=$(git show -s --format='%ae' -n 1 $sha)
+  git_repo_full_name=$GITHUB_REPOSITORY
+  git_provider=github
+  # Extract base_sha from the webhook event payload GitHub drops at
+  # $GITHUB_EVENT_PATH. Prefer jq when available (handles both push and PR
+  # events); fall back to a grep-based parse for the top-level "before" field
+  # on push events when jq is missing.
+  if [ -f "$GITHUB_EVENT_PATH" ]; then
+    if command -v jq >/dev/null 2>&1; then
+      base_sha=$(jq -r '.pull_request.base.sha // .before // empty' < "$GITHUB_EVENT_PATH" 2>/dev/null)
+    else
+      base_sha=$(grep -o '"before"[[:space:]]*:[[:space:]]*"[^"]*"' "$GITHUB_EVENT_PATH" | head -1 | sed -E 's/.*"[^"]*"[[:space:]]*:[[:space:]]*"([^"]*)".*/\1/')
+    fi
+    # GitHub emits all-zero SHAs when the ref was just created and has no prior
+    # state. Treat that as "no base" so the server falls through to head-only.
+    if [ "$base_sha" = "0000000000000000000000000000000000000000" ]; then
+      base_sha=""
+    fi
+  fi
 elif [ -n "$CIRCLECI" ]; then
   platform=circleci
   branch=$CIRCLE_BRANCH
@@ -23,6 +63,19 @@ elif [ -n "$CIRCLECI" ]; then
   commit_message=$(git log --format=%s -n 1 $sha)
   committer_name=$(git show -s --format='%an' -n 1 $sha)
   committer_email=$(git show -s --format='%ae' -n 1 $sha)
+  # CircleCI has no single "slug" env var. Compose from username + reponame.
+  # These work for both GitHub OAuth and GitHub App pipelines. For non-GitHub
+  # pipelines (GitLab, Bitbucket) the same vars exist but we gate on the repo
+  # URL to avoid emitting a non-GitHub slug.
+  if [ -n "$CIRCLE_PROJECT_USERNAME" ] && [ -n "$CIRCLE_PROJECT_REPONAME" ]; then
+    git_provider=$(detect_git_provider_from_url "$CIRCLE_REPOSITORY_URL")
+    if [ "$git_provider" = "github" ] || [ -z "$CIRCLE_REPOSITORY_URL" ]; then
+      git_repo_full_name="${CIRCLE_PROJECT_USERNAME}/${CIRCLE_PROJECT_REPONAME}"
+      # If we fell through the "no repo URL" path, default provider to github
+      # since the slug composition path is specific to GitHub-style owner/repo.
+      [ -z "$git_provider" ] && git_provider=github
+    fi
+  fi
 elif [ -n "$SEMAPHORE" ]; then
   platform=semaphore
   branch=${SEMAPHORE_GIT_PR_BRANCH:-$SEMAPHORE_GIT_BRANCH}
@@ -38,6 +91,35 @@ elif [ -n "$SEMAPHORE" ]; then
   commit_message=$(git log --format=%s -n 1 $sha)
   committer_name=$(git show -s --format='%an' -n 1 $sha)
   committer_email=$(git show -s --format='%ae' -n 1 $sha)
+  git_provider=$SEMAPHORE_GIT_PROVIDER
+  if [ "$git_provider" = "github" ]; then
+    git_repo_full_name=$SEMAPHORE_GIT_REPO_SLUG
+  fi
+  # SEMAPHORE_GIT_COMMIT_RANGE is "<base>...<head>" on push/PR events; take the
+  # left side. It is unset when the build isn't commit-scoped.
+  if [ -n "$SEMAPHORE_GIT_COMMIT_RANGE" ]; then
+    base_sha=$(echo "$SEMAPHORE_GIT_COMMIT_RANGE" | sed -E 's/\.\.\..*//')
+  fi
+elif [ -n "$BUILDKITE" ]; then
+  platform=buildkite
+  branch=$BUILDKITE_BRANCH
+  target_branch=$BUILDKITE_PULL_REQUEST_BASE_BRANCH
+  actor=$BUILDKITE_BUILD_AUTHOR
+  sha=$BUILDKITE_COMMIT
+  run_id=$BUILDKITE_BUILD_ID
+  run_attempt=$BUILDKITE_RETRY_COUNT
+  runner_id=$BUILDKITE_PARALLEL_JOB
+  pr_title=$BUILDKITE_PULL_REQUEST_TITLE
+  commit_message=$BUILDKITE_MESSAGE
+  committer_name=$BUILDKITE_BUILD_AUTHOR
+  committer_email=$BUILDKITE_BUILD_AUTHOR_EMAIL
+  # Buildkite tells us the provider explicitly, and BUILDKITE_REPO is the URL.
+  if [ "$BUILDKITE_PIPELINE_PROVIDER" = "github" ]; then
+    git_provider=github
+    git_repo_full_name=$(parse_github_slug "$BUILDKITE_REPO")
+  else
+    git_provider=$BUILDKITE_PIPELINE_PROVIDER
+  fi
 elif [ -n "$RWX" ]; then
   platform=rwx
   branch="${RWX_GIT_REF_NAME}"
@@ -52,6 +134,13 @@ elif [ -n "$RWX" ]; then
   commit_message="${RWX_GIT_COMMIT_SUMMARY}"
   committer_name="${RWX_GIT_COMMITTER_NAME}"
   committer_email="${RWX_GIT_COMMITTER_EMAIL}"
+  # RWX_GIT_REPOSITORY_NAME is extracted by the git/clone package from whatever
+  # URL was cloned. For non-GitHub hosts this still looks like "owner/repo" but
+  # points elsewhere, so cross-check the URL host before trusting it.
+  git_provider=$(detect_git_provider_from_url "$RWX_GIT_REPOSITORY_URL")
+  if [ "$git_provider" = "github" ]; then
+    git_repo_full_name="${RWX_GIT_REPOSITORY_NAME}"
+  fi
 elif [ -n "$MINT" ]; then
   platform=rwx
   branch="${MINT_GIT_REF_NAME}"
@@ -66,6 +155,27 @@ elif [ -n "$MINT" ]; then
   commit_message="${MINT_GIT_COMMIT_SUMMARY}"
   committer_name="${MINT_GIT_COMMITTER_NAME}"
   committer_email="${MINT_GIT_COMMITTER_EMAIL}"
+  git_provider=$(detect_git_provider_from_url "$MINT_GIT_REPOSITORY_URL")
+  if [ "$git_provider" = "github" ]; then
+    git_repo_full_name="${MINT_GIT_REPOSITORY_NAME}"
+  fi
+fi
+
+# Final fallbacks when we haven't resolved the GitHub slug from a known CI
+# platform. Order:
+#   1. Explicit SELECTIVE_GIT_REPO override (always wins; see below).
+#   2. git config --get remote.origin.url on a local checkout.
+if [ -z "$git_repo_full_name" ] && command -v git >/dev/null 2>&1; then
+  origin_url=$(git config --get remote.origin.url 2>/dev/null || true)
+  if [ -n "$origin_url" ]; then
+    parsed_slug=$(parse_github_slug "$origin_url")
+    if [ -n "$parsed_slug" ]; then
+      git_repo_full_name="$parsed_slug"
+      [ -z "$git_provider" ] && git_provider=github
+    elif [ -z "$git_provider" ]; then
+      git_provider=$(detect_git_provider_from_url "$origin_url")
+    fi
+  fi
 fi
 
 function escape() {
@@ -83,11 +193,14 @@ cat <<EOF
     "target_branch": "$(escape "${SELECTIVE_TARGET_BRANCH:-$target_branch}")",
     "actor": "$(escape "${SELECTIVE_ACTOR:-$actor}")",
     "sha": "$(escape "${SELECTIVE_SHA:-$sha}")",
+    "base_sha": "$(escape "${SELECTIVE_BASE_SHA:-$base_sha}")",
     "run_id": "$(escape "${SELECTIVE_RUN_ID:-$run_id}")",
     "run_attempt": "$(escape "${SELECTIVE_RUN_ATTEMPT:-$run_attempt}")",
     "runner_id": "$(escape "${SELECTIVE_RUNNER_ID:-$runner_id}")",
     "commit_message": "$(escape "${SELECTIVE_COMMIT_MESSAGE:-$commit_message}")",
     "committer_name": "$(escape "${SELECTIVE_COMMITTER_NAME:-$committer_name}")",
-    "committer_email": "$(escape "${SELECTIVE_COMMITTER_EMAIL:-$committer_email}")"
+    "committer_email": "$(escape "${SELECTIVE_COMMITTER_EMAIL:-$committer_email}")",
+    "git_repo_full_name": "$(escape "${SELECTIVE_GIT_REPO:-$git_repo_full_name}")",
+    "git_provider": "$(escape "${SELECTIVE_GIT_PROVIDER:-$git_provider}")"
   }
 EOF