datadog-ci 1.36.1 → 1.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70fc5fea2d200dd9654e43d303bc20ca67937ee3d6fdc03ff5595d5c22991424
-  data.tar.gz: 0ad11c672983e445ef7baed4fcf15af2c4710871b90962076f3075b572383ca7
+  metadata.gz: 2a4aa364e13169f17cd0c37cc4dff152b1f8861895569d7d5bdf0a9398d2415f
+  data.tar.gz: 900cc26e588995ffe4dde4c32a42aee348593adf521a498d82d138233595861b
 SHA512:
-  metadata.gz: c0df4d0e21c6bab928409176b1eee9b401532eac85b9522623c88dd89f54e4a75cb64c3c528cc508357cc77642e3c7e042bc6459edffea8423ef94d48dd6ee4d
-  data.tar.gz: '07888f1e31d079859c4e3bcfde608dc6c5c56028857f5c4feb58cbdacac4ab7be6a9865076174cf27cc7d6f9d1868e3f4a7cc6a1e014cd74c34982e335151b55'
+  metadata.gz: f9a3e6033dd78d3570da5184f1e220abdf7c3aeb7a9ed76cd1ff25440d906ea0f2a20670930270677c4e17826e6a7283ad411a71cdd446c01b16340dc5c86cce
+  data.tar.gz: 5e5eb24079c51dc28c78a22c07e185e6501917ef9dcb448b812cb76dc5243efe84fbe132042b1049bfc626c93ae057e8db954cad48c9f8a40e93dafdddfb3daf

data/CHANGELOG.md

@@ -1,5 +1,7 @@
 ## [Unreleased]
 
+## [1.37.0] - 2026-08-19
+
 ## [1.36.1] - 2026-08-11
 
 ### Fixed
@@ -682,7 +684,8 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 
 - Ruby versions < 2.7 no longer supported ([#8][])
 
-[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.36.1...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.37.0...main
+[1.37.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.36.1...v1.37.0
 [1.36.1]: https://github.com/DataDog/datadog-ci-rb/compare/v1.36.0...v1.36.1
 [1.36.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.35.0...v1.36.0
 [1.35.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.34.0...v1.35.0

data/ext/datadog_ci_native/ci.c

@@ -1,11 +1,15 @@
 #include "datadog_cov.h"
 #include "datadog_method_inspect.h"
+#include "file_serialization.h"
 #include "iseq_collector.h"
 
 void Init_datadog_ci_native(void) {
   // Coverage::DDCov
   Init_datadog_cov();
 
+  // FileSerialization
+  Init_file_serialization();
+
   // SourceCode
   Init_datadog_method_inspect();
   Init_dd_ci_iseq_collector();

data/ext/datadog_ci_native/datadog_common.c

@@ -2,14 +2,25 @@
 #include <ruby.h>
 #include <string.h>
 
-bool dd_ci_is_path_included(const char *path, const char *root_path,
-                            long root_path_len, const char *ignored_path,
-                            long ignored_path_len) {
-  if (strncmp(root_path, path, root_path_len) != 0) {
+static bool has_directory_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;
   }
-  if (ignored_path_len > 0 &&
-      strncmp(ignored_path, path, ignored_path_len) == 0) {
+
+  return prefix_len == path_len || prefix[prefix_len - 1] == '/' ||
+         path[prefix_len] == '/';
+}
+
+bool dd_ci_is_path_included(const char *path, long path_len,
+                            const char *root_path, long root_path_len,
+                            const char *ignored_path, long ignored_path_len) {
+  if (!has_directory_prefix(path, path_len, root_path, root_path_len)) {
+    return false;
+  }
+  if (ignored_path_len > 0 && has_directory_prefix(
+                                  path, path_len, ignored_path,
+                                  ignored_path_len)) {
     return false;
   }
   return true;

data/ext/datadog_ci_native/datadog_common.h

@@ -11,14 +11,15 @@
  * Returns true if the path should be included, false otherwise.
  *
  * @param path          The file path to check
+ * @param path_len      Length of path
  * @param root_path     The root path prefix (required)
  * @param root_path_len Length of root_path
  * @param ignored_path  Path prefix to exclude (can be NULL)
  * @param ignored_path_len Length of ignored_path (0 if not set)
  */
-bool dd_ci_is_path_included(const char *path, const char *root_path,
-                            long root_path_len, const char *ignored_path,
-                            long ignored_path_len);
+bool dd_ci_is_path_included(const char *path, long path_len,
+                            const char *root_path, long root_path_len,
+                            const char *ignored_path, long ignored_path_len);
 
 /* ---- Utility functions -------------------------------------------------- */
 

data/ext/datadog_ci_native/datadog_cov.c

@@ -3,6 +3,7 @@
 #include <ruby/st.h>
 
 #include <stdbool.h>
+#include <string.h>
 
 #include "datadog_common.h"
 
@@ -11,12 +12,26 @@
 // running only the tests that are affected by the changes.
 
 #define PROFILE_FRAMES_BUFFER_SIZE 1
+#define SEEN_FILENAME_CACHE_SIZE 1024
+#define SEEN_ALLOCATED_CLASS_CACHE_SIZE 4096
+#define KLASS_FILES_CACHE_SIZE 100000
+
+#if SEEN_FILENAME_CACHE_SIZE == 0 ||                                       \
+    (SEEN_FILENAME_CACHE_SIZE & (SEEN_FILENAME_CACHE_SIZE - 1)) != 0
+#error "SEEN_FILENAME_CACHE_SIZE must be a power of two"
+#endif
+
+#if SEEN_ALLOCATED_CLASS_CACHE_SIZE == 0 ||                               \
+    (SEEN_ALLOCATED_CLASS_CACHE_SIZE &                                   \
+     (SEEN_ALLOCATED_CLASS_CACHE_SIZE - 1)) != 0
+#error "SEEN_ALLOCATED_CLASS_CACHE_SIZE must be a power of two"
+#endif
 
 // threading modes
 enum threading_mode { single, multi };
 
 // functions declarations
-static void on_newobj_event(VALUE tracepoint_data, void *data);
+static void on_newobj_event(VALUE self, const rb_trace_arg_t *tracearg);
 
 static int mark_key_for_gc_i(st_data_t key, st_data_t _value, st_data_t _data) {
   VALUE klass = (VALUE)key;
@@ -25,6 +40,15 @@ static int mark_key_for_gc_i(st_data_t key, st_data_t _value, st_data_t _data) {
   return ST_CONTINUE;
 }
 
+static int mark_klass_files_for_gc_i(st_data_t key, st_data_t value,
+                                     st_data_t _data) {
+  // Both the class key and its cached filenames must remain at stable addresses
+  // because they are stored outside Ruby's object containers.
+  rb_gc_mark((VALUE)key);
+  rb_gc_mark((VALUE)value);
+  return ST_CONTINUE;
+}
+
 // Data structure
 struct dd_cov_data {
   // Ruby hash with filenames impacted by the test.
@@ -40,9 +64,12 @@ struct dd_cov_data {
   char *ignored_path;
   long ignored_path_len;
 
-  // Line tracepoint optimisation: cache last seen filename pointer to avoid
-  // unnecessary string comparison if we stay in the same file.
-  uintptr_t last_filename_ptr;
+  // Line tracepoint optimisation: make consecutive events from the same file a
+  // single comparison, then use a direct-mapped cache for later revisits. Keep
+  // the Ruby strings alive so their pointers cannot be reused for other paths.
+  // A collision only repeats path processing; it can never suppress coverage.
+  VALUE last_filename;
+  VALUE seen_filenames[SEEN_FILENAME_CACHE_SIZE];
 
   // Line tracepoint can work in two modes: single threaded and multi threaded
   //
@@ -61,22 +88,38 @@ struct dd_cov_data {
   // contain any methods that could be covered by line tracepoint.
   //
   // Allocation tracing works only in multi threaded mode.
-  VALUE object_allocation_tracepoint;
+  bool allocation_tracing_enabled;
+  bool allocation_hook_active;
   st_table *klasses_table; // { (VALUE) -> int } hashmap with class names that
                            // were covered by allocation during the test run
+  VALUE last_allocated_klass;
+  VALUE seen_allocated_klasses[SEEN_ALLOCATED_CLASS_CACHE_SIZE];
+  st_table *klass_files_cache; // { (VALUE) -> Array<String> } resolved files
+  size_t klass_files_cache_size;
 };
 
 static void dd_cov_mark(void *ptr) {
   struct dd_cov_data *dd_cov_data = ptr;
   rb_gc_mark_movable(dd_cov_data->impacted_files);
   rb_gc_mark_movable(dd_cov_data->th_covered);
-  rb_gc_mark_movable(dd_cov_data->object_allocation_tracepoint);
+
+  if (dd_cov_data->last_filename != Qnil) {
+    rb_gc_mark(dd_cov_data->last_filename);
+  }
+  for (size_t i = 0; i < SEEN_FILENAME_CACHE_SIZE; i++) {
+    if (dd_cov_data->seen_filenames[i] != Qnil) {
+      rb_gc_mark(dd_cov_data->seen_filenames[i]);
+    }
+  }
 
   // if GC starts withing dd_cov_allocate() call, klasses_table might not be
   // initialized yet
   if (dd_cov_data->klasses_table != NULL) {
     st_foreach(dd_cov_data->klasses_table, mark_key_for_gc_i, 0);
   }
+  if (dd_cov_data->klass_files_cache != NULL) {
+    st_foreach(dd_cov_data->klass_files_cache, mark_klass_files_for_gc_i, 0);
+  }
 }
 
 static void dd_cov_free(void *ptr) {
@@ -84,6 +127,7 @@ static void dd_cov_free(void *ptr) {
   xfree(dd_cov_data->root);
   xfree(dd_cov_data->ignored_path);
   st_free_table(dd_cov_data->klasses_table);
+  st_free_table(dd_cov_data->klass_files_cache);
   xfree(dd_cov_data);
 }
 
@@ -91,8 +135,6 @@ static void dd_cov_compact(void *ptr) {
   struct dd_cov_data *dd_cov_data = ptr;
   dd_cov_data->impacted_files = rb_gc_location(dd_cov_data->impacted_files);
   dd_cov_data->th_covered = rb_gc_location(dd_cov_data->th_covered);
-  dd_cov_data->object_allocation_tracepoint =
-      rb_gc_location(dd_cov_data->object_allocation_tracepoint);
   // keys for dd_cov_data->klasses_table are not moved by GC, so we don't need
   // to update them
 }
@@ -115,12 +157,21 @@ static VALUE dd_cov_allocate(VALUE klass) {
   dd_cov_data->root_len = 0;
   dd_cov_data->ignored_path = NULL;
   dd_cov_data->ignored_path_len = 0;
-  dd_cov_data->last_filename_ptr = 0;
+  dd_cov_data->last_filename = Qnil;
+  for (size_t i = 0; i < SEEN_FILENAME_CACHE_SIZE; i++) {
+    dd_cov_data->seen_filenames[i] = Qnil;
+  }
   dd_cov_data->threading_mode = multi;
 
-  dd_cov_data->object_allocation_tracepoint = Qnil;
+  dd_cov_data->allocation_tracing_enabled = false;
+  dd_cov_data->allocation_hook_active = false;
+  dd_cov_data->last_allocated_klass = Qnil;
+  memset(dd_cov_data->seen_allocated_klasses, 0,
+         sizeof(dd_cov_data->seen_allocated_klasses));
   // numtable type is needed to store VALUE as a key
   dd_cov_data->klasses_table = st_init_numtable();
+  dd_cov_data->klass_files_cache = st_init_numtable();
+  dd_cov_data->klass_files_cache_size = 0;
 
   return dd_cov;
 }
@@ -131,8 +182,9 @@ static VALUE dd_cov_allocate(VALUE klass) {
 // not in the ignored folder) and adds it to the impacted_files hash.
 static bool record_impacted_file(struct dd_cov_data *dd_cov_data,
                                  VALUE filename) {
-  if (!dd_ci_is_path_included(RSTRING_PTR(filename), dd_cov_data->root,
-                              dd_cov_data->root_len, dd_cov_data->ignored_path,
+  if (!dd_ci_is_path_included(RSTRING_PTR(filename), RSTRING_LEN(filename),
+                              dd_cov_data->root, dd_cov_data->root_len,
+                              dd_cov_data->ignored_path,
                               dd_cov_data->ignored_path_len)) {
     return false;
   }
@@ -145,18 +197,29 @@ static bool record_impacted_file(struct dd_cov_data *dd_cov_data,
 // rb_profile_frames.
 static void on_line_event(rb_event_flag_t event, VALUE data, VALUE self, ID id,
                           VALUE klass) {
-  struct dd_cov_data *dd_cov_data;
-  TypedData_Get_Struct(data, struct dd_cov_data, &dd_cov_data_type,
-                       dd_cov_data);
+  // The hook is registered only with DDCov instances, so the full typed-data
+  // type check on every Ruby line is unnecessary.
+  struct dd_cov_data *dd_cov_data = RTYPEDDATA_DATA(data);
 
   const char *c_filename = rb_sourcefile();
+  if (c_filename == NULL) {
+    return;
+  }
 
-  // skip if we cover the same file again
   uintptr_t current_filename_ptr = (uintptr_t)c_filename;
-  if (dd_cov_data->last_filename_ptr == current_filename_ptr) {
+  if (dd_cov_data->last_filename != Qnil &&
+      RSTRING_PTR(dd_cov_data->last_filename) == c_filename) {
+    return;
+  }
+
+  size_t cache_index =
+      ((current_filename_ptr >> 4) ^ (current_filename_ptr >> 12)) &
+      (SEEN_FILENAME_CACHE_SIZE - 1);
+  VALUE cached_filename = dd_cov_data->seen_filenames[cache_index];
+  if (cached_filename != Qnil && RSTRING_PTR(cached_filename) == c_filename) {
+    dd_cov_data->last_filename = cached_filename;
     return;
   }
-  dd_cov_data->last_filename_ptr = current_filename_ptr;
 
   VALUE top_frame;
   int captured_frames =
@@ -172,6 +235,8 @@ static void on_line_event(rb_event_flag_t event, VALUE data, VALUE self, ID id,
     return;
   }
 
+  dd_cov_data->last_filename = filename;
+  dd_cov_data->seen_filenames[cache_index] = filename;
   record_impacted_file(dd_cov_data, filename);
 }
 
@@ -185,21 +250,6 @@ static VALUE safely_get_mod_ancestors(VALUE klass) {
   return dd_ci_rescue_nil(rb_mod_ancestors, klass);
 }
 
-static bool record_impacted_klass(struct dd_cov_data *dd_cov_data,
-                                  VALUE klass) {
-  VALUE klass_name = safely_get_class_name(klass);
-  if (klass_name == Qnil) {
-    return false;
-  }
-
-  VALUE filename = dd_ci_resolve_const_to_file(klass_name);
-  if (filename == Qnil) {
-    return false;
-  }
-
-  return record_impacted_file(dd_cov_data, filename);
-}
-
 // This function is called for each class that was instantiated during the test
 // run.
 static int each_instantiated_klass(st_data_t key, st_data_t _value,
@@ -207,6 +257,18 @@ static int each_instantiated_klass(st_data_t key, st_data_t _value,
   VALUE klass = (VALUE)key;
   struct dd_cov_data *dd_cov_data = (struct dd_cov_data *)data;
 
+  st_data_t cached_files;
+  if (st_lookup(dd_cov_data->klass_files_cache, key, &cached_files)) {
+    VALUE files = (VALUE)cached_files;
+    long files_len = RARRAY_LEN(files);
+    for (long i = 0; i < files_len; i++) {
+      rb_hash_aset(dd_cov_data->impacted_files, rb_ary_entry(files, i), Qtrue);
+    }
+    return ST_CONTINUE;
+  }
+
+  VALUE files = rb_ary_new();
+
   // rb_mod_ancestors returns an array containing the "klass" itself
   // and all the parent classes and/or included/prepended modules
   VALUE ancestors = safely_get_mod_ancestors(klass);
@@ -221,17 +283,36 @@ static int each_instantiated_klass(st_data_t key, st_data_t _value,
       continue;
     }
 
-    record_impacted_klass(dd_cov_data, mod);
+    VALUE klass_name = safely_get_class_name(mod);
+    if (klass_name == Qnil) {
+      continue;
+    }
+
+    VALUE filename = dd_ci_resolve_const_to_file(klass_name);
+    if (filename == Qnil || !record_impacted_file(dd_cov_data, filename)) {
+      continue;
+    }
+
+    rb_ary_push(files, filename);
   }
 
+  rb_obj_freeze(files);
+  // Bound cross-test retention without adding eviction work to cache hits.
+  // Reaching the limit starts a fresh cache generation.
+  if (dd_cov_data->klass_files_cache_size >= KLASS_FILES_CACHE_SIZE) {
+    st_clear(dd_cov_data->klass_files_cache);
+    dd_cov_data->klass_files_cache_size = 0;
+  }
+  st_insert(dd_cov_data->klass_files_cache, key, (st_data_t)files);
+  dd_cov_data->klass_files_cache_size++;
+
   return ST_CONTINUE;
 }
 
 // Executed on RUBY_INTERNAL_EVENT_NEWOBJ event and captures the source file for
 // the allocated object's class.
-static void on_newobj_event(VALUE tracepoint_data, void *data) {
-  rb_trace_arg_t *tracearg = rb_tracearg_from_tracepoint(tracepoint_data);
-  VALUE new_object = rb_tracearg_object(tracearg);
+static void on_newobj_event(VALUE self, const rb_trace_arg_t *tracearg) {
+  VALUE new_object = rb_tracearg_object((rb_trace_arg_t *)tracearg);
 
   // To keep things fast and practical, we only care about objects that extend
   // either Object or Struct.
@@ -244,20 +325,41 @@ static void on_newobj_event(VALUE tracepoint_data, void *data) {
   if (klass == Qnil || klass == 0) {
     return;
   }
-  // Skip anonymous classes starting with "#<Class".
-  // it allows us to skip the source location lookup that will always fail
-  //
-  // rb_mod_name returns nil for anonymous classes
-  if (rb_mod_name(klass) == Qnil) {
+
+  struct dd_cov_data *dd_cov_data = RTYPEDDATA_DATA(self);
+
+  if (dd_cov_data->last_allocated_klass == klass) {
     return;
   }
 
-  struct dd_cov_data *dd_cov_data = (struct dd_cov_data *)data;
+  uintptr_t klass_ptr = (uintptr_t)klass;
+  size_t cache_index =
+      ((klass_ptr >> 4) ^ (klass_ptr >> 12)) &
+      (SEEN_ALLOCATED_CLASS_CACHE_SIZE - 1);
+  if (dd_cov_data->seen_allocated_klasses[cache_index] == klass) {
+    dd_cov_data->last_allocated_klass = klass;
+    return;
+  }
+
+  // A direct-cache collision must not make us repeat name resolution or table
+  // insertion for a class that this test already observed.
+  if (st_is_member(dd_cov_data->klasses_table, (st_data_t)klass)) {
+    dd_cov_data->last_allocated_klass = klass;
+    dd_cov_data->seen_allocated_klasses[cache_index] = klass;
+    return;
+  }
+
+  // rb_mod_name returns nil for anonymous classes and is safe during NEWOBJ.
+  if (rb_mod_name(klass) == Qnil) {
+    return;
+  }
 
   // We use VALUE directly as a key for the hashmap
   // Ruby itself does it too:
   // https://github.com/ruby/ruby/blob/94b87084a689a3bc732dcaee744508a708223d6c/ext/objspace/object_tracing.c#L113
   st_insert(dd_cov_data->klasses_table, (st_data_t)klass, 1);
+  dd_cov_data->last_allocated_klass = klass;
+  dd_cov_data->seen_allocated_klasses[cache_index] = klass;
 }
 
 // DDCov instance methods available in Ruby
@@ -265,12 +367,22 @@ static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self) {
   VALUE opt;
 
   rb_scan_args(argc, argv, "10", &opt);
+  Check_Type(opt, T_HASH);
+
   VALUE rb_root = rb_hash_lookup(opt, ID2SYM(rb_intern("root")));
   if (!RTEST(rb_root)) {
     rb_raise(rb_eArgError, "root is required");
   }
+  Check_Type(rb_root, T_STRING);
+  const char *root = StringValueCStr(rb_root);
+
   VALUE rb_ignored_path =
       rb_hash_lookup(opt, ID2SYM(rb_intern("ignored_path")));
+  const char *ignored_path = NULL;
+  if (RTEST(rb_ignored_path)) {
+    Check_Type(rb_ignored_path, T_STRING);
+    ignored_path = StringValueCStr(rb_ignored_path);
+  }
 
   VALUE rb_threading_mode =
       rb_hash_lookup(opt, ID2SYM(rb_intern("threading_mode")));
@@ -296,18 +408,16 @@ static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self) {
 
   dd_cov_data->threading_mode = threading_mode;
   dd_cov_data->root_len = RSTRING_LEN(rb_root);
-  dd_cov_data->root =
-      dd_ci_ruby_strndup(RSTRING_PTR(rb_root), dd_cov_data->root_len);
+  dd_cov_data->root = dd_ci_ruby_strndup(root, dd_cov_data->root_len);
 
   if (RTEST(rb_ignored_path)) {
     dd_cov_data->ignored_path_len = RSTRING_LEN(rb_ignored_path);
     dd_cov_data->ignored_path = dd_ci_ruby_strndup(
-        RSTRING_PTR(rb_ignored_path), dd_cov_data->ignored_path_len);
+        ignored_path, dd_cov_data->ignored_path_len);
   }
 
   if (rb_allocation_tracing_enabled == Qtrue) {
-    dd_cov_data->object_allocation_tracepoint = rb_tracepoint_new(
-        Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, on_newobj_event, (void *)dd_cov_data);
+    dd_cov_data->allocation_tracing_enabled = true;
   }
 
   return Qnil;
@@ -332,9 +442,18 @@ static VALUE dd_cov_start(VALUE self) {
     rb_add_event_hook(on_line_event, RUBY_EVENT_LINE, self);
   }
 
-  // add object allocation tracepoint
-  if (dd_cov_data->object_allocation_tracepoint != Qnil) {
-    rb_tracepoint_enable(dd_cov_data->object_allocation_tracepoint);
+  // Register the raw hook that TracePoint would wrap and dispatch directly to
+  // the allocation callback. NEWOBJ permits no general Ruby API; the callback
+  // is limited to the existing event-safe accessors plus rb_mod_name, which is
+  // explicitly safe here. Each collector owns its hook, preserving concurrent
+  // collector behavior.
+  if (dd_cov_data->allocation_tracing_enabled &&
+      !dd_cov_data->allocation_hook_active) {
+    rb_add_event_hook2((rb_event_hook_func_t)on_newobj_event,
+                       RUBY_INTERNAL_EVENT_NEWOBJ, self,
+                       RUBY_EVENT_HOOK_FLAG_SAFE |
+                           RUBY_EVENT_HOOK_FLAG_RAW_ARG);
+    dd_cov_data->allocation_hook_active = true;
   }
 
   return self;
@@ -360,20 +479,28 @@ static VALUE dd_cov_stop(VALUE self) {
     rb_remove_event_hook(on_line_event);
   }
 
-  // stop object allocation tracepoint
-  if (dd_cov_data->object_allocation_tracepoint != Qnil) {
-    rb_tracepoint_disable(dd_cov_data->object_allocation_tracepoint);
+  // Remove only this collector's hook; other concurrently active collectors
+  // continue to receive allocation events.
+  if (dd_cov_data->allocation_hook_active) {
+    rb_remove_event_hook_with_data((rb_event_hook_func_t)on_newobj_event, self);
+    dd_cov_data->allocation_hook_active = false;
   }
 
   // process classes covered by allocation tracing
   st_foreach(dd_cov_data->klasses_table, each_instantiated_klass,
              (st_data_t)dd_cov_data);
+  dd_cov_data->last_allocated_klass = Qnil;
+  memset(dd_cov_data->seen_allocated_klasses, 0,
+         sizeof(dd_cov_data->seen_allocated_klasses));
   st_clear(dd_cov_data->klasses_table);
 
   VALUE res = dd_cov_data->impacted_files;
 
   dd_cov_data->impacted_files = rb_hash_new();
-  dd_cov_data->last_filename_ptr = 0;
+  dd_cov_data->last_filename = Qnil;
+  for (size_t i = 0; i < SEEN_FILENAME_CACHE_SIZE; i++) {
+    dd_cov_data->seen_filenames[i] = Qnil;
+  }
 
   return res;
 }

data/ext/datadog_ci_native/file_serialization.c

@@ -0,0 +1,279 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/st.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "file_serialization.h"
+
+// Bulk file serialization is independent from coverage collection. It packs
+// large file lists without building normalized intermediate Ruby collections.
+
+struct packed_files_context {
+  VALUE root;
+  VALUE seen;
+  VALUE packed;
+  long root_len;
+  uint32_t files_count;
+  bool direct_absolute;
+  bool fast_path_supported;
+};
+
+static bool string_bytes_are_ascii(VALUE string) {
+  const unsigned char *ptr = (const unsigned char *)RSTRING_PTR(string);
+  long len = RSTRING_LEN(string);
+  for (long i = 0; i < len; i++) {
+    if ((ptr[i] & 0x80U) != 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+static void packed_files_append_u16(VALUE packed, uint16_t value) {
+  unsigned char bytes[2] = {(unsigned char)(value >> 8),
+                            (unsigned char)value};
+  rb_str_cat(packed, (const char *)bytes, 2);
+}
+
+static void packed_files_append_u32(VALUE packed, uint32_t value) {
+  unsigned char bytes[4] = {
+      (unsigned char)(value >> 24), (unsigned char)(value >> 16),
+      (unsigned char)(value >> 8), (unsigned char)value};
+  rb_str_cat(packed, (const char *)bytes, 4);
+}
+
+static void packed_files_append_string_header(VALUE packed, uint32_t len,
+                                              bool binary) {
+  unsigned char byte;
+  if (binary) {
+    if (len < 256) {
+      byte = 0xc4;
+      rb_str_cat(packed, (const char *)&byte, 1);
+      byte = (unsigned char)len;
+      rb_str_cat(packed, (const char *)&byte, 1);
+    } else if (len < 65536) {
+      byte = 0xc5;
+      rb_str_cat(packed, (const char *)&byte, 1);
+      packed_files_append_u16(packed, (uint16_t)len);
+    } else {
+      byte = 0xc6;
+      rb_str_cat(packed, (const char *)&byte, 1);
+      packed_files_append_u32(packed, len);
+    }
+  } else if (len < 32) {
+    byte = (unsigned char)(0xa0U | len);
+    rb_str_cat(packed, (const char *)&byte, 1);
+  } else if (len < 256) {
+    byte = 0xd9;
+    rb_str_cat(packed, (const char *)&byte, 1);
+    byte = (unsigned char)len;
+    rb_str_cat(packed, (const char *)&byte, 1);
+  } else if (len < 65536) {
+    byte = 0xda;
+    rb_str_cat(packed, (const char *)&byte, 1);
+    packed_files_append_u16(packed, (uint16_t)len);
+  } else {
+    byte = 0xdb;
+    rb_str_cat(packed, (const char *)&byte, 1);
+    packed_files_append_u32(packed, len);
+  }
+}
+
+static bool packed_files_append_entry(struct packed_files_context *context,
+                                      VALUE file, bool additional_file) {
+  if (file == Qnil && !additional_file) {
+    return true;
+  }
+  if (!RB_TYPE_P(file, T_STRING) || rb_obj_class(file) != rb_cString) {
+    context->fast_path_supported = false;
+    return false;
+  }
+
+  VALUE relative_file = file;
+  VALUE dedup_file = file;
+  long relative_len = RSTRING_LEN(file);
+  long relative_offset = 0;
+  const char *file_ptr = RSTRING_PTR(file);
+  long file_len = RSTRING_LEN(file);
+  if (memchr(file_ptr, '\0', (size_t)file_len) != NULL) {
+    context->fast_path_supported = false;
+    return false;
+  }
+  bool absolute = file_len > 0 && file_ptr[0] == '/';
+  if (absolute) {
+    if (file_len <= context->root_len ||
+        memcmp(file_ptr, RSTRING_PTR(context->root),
+               (size_t)context->root_len) != 0 ||
+        file_ptr[context->root_len] != '/') {
+      // Absolute additional files outside the immutable repository root are
+      // ignored. Primary files are already filtered by the same root.
+      return true;
+    }
+
+    relative_len = file_len - context->root_len - 1;
+    if (relative_len == 0) {
+      return true;
+    }
+    if (context->direct_absolute) {
+      relative_offset = context->root_len + 1;
+    } else {
+      relative_file = rb_str_substr(file, context->root_len + 1, file_len);
+      dedup_file = relative_file;
+    }
+  } else if (!additional_file) {
+    // Relative primary paths depend on cwd-to-root Pathname semantics. They
+    // are uncommon and retain the authoritative Ruby fallback.
+    context->fast_path_supported = false;
+    return false;
+  }
+
+  if (relative_len == 0) {
+    return true;
+  }
+  if (rb_hash_lookup2(context->seen, dedup_file, Qundef) != Qundef) {
+    return true;
+  }
+  rb_hash_aset(context->seen, dedup_file, Qtrue);
+
+  int encoding_index = rb_enc_get_index(relative_file);
+  bool binary = encoding_index == rb_ascii8bit_encindex();
+  if (!binary && encoding_index != rb_utf8_encindex() &&
+      encoding_index != rb_usascii_encindex() &&
+      (!rb_enc_str_asciicompat_p(relative_file) ||
+       !string_bytes_are_ascii(relative_file))) {
+    context->fast_path_supported = false;
+    return false;
+  }
+
+  if (relative_len > UINT32_MAX) {
+    rb_raise(rb_eArgError, "size of filename is too long to pack: %lu bytes",
+             (unsigned long)relative_len);
+  }
+
+  static const unsigned char filename_entry_prefix[] = {
+      0x81, 0xa8, 'f', 'i', 'l', 'e', 'n', 'a', 'm', 'e'};
+  rb_str_cat(context->packed, (const char *)filename_entry_prefix,
+             sizeof(filename_entry_prefix));
+  packed_files_append_string_header(context->packed, (uint32_t)relative_len,
+                                    binary);
+  const char *relative_ptr = RSTRING_PTR(relative_file) + relative_offset;
+  rb_str_cat(context->packed, relative_ptr, relative_len);
+  RB_GC_GUARD(relative_file);
+  context->files_count++;
+  return true;
+}
+
+static int pack_primary_file_i(VALUE file, VALUE _value,
+                               VALUE context_value) {
+  struct packed_files_context *context =
+      (struct packed_files_context *)context_value;
+  return packed_files_append_entry(context, file, false) ? ST_CONTINUE
+                                                         : ST_STOP;
+}
+
+static bool packed_file_is_absolute(VALUE file, bool additional_file) {
+  if (file == Qnil && !additional_file) {
+    return true;
+  }
+  return RB_TYPE_P(file, T_STRING) && rb_obj_class(file) == rb_cString &&
+         RSTRING_LEN(file) > 0 && RSTRING_PTR(file)[0] == '/';
+}
+
+static int detect_absolute_primary_file_i(VALUE file, VALUE _value,
+                                          VALUE all_absolute_value) {
+  bool *all_absolute = (bool *)all_absolute_value;
+  if (!packed_file_is_absolute(file, false)) {
+    *all_absolute = false;
+    return ST_STOP;
+  }
+  return ST_CONTINUE;
+}
+
+static void
+packed_files_write_array_header(struct packed_files_context *context) {
+  unsigned char header[5];
+  size_t header_len;
+  if (context->files_count < 16) {
+    header[0] = (unsigned char)(0x90U | context->files_count);
+    header_len = 1;
+  } else if (context->files_count < 65536) {
+    header[0] = 0xdc;
+    header[1] = (unsigned char)(context->files_count >> 8);
+    header[2] = (unsigned char)context->files_count;
+    header_len = 3;
+  } else {
+    header[0] = 0xdd;
+    header[1] = (unsigned char)(context->files_count >> 24);
+    header[2] = (unsigned char)(context->files_count >> 16);
+    header[3] = (unsigned char)(context->files_count >> 8);
+    header[4] = (unsigned char)context->files_count;
+    header_len = 5;
+  }
+
+  long body_len = RSTRING_LEN(context->packed) - 5;
+  char *packed_ptr = RSTRING_PTR(context->packed);
+  if (header_len != 5) {
+    memmove(packed_ptr + header_len, packed_ptr + 5, (size_t)body_len);
+    rb_str_resize(context->packed, body_len + (long)header_len);
+    packed_ptr = RSTRING_PTR(context->packed);
+  }
+  memcpy(packed_ptr, header, header_len);
+}
+
+static VALUE file_serialization_pack_files(VALUE module, VALUE primary_files,
+                                           VALUE additional_files,
+                                           VALUE root) {
+  Check_Type(primary_files, T_HASH);
+  Check_Type(additional_files, T_ARRAY);
+  if (!RB_TYPE_P(root, T_STRING) || rb_obj_class(root) != rb_cString ||
+      RSTRING_LEN(root) == 0 || !string_bytes_are_ascii(root)) {
+    return Qnil;
+  }
+
+  bool all_absolute = true;
+  rb_hash_foreach(primary_files, detect_absolute_primary_file_i,
+                  (VALUE)&all_absolute);
+  long additional_files_len = RARRAY_LEN(additional_files);
+  for (long i = 0; all_absolute && i < additional_files_len; i++) {
+    all_absolute =
+        packed_file_is_absolute(rb_ary_entry(additional_files, i), true);
+  }
+
+  struct packed_files_context context = {
+      .root = root,
+      .seen = rb_hash_new(),
+      .packed = rb_str_buf_new(4096),
+      .root_len = RSTRING_LEN(root),
+      .files_count = 0,
+      .direct_absolute = all_absolute,
+      .fast_path_supported = true};
+  rb_str_resize(context.packed, 5);
+
+  rb_hash_foreach(primary_files, pack_primary_file_i, (VALUE)&context);
+  if (!context.fast_path_supported) {
+    return Qnil;
+  }
+
+  for (long i = 0; i < additional_files_len; i++) {
+    if (!packed_files_append_entry(&context,
+                                   rb_ary_entry(additional_files, i), true)) {
+      return Qnil;
+    }
+  }
+
+  packed_files_write_array_header(&context);
+  return context.packed;
+}
+
+void Init_file_serialization(void) {
+  VALUE mDatadog = rb_define_module("Datadog");
+  VALUE mCI = rb_define_module_under(mDatadog, "CI");
+  VALUE mFileSerialization =
+      rb_define_module_under(mCI, "FileSerialization");
+
+  rb_define_singleton_method(mFileSerialization, "pack_files",
+                             file_serialization_pack_files, 3);
+}

data/ext/datadog_ci_native/file_serialization.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void Init_file_serialization(void);

data/lib/datadog/ci/contrib/instrumentation.rb

@@ -147,6 +147,20 @@ module Datadog
           end
         end
 
+        # The intended test process may be reached through an exec'ing launcher
+        # such as Bundler, so keep activation until its test session starts.
+        # Forked workers then inherit loaded instrumentation, while unrelated
+        # Ruby processes started by the suite do not initialize it again.
+        def self.remove_auto_instrumentation_from_rubyopt
+          rubyopt = ENV["RUBYOPT"]
+          return unless rubyopt
+
+          auto_instrument_require = /(?<!\S)-r\s*datadog\/ci\/auto_instrument(?!\S)/
+          rubyopt = rubyopt.gsub(auto_instrument_require, "")
+
+          rubyopt.match?(/\S/) ? ENV["RUBYOPT"] = rubyopt : ENV.delete("RUBYOPT")
+        end
+
         def self.auto_configure_datadog
           configure_once.run do
             Datadog.logger.debug("Applying Datadog configuration in CI mode...")

data/lib/datadog/ci/contrib/parallel_tests/cli.rb

@@ -18,6 +18,10 @@ module Datadog
               return super if @runner != ::ParallelTests::RSpec::Runner
 
               begin
+                # Preserve activation explicitly for the RSpec worker commands.
+                # Starting the distributed parent session removes inherited
+                # activation before unrelated child processes can receive it.
+                worker_rubyopt = ENV["RUBYOPT"]
                 test_session = test_tracing_component.start_test_session(
                   tags: {
                     CI::Ext::Test::TAG_FRAMEWORK => CI::Contrib::RSpec::Ext::FRAMEWORK,
@@ -31,6 +35,7 @@ module Datadog
 
                 options[:env] ||= {}
                 options[:env][CI::Ext::Settings::ENV_TEST_VISIBILITY_DRB_SERVER_URI] = test_tracing_component.context_service_uri
+                options[:env]["RUBYOPT"] ||= worker_rubyopt if worker_rubyopt
 
                 super
               ensure

data/lib/datadog/ci/file_serialization.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    # Native fast path for serializing large lists of file paths.
+    # Implementation in ext/datadog_ci_native/file_serialization.c.
+    #
+    # @internal
+    module FileSerialization
+    end
+  end
+end

data/lib/datadog/ci/source_code/path_filter.rb

@@ -6,8 +6,8 @@ module Datadog
       # PathFilter determines whether a file path should be included in test impact analysis.
       #
       # A path is included if:
-      # - It starts with root_path (prefix match)
-      # - It does NOT start with ignored_path (when ignored_path is set)
+      # - It is equal to root_path or located below it
+      # - It is NOT equal to ignored_path or located below it
       #
       # This module mirrors the C implementation in datadog_common.c (dd_ci_is_path_included).
       module PathFilter
@@ -19,14 +19,22 @@ module Datadog
         # @return [Boolean] true if the path should be included
         def self.included?(path, root_path, ignored_path = nil)
           return false unless path.is_a?(String) && root_path.is_a?(String)
-          return false unless path.start_with?(root_path)
+          return false unless directory_prefix?(path, root_path)
 
           if ignored_path.is_a?(String) && !ignored_path.empty?
-            return false if path.start_with?(ignored_path)
+            return false if directory_prefix?(path, ignored_path)
           end
 
           true
         end
+
+        def self.directory_prefix?(path, prefix)
+          return false unless path.start_with?(prefix)
+
+          path.length == prefix.length || prefix.end_with?(File::SEPARATOR) ||
+            path[prefix.length] == File::SEPARATOR
+        end
+        private_class_method :directory_prefix?
       end
     end
   end

data/lib/datadog/ci/span.rb

@@ -17,6 +17,14 @@ module Datadog
     class Span
       include DRb::DRbUndumped
 
+      ENVIRONMENT_RUNTIME_TAGS = {
+        Ext::Test::TAG_OS_ARCHITECTURE => ::RbConfig::CONFIG["host_cpu"],
+        Ext::Test::TAG_OS_PLATFORM => ::RbConfig::CONFIG["host_os"],
+        Ext::Test::TAG_OS_VERSION => Core::Environment::Platform.kernel_release,
+        Ext::Test::TAG_RUNTIME_NAME => Core::Environment::Ext::LANG_ENGINE,
+        Ext::Test::TAG_RUNTIME_VERSION => Core::Environment::Ext::ENGINE_VERSION
+      }.freeze
+
       attr_reader :tracer_span
 
       def initialize(tracer_span)
@@ -245,11 +253,7 @@ module Datadog
       end
 
       def set_environment_runtime_tags
-        tracer_span.set_tag(Ext::Test::TAG_OS_ARCHITECTURE, ::RbConfig::CONFIG["host_cpu"])
-        tracer_span.set_tag(Ext::Test::TAG_OS_PLATFORM, ::RbConfig::CONFIG["host_os"])
-        tracer_span.set_tag(Ext::Test::TAG_OS_VERSION, Core::Environment::Platform.kernel_release)
-        tracer_span.set_tag(Ext::Test::TAG_RUNTIME_NAME, Core::Environment::Ext::LANG_ENGINE)
-        tracer_span.set_tag(Ext::Test::TAG_RUNTIME_VERSION, Core::Environment::Ext::ENGINE_VERSION)
+        tracer_span.set_tags(ENVIRONMENT_RUNTIME_TAGS)
         tracer_span.set_tag(Ext::Test::TAG_COMMAND, Utils::TestRun.command)
       end
 

data/lib/datadog/ci/test_impact_analysis/coverage/event.rb

@@ -58,12 +58,7 @@ module Datadog
             end
 
             packer.write("files")
-            packer.write_array_header(@files.size)
-            @files.each do |filename|
-              packer.write_map_header(1)
-              packer.write("filename")
-              packer.write(filename)
-            end
+            @files.write_to(packer)
           end
 
           def to_s

data/lib/datadog/ci/test_impact_analysis/coverage/files.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../git/local_repository"
+require_relative "../../file_serialization"
 
 module Datadog
   module CI
@@ -16,6 +17,10 @@ module Datadog
           def initialize(coverage, custom_impacted_files = EMPTY_FILES)
             @coverage = coverage
             @custom_impacted_files = custom_impacted_files
+            # The repository root is a process invariant between coverage
+            # events. Capture it once so native normalization can reuse the
+            # same exact boundary for this event without repeated lookups.
+            @root = Git::LocalRepository.root
             @normalized_files = nil
           end
 
@@ -27,6 +32,30 @@ module Datadog
             normalized_files.size
           end
 
+          # Writes the complete MessagePack files array. The native fast path
+          # combines absolute-path classification, immutable-root slicing,
+          # stable deduplication, and filename-entry packing. Any shape it does
+          # not support falls back before writing bytes.
+          def write_to(packer)
+            if FileSerialization.respond_to?(:pack_files) &&
+                (packed_files = FileSerialization.pack_files(
+                  @coverage,
+                  @custom_impacted_files,
+                  @root
+                ))
+              packer.buffer.write(packed_files)
+              return packer
+            end
+
+            packer.write_array_header(size)
+            each do |filename|
+              packer.write_map_header(1)
+              packer.write("filename")
+              packer.write(filename)
+            end
+            packer
+          end
+
           # Returns a readable view while preserving the paths supplied by
           # native coverage and the custom impacted-files API. Serialized files
           # are normalized through {#each}.

data/lib/datadog/ci/test_tracing/component.rb

@@ -260,6 +260,11 @@ module Datadog
 
         # DOMAIN EVENTS
         def on_test_session_started(test_session)
+          # Forked workers inherit the active test session and instrumentation.
+          # Fresh Ruby processes started by the suite should not initialize
+          # Test Optimization merely because they inherit RUBYOPT.
+          Contrib::Instrumentation.remove_auto_instrumentation_from_rubyopt
+
           # signal git tree upload worker to start uploading git metadata
           git_tree_upload_worker.perform(test_session.git_repository_url)
 

data/lib/datadog/ci/version.rb

@@ -4,8 +4,8 @@ module Datadog
   module CI
     module VERSION
       MAJOR = 1
-      MINOR = 36
-      PATCH = 1
+      MINOR = 37
+      PATCH = 0
       PRE = nil
       BUILD = nil
       # PRE and BUILD above are modified for dev gems during gem build GHA workflow

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.36.1
+  version: 1.37.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -79,6 +79,8 @@ files:
 - ext/datadog_ci_native/datadog_method_inspect.c
 - ext/datadog_ci_native/datadog_method_inspect.h
 - ext/datadog_ci_native/extconf.rb
+- ext/datadog_ci_native/file_serialization.c
+- ext/datadog_ci_native/file_serialization.h
 - ext/datadog_ci_native/imemo_helpers.c
 - ext/datadog_ci_native/imemo_helpers.h
 - ext/datadog_ci_native/iseq_collector.c
@@ -210,6 +212,7 @@ files:
 - lib/datadog/ci/ext/test_discovery.rb
 - lib/datadog/ci/ext/test_optimization_cache.rb
 - lib/datadog/ci/ext/transport.rb
+- lib/datadog/ci/file_serialization.rb
 - lib/datadog/ci/git/base_branch_sha_detection/base.rb
 - lib/datadog/ci/git/base_branch_sha_detection/branch_metric.rb
 - lib/datadog/ci/git/base_branch_sha_detection/guesser.rb