datadog-ci 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61f6379b9a5ac0c29ff9ee6b1687c1c2add77d6a5031dfd5758eb34a66cc6235
-  data.tar.gz: a795d8d69513925ee5ea6cf113cb54cec3711fe65ae5e928fcdeb8e1454323af
+  metadata.gz: ba0975da7283a037f3ea9c70954f2868cf387a0e86608882d2ebefdd097e0cf7
+  data.tar.gz: 7842e2e30802411616d987bcbae9be620befa27ba90206a733646a469225f835
 SHA512:
-  metadata.gz: 3ea51d0baa70ecb4e66fb49712f4f291582ecb04455b2d32ec1328bb8ea3c112c4c25d80e450db542ee4f29408786b09a82b5f94fb1c7ef8c96b98d301e61e9b
-  data.tar.gz: 4f066970c2d9ed93001f35f9096cefcf2a4447a86cf7c1d89435853b1da00389c587924304c7a213e56f58f64b191523d202e34f86da535ded271583881411ac
+  metadata.gz: 89bce02785793b2c1f5b5438f6c9cfbf63d3ff4cb065788b4884063341bdc23c289e29715f846ce24e5a4ab939c9cdeb05e755a216e92cee6f20b9954462b05f
+  data.tar.gz: 6adac19cff9d74fc081d22654a8b0db93152c8c5b6706fee82263e6f219edd96bb473f9595c85418a904110bfcde430b7ddcabd034279cb45d24374a55c5b170

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [1.2.0] - 2024-07-16
+
+### Changed
+* Expand test impact analysis with allocation tracing ([#197][])
+
 ## [1.1.0] - 2024-07-01
 
 ### Added
@@ -272,7 +277,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.1.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.2.0...main
+[1.2.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.1.0...v1.2.0
 [1.1.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.1...v1.1.0
 [1.0.1]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.0.0.beta6...v1.0.0
@@ -384,4 +390,5 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#185]: https://github.com/DataDog/datadog-ci-rb/issues/185
 [#189]: https://github.com/DataDog/datadog-ci-rb/issues/189
 [#190]: https://github.com/DataDog/datadog-ci-rb/issues/190
-[#193]: https://github.com/DataDog/datadog-ci-rb/issues/193
+[#193]: https://github.com/DataDog/datadog-ci-rb/issues/193
+[#197]: https://github.com/DataDog/datadog-ci-rb/issues/197

data/ext/datadog_cov/datadog_cov.c

@@ -1,13 +1,26 @@
 #include <ruby.h>
 #include <ruby/debug.h>
+#include <ruby/st.h>
+
+#include <stdbool.h>
+
+// This is a native extension that collects a list of Ruby files that were executed during the test run.
+// It is used to optimize the test suite by running only the tests that are affected by the changes.
 
 #define PROFILE_FRAMES_BUFFER_SIZE 1
 
 // threading modes
-#define SINGLE_THREADED_COVERAGE_MODE 0
-#define MULTI_THREADED_COVERAGE_MODE 1
+enum threading_mode
+{
+  single,
+  multi
+};
+
+// functions declarations
+static void on_newobj_event(VALUE tracepoint_data, void *data);
 
-char *ruby_strndup(const char *str, size_t size)
+// utility functions
+static char *ruby_strndup(const char *str, size_t size)
 {
   char *dup;
 
@@ -18,30 +31,84 @@ char *ruby_strndup(const char *str, size_t size)
   return dup;
 }
 
+// Equivalent to Ruby "begin/rescue nil" call, where we call a C function and
+// swallow the exception if it occurs - const_source_location often fails with
+// exceptions for classes that are defined in C or for anonymous classes.
+static VALUE rescue_nil(VALUE (*function_to_call_safely)(VALUE), VALUE function_to_call_safely_arg)
+{
+  int exception_state;
+  // rb_protect sets exception_state to non-zero if an exception occurs
+  // see https://github.com/ruby/ruby/blob/3219ecf4f659908674f534491d8934ba54e1143d/include/ruby/internal/intern/proc.h#L349
+  VALUE result = rb_protect(function_to_call_safely, function_to_call_safely_arg, &exception_state);
+  if (exception_state != 0)
+  {
+    return Qnil;
+  }
+
+  return result;
+}
+
+static int mark_key_for_gc_i(st_data_t key, st_data_t _value, st_data_t _data)
+{
+  VALUE klass = (VALUE)key;
+  // mark klass link for GC as non-movable to avoid changing hashtable's keys
+  rb_gc_mark(klass);
+  return ST_CONTINUE;
+}
+
 // Data structure
 struct dd_cov_data
 {
+  // Ruby hash with filenames impacted by the test.
+  VALUE impacted_files;
+
+  // Root is the path to the root folder of the project under test.
+  // Files located outside of the root are ignored.
   char *root;
   long root_len;
 
+  // Ignored path contains path to the folder where bundled gems are located if
+  // gems are installed in the project folder.
   char *ignored_path;
   long ignored_path_len;
 
-  VALUE coverage;
-
+  // 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 can work in two modes: single threaded and multi threaded
+  //
+  // In single threaded mode line tracepoint will only cover the thread that started the coverage.
+  // This mode is useful for testing frameworks that run tests in multiple threads.
+  // Do not use single threaded mode for Rails applications unless you know that you
+  // don't run any background threads.
+  //
+  // In multi threaded mode line tracepoint will cover all threads. This mode is enabled by default
+  // and is recommended for most applications.
+  enum threading_mode threading_mode;
   // for single threaded mode: thread that is being covered
   VALUE th_covered;
 
-  int threading_mode;
+  // Allocation tracing is used to track test impact for objects that do not
+  // contain any methods that could be covered by line tracepoint.
+  //
+  // Allocation tracing works only in multi threaded mode.
+  VALUE object_allocation_tracepoint;
+  st_table *klasses_table; // { (VALUE) -> int } hashmap with class names that were covered by allocation during the test run
 };
 
 static void dd_cov_mark(void *ptr)
 {
   struct dd_cov_data *dd_cov_data = ptr;
-  rb_gc_mark_movable(dd_cov_data->coverage);
+  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 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);
+  }
 }
 
 static void dd_cov_free(void *ptr)
@@ -49,17 +116,20 @@ static void dd_cov_free(void *ptr)
   struct dd_cov_data *dd_cov_data = ptr;
   xfree(dd_cov_data->root);
   xfree(dd_cov_data->ignored_path);
+  st_free_table(dd_cov_data->klasses_table);
   xfree(dd_cov_data);
 }
 
 static void dd_cov_compact(void *ptr)
 {
   struct dd_cov_data *dd_cov_data = ptr;
-  dd_cov_data->coverage = rb_gc_location(dd_cov_data->coverage);
+  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
 }
 
-const rb_data_type_t dd_cov_data_type = {
+static const rb_data_type_t dd_cov_data_type = {
     .wrap_struct_name = "dd_cov",
     .function = {
         .dmark = dd_cov_mark,
@@ -71,64 +141,48 @@ const rb_data_type_t dd_cov_data_type = {
 static VALUE dd_cov_allocate(VALUE klass)
 {
   struct dd_cov_data *dd_cov_data;
-  VALUE obj = TypedData_Make_Struct(klass, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
+  VALUE dd_cov = TypedData_Make_Struct(klass, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
 
-  dd_cov_data->coverage = rb_hash_new();
+  dd_cov_data->impacted_files = rb_hash_new();
   dd_cov_data->root = NULL;
   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->threading_mode = MULTI_THREADED_COVERAGE_MODE;
+  dd_cov_data->threading_mode = multi;
 
-  return obj;
-}
+  dd_cov_data->object_allocation_tracepoint = Qnil;
+  // numtable type is needed to store VALUE as a key
+  dd_cov_data->klasses_table = st_init_numtable();
 
-// DDCov methods
-static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self)
-{
-  VALUE opt;
+  return dd_cov;
+}
 
-  rb_scan_args(argc, argv, "10", &opt);
-  VALUE rb_root = rb_hash_lookup(opt, ID2SYM(rb_intern("root")));
-  if (!RTEST(rb_root))
-  {
-    rb_raise(rb_eArgError, "root is required");
-  }
-  VALUE rb_ignored_path = rb_hash_lookup(opt, ID2SYM(rb_intern("ignored_path")));
+// Helper functions (available in C only)
 
-  VALUE rb_threading_mode = rb_hash_lookup(opt, ID2SYM(rb_intern("threading_mode")));
-  int threading_mode;
-  if (rb_threading_mode == ID2SYM(rb_intern("multi")))
-  {
-    threading_mode = MULTI_THREADED_COVERAGE_MODE;
-  }
-  else if (rb_threading_mode == ID2SYM(rb_intern("single")))
-  {
-    threading_mode = SINGLE_THREADED_COVERAGE_MODE;
-  }
-  else
+// Checks if the filename is located under the root folder of the project (but not
+// in the ignored folder) and adds it to the impacted_files hash.
+static void record_impacted_file(struct dd_cov_data *dd_cov_data, VALUE filename)
+{
+  char *filename_ptr = RSTRING_PTR(filename);
+  // if the current filename is not located under the root, we skip it
+  if (strncmp(dd_cov_data->root, filename_ptr, dd_cov_data->root_len) != 0)
   {
-    rb_raise(rb_eArgError, "threading mode is invalid");
+    return;
   }
 
-  struct dd_cov_data *dd_cov_data;
-  TypedData_Get_Struct(self, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
-
-  dd_cov_data->threading_mode = threading_mode;
-  dd_cov_data->root_len = RSTRING_LEN(rb_root);
-  dd_cov_data->root = ruby_strndup(RSTRING_PTR(rb_root), dd_cov_data->root_len);
-
-  if (RTEST(rb_ignored_path))
+  // if ignored_path is provided and the current filename is located under the ignored_path, we skip it too
+  // this is useful for ignoring bundled gems location
+  if (dd_cov_data->ignored_path_len != 0 && strncmp(dd_cov_data->ignored_path, filename_ptr, dd_cov_data->ignored_path_len) == 0)
   {
-    dd_cov_data->ignored_path_len = RSTRING_LEN(rb_ignored_path);
-    dd_cov_data->ignored_path = ruby_strndup(RSTRING_PTR(rb_ignored_path), dd_cov_data->ignored_path_len);
+    return;
   }
 
-  return Qnil;
+  rb_hash_aset(dd_cov_data->impacted_files, filename, Qtrue);
 }
 
-static void dd_cov_update_coverage(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE klass)
+// Executed on RUBY_EVENT_LINE event and captures the filename from 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);
@@ -161,54 +215,182 @@ static void dd_cov_update_coverage(rb_event_flag_t event, VALUE data, VALUE self
     return;
   }
 
-  char *filename_ptr = RSTRING_PTR(filename);
-  // if the current filename is not located under the root, we skip it
-  if (strncmp(dd_cov_data->root, filename_ptr, dd_cov_data->root_len) != 0)
+  record_impacted_file(dd_cov_data, filename);
+}
+
+// Get source location for a given class name
+static VALUE get_source_location(VALUE klass_name)
+{
+  return rb_funcall(rb_cObject, rb_intern("const_source_location"), 1, klass_name);
+}
+
+// Get source location for a given class name and swallow any exceptions
+static VALUE safely_get_source_location(VALUE klass_name)
+{
+  return rescue_nil(get_source_location, klass_name);
+}
+
+// This function is called for each class that was instantiated during the test run.
+static int process_instantiated_klass(st_data_t key, st_data_t _value, st_data_t data)
+{
+  VALUE klass = (VALUE)key;
+  struct dd_cov_data *dd_cov_data = (struct dd_cov_data *)data;
+
+  VALUE klass_name = rb_class_name(klass);
+  if (klass_name == Qnil)
+  {
+    return ST_CONTINUE;
+  }
+
+  VALUE source_location = safely_get_source_location(klass_name);
+  if (source_location == Qnil || RARRAY_LEN(source_location) == 0)
+  {
+    return ST_CONTINUE;
+  }
+
+  VALUE filename = RARRAY_AREF(source_location, 0);
+  if (filename == Qnil)
+  {
+    return ST_CONTINUE;
+  }
+
+  record_impacted_file(dd_cov_data, filename);
+  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);
+
+  // To keep things fast and practical, we only care about objects that extend
+  // either Object or Struct.
+  enum ruby_value_type type = rb_type(new_object);
+  if (type != RUBY_T_OBJECT && type != RUBY_T_STRUCT)
   {
     return;
   }
 
-  // if ignored_path is provided and the current filename is located under the ignored_path, we skip it too
-  // this is useful for ignoring bundled gems location
-  if (dd_cov_data->ignored_path_len != 0 && strncmp(dd_cov_data->ignored_path, filename_ptr, dd_cov_data->ignored_path_len) == 0)
+  VALUE klass = rb_class_of(new_object);
+  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)
   {
     return;
   }
 
-  rb_hash_aset(dd_cov_data->coverage, filename, Qtrue);
+  struct dd_cov_data *dd_cov_data = (struct dd_cov_data *)data;
+
+  // 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);
 }
 
-static VALUE dd_cov_start(VALUE self)
+// DDCov instance methods available in Ruby
+static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self)
 {
+  VALUE opt;
+
+  rb_scan_args(argc, argv, "10", &opt);
+  VALUE rb_root = rb_hash_lookup(opt, ID2SYM(rb_intern("root")));
+  if (!RTEST(rb_root))
+  {
+    rb_raise(rb_eArgError, "root is required");
+  }
+  VALUE rb_ignored_path = rb_hash_lookup(opt, ID2SYM(rb_intern("ignored_path")));
+
+  VALUE rb_threading_mode = rb_hash_lookup(opt, ID2SYM(rb_intern("threading_mode")));
+  enum threading_mode threading_mode;
+  if (rb_threading_mode == ID2SYM(rb_intern("multi")))
+  {
+    threading_mode = multi;
+  }
+  else if (rb_threading_mode == ID2SYM(rb_intern("single")))
+  {
+    threading_mode = single;
+  }
+  else
+  {
+    rb_raise(rb_eArgError, "threading mode is invalid");
+  }
+
+  VALUE rb_allocation_tracing_enabled = rb_hash_lookup(opt, ID2SYM(rb_intern("use_allocation_tracing")));
+  if (rb_allocation_tracing_enabled == Qtrue && threading_mode == single)
+  {
+    rb_raise(rb_eArgError, "allocation tracing is not supported in single threaded mode");
+  }
 
   struct dd_cov_data *dd_cov_data;
   TypedData_Get_Struct(self, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
 
+  dd_cov_data->threading_mode = threading_mode;
+  dd_cov_data->root_len = RSTRING_LEN(rb_root);
+  dd_cov_data->root = ruby_strndup(RSTRING_PTR(rb_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 = ruby_strndup(RSTRING_PTR(rb_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);
+  }
+
+  return Qnil;
+}
+
+// starts test impact collection, executed before the start of each test
+static VALUE dd_cov_start(VALUE self)
+{
+  struct dd_cov_data *dd_cov_data;
+  TypedData_Get_Struct(self, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
+
   if (dd_cov_data->root_len == 0)
   {
     rb_raise(rb_eRuntimeError, "root is required");
   }
 
-  if (dd_cov_data->threading_mode == SINGLE_THREADED_COVERAGE_MODE)
+  // add line tracepoint
+  if (dd_cov_data->threading_mode == single)
   {
     VALUE thval = rb_thread_current();
-    rb_thread_add_event_hook(thval, dd_cov_update_coverage, RUBY_EVENT_LINE, self);
+    rb_thread_add_event_hook(thval, on_line_event, RUBY_EVENT_LINE, self);
     dd_cov_data->th_covered = thval;
   }
   else
   {
-    rb_add_event_hook(dd_cov_update_coverage, RUBY_EVENT_LINE, 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);
   }
 
   return self;
 }
 
+// stops test impact collection, executed after the end of each test
+// returns the hash with impacted files and resets the internal state
 static VALUE dd_cov_stop(VALUE self)
 {
   struct dd_cov_data *dd_cov_data;
   TypedData_Get_Struct(self, struct dd_cov_data, &dd_cov_data_type, dd_cov_data);
 
-  if (dd_cov_data->threading_mode == SINGLE_THREADED_COVERAGE_MODE)
+  // stop line tracepoint
+  if (dd_cov_data->threading_mode == single)
   {
     VALUE thval = rb_thread_current();
     if (!rb_equal(thval, dd_cov_data->th_covered))
@@ -216,17 +398,27 @@ static VALUE dd_cov_stop(VALUE self)
       rb_raise(rb_eRuntimeError, "Coverage was not started by this thread");
     }
 
-    rb_thread_remove_event_hook(dd_cov_data->th_covered, dd_cov_update_coverage);
+    rb_thread_remove_event_hook(dd_cov_data->th_covered, on_line_event);
     dd_cov_data->th_covered = Qnil;
   }
   else
   {
-    rb_remove_event_hook(dd_cov_update_coverage);
+    rb_remove_event_hook(on_line_event);
   }
 
-  VALUE res = dd_cov_data->coverage;
+  // stop object allocation tracepoint
+  if (dd_cov_data->object_allocation_tracepoint != Qnil)
+  {
+    rb_tracepoint_disable(dd_cov_data->object_allocation_tracepoint);
+  }
+
+  // process classes covered by allocation tracing
+  st_foreach(dd_cov_data->klasses_table, process_instantiated_klass, (st_data_t)dd_cov_data);
+  st_clear(dd_cov_data->klasses_table);
+
+  VALUE res = dd_cov_data->impacted_files;
 
-  dd_cov_data->coverage = rb_hash_new();
+  dd_cov_data->impacted_files = rb_hash_new();
   dd_cov_data->last_filename_ptr = 0;
 
   return res;
@@ -236,8 +428,8 @@ void Init_datadog_cov(void)
 {
   VALUE mDatadog = rb_define_module("Datadog");
   VALUE mCI = rb_define_module_under(mDatadog, "CI");
-  VALUE mITR = rb_define_module_under(mCI, "ITR");
-  VALUE mCoverage = rb_define_module_under(mITR, "Coverage");
+  VALUE mTestOptimisation = rb_define_module_under(mCI, "TestOptimisation");
+  VALUE mCoverage = rb_define_module_under(mTestOptimisation, "Coverage");
   VALUE cDatadogCov = rb_define_class_under(mCoverage, "DDCov", rb_cObject);
 
   rb_define_alloc_func(cDatadogCov, dd_cov_allocate);

data/lib/datadog/ci/configuration/components.rb

@@ -2,12 +2,12 @@
 
 require_relative "../ext/settings"
 require_relative "../git/tree_uploader"
-require_relative "../itr/runner"
-require_relative "../itr/coverage/transport"
-require_relative "../itr/coverage/writer"
+require_relative "../test_optimisation/component"
+require_relative "../test_optimisation/coverage/transport"
+require_relative "../test_optimisation/coverage/writer"
+require_relative "../test_visibility/component"
 require_relative "../test_visibility/flush"
-require_relative "../test_visibility/recorder"
-require_relative "../test_visibility/null_recorder"
+require_relative "../test_visibility/null_component"
 require_relative "../test_visibility/serializers/factories/test_level"
 require_relative "../test_visibility/serializers/factories/test_suite_level"
 require_relative "../test_visibility/transport"
@@ -21,15 +21,15 @@ module Datadog
     module Configuration
       # Adds CI behavior to Datadog trace components
       module Components
-        attr_reader :ci_recorder, :itr
+        attr_reader :test_visibility, :test_optimisation
 
         def initialize(settings)
+          @test_optimisation = nil
+          @test_visibility = TestVisibility::NullComponent.new
+
           # Activate CI mode if enabled
           if settings.ci.enabled
             activate_ci!(settings)
-          else
-            @itr = nil
-            @ci_recorder = TestVisibility::NullRecorder.new
           end
 
           super
@@ -38,8 +38,8 @@ module Datadog
         def shutdown!(replacement = nil)
           super
 
-          @ci_recorder&.shutdown!
-          @itr&.shutdown!
+          @test_visibility&.shutdown!
+          @test_optimisation&.shutdown!
         end
 
         def activate_ci!(settings)
@@ -53,22 +53,21 @@ module Datadog
             return
           end
 
-          # Configure ddtrace library for CI visibility mode
+          # Builds test visibility API layer in agentless or EvP proxy mode
+          test_visibility_api = build_test_visibility_api(settings)
+          # bail out early if api is misconfigured
+          return unless settings.ci.enabled
+
+          # Configure datadog gem for test visibility mode
+
           # Deactivate telemetry
           settings.telemetry.enabled = false
 
-          # Deactivate remote configuration
+          # Test visibility uses its own remote settings
           settings.remote.enabled = false
 
-          # do not use 128-bit trace ids for CI visibility
-          # they are used for OTEL compatibility in Datadog tracer
-          settings.tracing.trace_id_128_bit_generation_enabled = false
-
-          # Activate underlying tracing test mode
-          settings.tracing.test_mode.enabled = true
-
-          # Choose user defined TraceFlush or default to CI TraceFlush
-          settings.tracing.test_mode.trace_flush = settings.ci.trace_flush || CI::TestVisibility::Flush::Partial.new
+          # startup logs are useless for test visibility and create noise
+          settings.diagnostics.startup_logs.enabled = false
 
           # When timecop is present, Time.now is mocked and .now_without_mock_time is added on Time to
           # get the current time without the mock.
@@ -81,76 +80,70 @@ module Datadog
             end
           end
 
-          # startup logs are useless for CI visibility and create noise
-          settings.diagnostics.startup_logs.enabled = false
+          # Configure Datadog::Tracing module
 
-          # transport creation
-          writer_options = settings.ci.writer_options
-          coverage_writer = nil
-          test_visibility_api = build_test_visibility_api(settings)
+          # No need not use 128-bit trace ids for test visibility,
+          # they are used for OTEL compatibility in Datadog tracer
+          settings.tracing.trace_id_128_bit_generation_enabled = false
 
-          if test_visibility_api
-            # setup writer for code coverage payloads
-            coverage_writer = ITR::Coverage::Writer.new(
-              transport: ITR::Coverage::Transport.new(api: test_visibility_api)
-            )
+          # Activate underlying tracing test mode with async worker
+          settings.tracing.test_mode.enabled = true
+          settings.tracing.test_mode.async = true
+          settings.tracing.test_mode.trace_flush = settings.ci.trace_flush || CI::TestVisibility::Flush::Partial.new
 
-            # configure tracing writer to send traces to CI visibility backend
-            writer_options[:transport] = TestVisibility::Transport.new(
-              api: test_visibility_api,
-              serializers_factory: serializers_factory(settings),
-              dd_env: settings.env
-            )
-            writer_options[:shutdown_timeout] = 60
-            writer_options[:buffer_size] = 10_000
+          trace_writer_options = settings.ci.writer_options
+          trace_writer_options[:shutdown_timeout] = 60
+          trace_writer_options[:buffer_size] = 10_000
+          tracing_transport = build_tracing_transport(settings, test_visibility_api)
+          trace_writer_options[:transport] = tracing_transport if tracing_transport
 
-            settings.tracing.test_mode.async = true
-          else
-            # only legacy APM protocol is supported, so no test suite level visibility
-            settings.ci.force_test_level_visibility = true
+          settings.tracing.test_mode.writer_options = trace_writer_options
 
-            # ITR is not supported with APM protocol
-            settings.ci.itr_enabled = false
-          end
+          # @type ivar @test_optimisation: Datadog::CI::TestOptimisation::Component
+          @test_optimisation = build_test_optimisation(settings, test_visibility_api)
 
-          settings.tracing.test_mode.writer_options = writer_options
+          @test_visibility = TestVisibility::Component.new(
+            test_optimisation: @test_optimisation,
+            test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility,
+            remote_settings_api: build_remote_settings_client(settings, test_visibility_api),
+            git_tree_upload_worker: build_git_upload_worker(settings, test_visibility_api)
+          )
+        end
 
-          custom_configuration_tags = Utils::TestRun.custom_configuration(settings.tags)
+        def build_test_optimisation(settings, test_visibility_api)
+          if settings.ci.itr_code_coverage_use_single_threaded_mode &&
+              settings.ci.itr_test_impact_analysis_use_allocation_tracing
+            Datadog.logger.warn(
+              "Intelligent test runner: Single threaded coverage mode is incompatible with allocation tracing. " \
+              "Allocation tracing will be disabled. It means that test impact analysis will not be able to detect " \
+              "instantiations of objects in your code, which is important for ActiveRecord models. " \
+              "Please add your app/model folder to the list of tracked files or disable single threaded coverage mode."
+            )
 
-          remote_settings_api = Transport::RemoteSettingsApi.new(
-            api: test_visibility_api,
-            dd_env: settings.env,
-            config_tags: custom_configuration_tags
-          )
+            settings.ci.itr_test_impact_analysis_use_allocation_tracing = false
+          end
 
-          itr = ITR::Runner.new(
+          if RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3" &&
+              settings.ci.itr_test_impact_analysis_use_allocation_tracing
+            Datadog.logger.warn(
+              "Intelligent test runner: Allocation tracing is not supported in Ruby versions 3.2.0, 3.2.1 and 3.2.2 and will be forcibly " \
+              "disabled. This is due to a VM bug that can lead to crashes (https://bugs.ruby-lang.org/issues/19482). " \
+              "Please update your Ruby version or add your app/model folder to the list of tracked files." \
+              "Set env variable DD_CIVISIBILITY_ITR_TEST_IMPACT_ANALYSIS_USE_ALLOCATION_TRACING to 0 to disable this warning."
+            )
+            settings.ci.itr_test_impact_analysis_use_allocation_tracing = false
+          end
+
+          TestOptimisation::Component.new(
             api: test_visibility_api,
             dd_env: settings.env,
-            config_tags: custom_configuration_tags,
-            coverage_writer: coverage_writer,
+            config_tags: custom_configuration(settings),
+            coverage_writer: build_coverage_writer(settings, test_visibility_api),
             enabled: settings.ci.enabled && settings.ci.itr_enabled,
             bundle_location: settings.ci.itr_code_coverage_excluded_bundle_path,
-            use_single_threaded_coverage: settings.ci.itr_code_coverage_use_single_threaded_mode
-          )
-
-          git_tree_uploader = Git::TreeUploader.new(api: test_visibility_api)
-          git_tree_upload_worker = if settings.ci.git_metadata_upload_enabled
-            Worker.new do |repository_url|
-              git_tree_uploader.call(repository_url)
-            end
-          else
-            DummyWorker.new
-          end
-
-          # CI visibility recorder global instance
-          @ci_recorder = TestVisibility::Recorder.new(
-            test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility,
-            itr: itr,
-            remote_settings_api: remote_settings_api,
-            git_tree_upload_worker: git_tree_upload_worker
+            use_single_threaded_coverage: settings.ci.itr_code_coverage_use_single_threaded_mode,
+            use_allocation_tracing: settings.ci.itr_test_impact_analysis_use_allocation_tracing
           )
-
-          @itr = itr
         end
 
         def build_test_visibility_api(settings)
@@ -179,12 +172,61 @@ module Datadog
               Datadog.logger.debug(
                 "Old agent version detected, no evp_proxy support. Forcing test level visibility mode"
               )
+
+              # only legacy APM protocol is supported, so no test suite level visibility
+              settings.ci.force_test_level_visibility = true
+
+              # ITR is not supported with APM protocol
+              settings.ci.itr_enabled = false
             end
           end
 
           api
         end
 
+        def build_tracing_transport(settings, api)
+          return nil if api.nil?
+
+          TestVisibility::Transport.new(
+            api: api,
+            serializers_factory: serializers_factory(settings),
+            dd_env: settings.env
+          )
+        end
+
+        def build_coverage_writer(settings, api)
+          return nil if api.nil?
+
+          TestOptimisation::Coverage::Writer.new(
+            transport: TestOptimisation::Coverage::Transport.new(api: api)
+          )
+        end
+
+        def build_git_upload_worker(settings, api)
+          if settings.ci.git_metadata_upload_enabled
+            git_tree_uploader = Git::TreeUploader.new(api: api)
+            Worker.new do |repository_url|
+              git_tree_uploader.call(repository_url)
+            end
+          else
+            DummyWorker.new
+          end
+        end
+
+        def build_remote_settings_client(settings, api)
+          Transport::RemoteSettingsApi.new(
+            api: api,
+            dd_env: settings.env,
+            config_tags: custom_configuration(settings)
+          )
+        end
+
+        # fetch custom tags provided by the user in DD_TAGS env var
+        # with prefix test.configuration.
+        def custom_configuration(settings)
+          @custom_configuration ||= Utils::TestRun.custom_configuration(settings.tags)
+        end
+
         def serializers_factory(settings)
           if settings.ci.force_test_level_visibility
             TestVisibility::Serializers::Factories::TestLevel

data/lib/datadog/ci/configuration/settings.rb

@@ -82,6 +82,12 @@ module Datadog
                 o.default false
               end
 
+              option :itr_test_impact_analysis_use_allocation_tracing do |o|
+                o.type :bool
+                o.env CI::Ext::Settings::ENV_ITR_TEST_IMPACT_ANALYSIS_USE_ALLOCATION_TRACING
+                o.default true
+              end
+
               define_method(:instrument) do |integration_name, options = {}, &block|
                 return unless enabled
 

data/lib/datadog/ci/ext/settings.rb

@@ -14,6 +14,7 @@ module Datadog
         ENV_GIT_METADATA_UPLOAD_ENABLED = "DD_CIVISIBILITY_GIT_METADATA_UPLOAD_ENABLED"
         ENV_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH"
         ENV_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE"
+        ENV_ITR_TEST_IMPACT_ANALYSIS_USE_ALLOCATION_TRACING = "DD_CIVISIBILITY_ITR_TEST_IMPACT_ANALYSIS_USE_ALLOCATION_TRACING"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = %w[

data/lib/datadog/ci/span.rb

@@ -202,9 +202,9 @@ module Datadog
 
       private
 
-      # provides access to global CI recorder for CI models to deactivate themselves
-      def recorder
-        Datadog.send(:components).ci_recorder
+      # provides access to the test visibility component for CI models to deactivate themselves
+      def test_visibility
+        Datadog.send(:components).test_visibility
       end
     end
   end

data/lib/datadog/ci/test.rb

@@ -19,7 +19,7 @@ module Datadog
       # Finishes the current test.
       # @return [void]
       def finish
-        recorder.deactivate_test
+        test_visibility.deactivate_test
 
         super
       end

data/lib/datadog/ci/test_module.rb

@@ -14,7 +14,7 @@ module Datadog
       # Finishes this test module.
       # @return [void]
       def finish
-        recorder.deactivate_test_module
+        test_visibility.deactivate_test_module
 
         super
       end

data/lib/datadog/ci/{itr/runner.rb → test_optimisation/component.rb}

@@ -16,11 +16,11 @@ require_relative "skippable"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       # Intelligent test runner implementation
       # Integrates with backend to provide test impact analysis data and
       # skip tests that are not impacted by the changes
-      class Runner
+      class Component
         include Core::Utils::Forking
 
         attr_reader :correlation_id, :skippable_tests, :skipped_tests_count
@@ -32,7 +32,8 @@ module Datadog
           coverage_writer: nil,
           enabled: false,
           bundle_location: nil,
-          use_single_threaded_coverage: false
+          use_single_threaded_coverage: false,
+          use_allocation_tracing: true
         )
           @enabled = enabled
           @api = api
@@ -45,6 +46,7 @@ module Datadog
             bundle_location
           end
           @use_single_threaded_coverage = use_single_threaded_coverage
+          @use_allocation_tracing = use_allocation_tracing
 
           @test_skipping_enabled = false
           @code_coverage_enabled = false
@@ -57,11 +59,11 @@ module Datadog
           @skipped_tests_count = 0
           @mutex = Mutex.new
 
-          Datadog.logger.debug("ITR Runner initialized with enabled: #{@enabled}")
+          Datadog.logger.debug("TestOptimisation initialized with enabled: #{@enabled}")
         end
 
         def configure(remote_configuration, test_session:, git_tree_upload_worker:)
-          Datadog.logger.debug("Configuring ITR Runner with remote configuration: #{remote_configuration}")
+          Datadog.logger.debug("Configuring TestOptimisation with remote configuration: #{remote_configuration}")
 
           @enabled = Utils::Parsing.convert_to_bool(
             remote_configuration.fetch(Ext::Transport::DD_API_SETTINGS_RESPONSE_ITR_ENABLED_KEY, false)
@@ -83,7 +85,7 @@ module Datadog
 
           load_datadog_cov! if @code_coverage_enabled
 
-          Datadog.logger.debug("Configured ITR Runner with enabled: #{@enabled}, skipping_tests: #{@test_skipping_enabled}, code_coverage: #{@code_coverage_enabled}")
+          Datadog.logger.debug("Configured TestOptimisation with enabled: #{@enabled}, skipping_tests: #{@test_skipping_enabled}, code_coverage: #{@code_coverage_enabled}")
 
           fetch_skippable_tests(test_session: test_session, git_tree_upload_worker: git_tree_upload_worker)
         end
@@ -139,7 +141,7 @@ module Datadog
           skippable_test_id = Utils::TestRun.skippable_test_id(test.name, test.test_suite_name, test.parameters)
           if @skippable_tests.include?(skippable_test_id)
             if forked?
-              Datadog.logger.warn { "ITR is not supported for forking test runners yet" }
+              Datadog.logger.warn { "Intelligent test runner is not supported for forking test runners yet" }
               return
             end
 
@@ -155,7 +157,7 @@ module Datadog
           return if !test.skipped? || !test.skipped_by_itr?
 
           if forked?
-            Datadog.logger.warn { "ITR is not supported for forking test runners yet" }
+            Datadog.logger.warn { "Intelligent test runner is not supported for forking test runners yet" }
             return
           end
 
@@ -167,7 +169,7 @@ module Datadog
         def write_test_session_tags(test_session)
           return if !enabled?
 
-          Datadog.logger.debug { "Finished ITR session with test skipping enabled: #{@test_skipping_enabled}" }
+          Datadog.logger.debug { "Finished optimised session with test skipping enabled: #{@test_skipping_enabled}" }
           Datadog.logger.debug { "#{@skipped_tests_count} tests were skipped" }
 
           test_session.set_tag(Ext::Test::TAG_ITR_TESTS_SKIPPED, @skipped_tests_count.positive?.to_s)
@@ -189,7 +191,8 @@ module Datadog
           Thread.current[:dd_coverage_collector] ||= Coverage::DDCov.new(
             root: Git::LocalRepository.root,
             ignored_path: @bundle_location,
-            threading_mode: code_coverage_mode
+            threading_mode: code_coverage_mode,
+            use_allocation_tracing: @use_allocation_tracing
           )
         end
 

data/lib/datadog/ci/{itr → test_optimisation}/coverage/ddcov.rb

@@ -2,7 +2,7 @@
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       module Coverage
         # Placeholder for code coverage collection
         # Implementation in ext/datadog_cov

data/lib/datadog/ci/{itr → test_optimisation}/coverage/event.rb

@@ -6,7 +6,7 @@ require_relative "../../git/local_repository"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       module Coverage
         class Event
           attr_reader :test_id, :test_suite_id, :test_session_id, :coverage

data/lib/datadog/ci/{itr → test_optimisation}/coverage/transport.rb

@@ -5,7 +5,7 @@ require_relative "../../transport/event_platform_transport"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       module Coverage
         class Transport < Datadog::CI::Transport::EventPlatformTransport
           private

data/lib/datadog/ci/{itr → test_optimisation}/coverage/writer.rb

@@ -11,7 +11,7 @@ require "datadog/core/environment/ext"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       module Coverage
         class Writer
           include Core::Workers::Queue

data/lib/datadog/ci/{itr → test_optimisation}/skippable.rb

@@ -8,7 +8,7 @@ require_relative "../utils/test_run"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       class Skippable
         class Response
           def initialize(http_response)

data/lib/datadog/ci/test_session.rb

@@ -15,7 +15,7 @@ module Datadog
       # Finishes the current test session.
       # @return [void]
       def finish
-        recorder.deactivate_test_session
+        test_visibility.deactivate_test_session
 
         super
       end

data/lib/datadog/ci/test_suite.rb

@@ -26,7 +26,7 @@ module Datadog
           # we try to derive test suite status from execution stats if no status was set explicitly
           set_status_from_stats! if undefined?
 
-          recorder.deactivate_test_suite(name)
+          test_visibility.deactivate_test_suite(name)
 
           super
         end

data/lib/datadog/ci/test_visibility/{recorder.rb → component.rb}

@@ -28,11 +28,11 @@ module Datadog
     module TestVisibility
       # Common behavior for CI tests
       # Note: this class has too many responsibilities and should be split into multiple classes
-      class Recorder
+      class Component
         attr_reader :environment_tags, :test_suite_level_visibility_enabled
 
         def initialize(
-          itr:,
+          test_optimisation:,
           remote_settings_api:,
           git_tree_upload_worker: DummyWorker.new,
           test_suite_level_visibility_enabled: false,
@@ -46,7 +46,7 @@ module Datadog
 
           @codeowners = codeowners
 
-          @itr = itr
+          @test_optimisation = test_optimisation
           @remote_settings_api = remote_settings_api
           @git_tree_upload_worker = git_tree_upload_worker
         end
@@ -210,7 +210,7 @@ module Datadog
         end
 
         def itr_enabled?
-          @itr.enabled?
+          @test_optimisation.enabled?
         end
 
         private
@@ -234,7 +234,7 @@ module Datadog
             end
           end
 
-          @itr.configure(
+          @test_optimisation.configure(
             remote_configuration.payload,
             test_session: test_session,
             git_tree_upload_worker: @git_tree_upload_worker
@@ -404,17 +404,17 @@ module Datadog
 
         # TODO: use kind of event system to notify about test finished?
         def on_test_finished(test)
-          @itr.stop_coverage(test)
-          @itr.count_skipped_test(test)
+          @test_optimisation.stop_coverage(test)
+          @test_optimisation.count_skipped_test(test)
         end
 
         def on_test_started(test)
-          @itr.mark_if_skippable(test)
-          @itr.start_coverage(test)
+          @test_optimisation.mark_if_skippable(test)
+          @test_optimisation.start_coverage(test)
         end
 
         def on_test_session_finished(test_session)
-          @itr.write_test_session_tags(test_session)
+          @test_optimisation.write_test_session_tags(test_session)
         end
       end
     end

data/lib/datadog/ci/test_visibility/{null_recorder.rb → null_component.rb}

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "recorder"
-
 module Datadog
   module CI
     module TestVisibility
-      # Special recorder that does not record anything
-      class NullRecorder
+      # Special test visibility component that does not record anything
+      class NullComponent
         def start_test_session(service: nil, tags: {})
           skip_tracing
         end
@@ -45,6 +43,10 @@ module Datadog
         def shutdown!
         end
 
+        def itr_enabled?
+          false
+        end
+
         private
 
         def skip_tracing(block = nil)

data/lib/datadog/ci/test_visibility/transport.rb

@@ -100,7 +100,7 @@ module Datadog
         end
 
         def itr
-          @itr ||= Datadog::CI.send(:itr_runner)
+          @test_optimisation ||= Datadog::CI.send(:test_optimisation)
         end
       end
     end

data/lib/datadog/ci/version.rb

@@ -4,7 +4,7 @@ module Datadog
   module CI
     module VERSION
       MAJOR = 1
-      MINOR = 1
+      MINOR = 2
       PATCH = 0
       PRE = nil
       BUILD = nil

data/lib/datadog/ci.rb

@@ -39,7 +39,7 @@ module Datadog
       # @return [Datadog::CI::TestSession] the active, running {Datadog::CI::TestSession}.
       # @return [nil] if test suite level visibility is disabled or CI mode is disabled.
       def start_test_session(service: Utils::Configuration.fetch_service_name("test"), tags: {})
-        recorder.start_test_session(service: service, tags: tags)
+        test_visibility.start_test_session(service: service, tags: tags)
       end
 
       # The active, unfinished test session.
@@ -61,7 +61,7 @@ module Datadog
       # @return [Datadog::CI::TestSession] the active test session
       # @return [nil] if no test session is active
       def active_test_session
-        recorder.active_test_session
+        test_visibility.active_test_session
       end
 
       # Starts a {Datadog::CI::TestModule ci_test_module} that represents a single test module (for most Ruby test frameworks
@@ -93,7 +93,7 @@ module Datadog
       # @return [Datadog::CI::TestModule] the active, running {Datadog::CI::TestModule}.
       # @return [nil] if test suite level visibility is disabled or CI mode is disabled.
       def start_test_module(test_module_name, service: nil, tags: {})
-        recorder.start_test_module(test_module_name, service: service, tags: tags)
+        test_visibility.start_test_module(test_module_name, service: service, tags: tags)
       end
 
       # The active, unfinished test module.
@@ -116,7 +116,7 @@ module Datadog
       # @return [Datadog::CI::TestModule] the active test module
       # @return [nil] if no test module is active
       def active_test_module
-        recorder.active_test_module
+        test_visibility.active_test_module
       end
 
       # Starts a {Datadog::CI::TestSuite ci_test_suite} that represents a single test suite.
@@ -145,7 +145,7 @@ module Datadog
       # @return [Datadog::CI::TestSuite] the active, running {Datadog::CI::TestSuite}.
       # @return [nil] if test suite level visibility is disabled or CI mode is disabled.
       def start_test_suite(test_suite_name, service: nil, tags: {})
-        recorder.start_test_suite(test_suite_name, service: service, tags: tags)
+        test_visibility.start_test_suite(test_suite_name, service: service, tags: tags)
       end
 
       # The active, unfinished test suite.
@@ -168,7 +168,7 @@ module Datadog
       # @return [Datadog::CI::TestSuite] the active test suite
       # @return [nil] if no test suite with given name is active
       def active_test_suite(test_suite_name)
-        recorder.active_test_suite(test_suite_name)
+        test_visibility.active_test_suite(test_suite_name)
       end
 
       # Return a {Datadog::CI::Test ci_test} that will trace a test called `test_name`.
@@ -222,7 +222,7 @@ module Datadog
       # @yieldparam [Datadog::CI::Test] ci_test the newly created and active [Datadog::CI::Test]
       # @yieldparam [nil] if CI mode is disabled
       def trace_test(test_name, test_suite_name, service: nil, tags: {}, &block)
-        recorder.trace_test(test_name, test_suite_name, service: service, tags: tags, &block)
+        test_visibility.trace_test(test_name, test_suite_name, service: service, tags: tags, &block)
       end
 
       # Same as {.trace_test} but it does not accept a block.
@@ -248,7 +248,7 @@ module Datadog
       # @return [Datadog::CI::Test] the active, unfinished {Datadog::CI::Test}.
       # @return [nil] if CI mode is disabled.
       def start_test(test_name, test_suite_name, service: nil, tags: {})
-        recorder.trace_test(test_name, test_suite_name, service: service, tags: tags)
+        test_visibility.trace_test(test_name, test_suite_name, service: service, tags: tags)
       end
 
       # Trace any custom span inside a test. For example, you could trace:
@@ -300,7 +300,7 @@ module Datadog
           )
         end
 
-        recorder.trace(span_name, type: type, tags: tags, &block)
+        test_visibility.trace(span_name, type: type, tags: tags, &block)
       end
 
       # The active, unfinished custom (i.e. not test/suite/module/session) span.
@@ -326,7 +326,7 @@ module Datadog
       # @return [Datadog::CI::Span] the active span
       # @return [nil] if no span is active, or if the active span is not a custom span
       def active_span
-        span = recorder.active_span
+        span = test_visibility.active_span
         span if span && !Ext::AppTypes::CI_SPAN_TYPES.include?(span.type)
       end
 
@@ -352,7 +352,7 @@ module Datadog
       # @return [Datadog::CI::Test] the active test
       # @return [nil] if no test is active
       def active_test
-        recorder.active_test
+        test_visibility.active_test
       end
 
       private
@@ -361,12 +361,12 @@ module Datadog
         Datadog.send(:components)
       end
 
-      def recorder
-        components.ci_recorder
+      def test_visibility
+        components.test_visibility
       end
 
-      def itr_runner
-        components.itr
+      def test_optimisation
+        components.test_optimisation
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-01 00:00:00.000000000 Z
+date: 2024-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: datadog
@@ -134,22 +134,22 @@ files:
 - lib/datadog/ci/git/tree_uploader.rb
 - lib/datadog/ci/git/upload_packfile.rb
 - lib/datadog/ci/git/user.rb
-- lib/datadog/ci/itr/coverage/ddcov.rb
-- lib/datadog/ci/itr/coverage/event.rb
-- lib/datadog/ci/itr/coverage/transport.rb
-- lib/datadog/ci/itr/coverage/writer.rb
-- lib/datadog/ci/itr/runner.rb
-- lib/datadog/ci/itr/skippable.rb
 - lib/datadog/ci/span.rb
 - lib/datadog/ci/test.rb
 - lib/datadog/ci/test_module.rb
+- lib/datadog/ci/test_optimisation/component.rb
+- lib/datadog/ci/test_optimisation/coverage/ddcov.rb
+- lib/datadog/ci/test_optimisation/coverage/event.rb
+- lib/datadog/ci/test_optimisation/coverage/transport.rb
+- lib/datadog/ci/test_optimisation/coverage/writer.rb
+- lib/datadog/ci/test_optimisation/skippable.rb
 - lib/datadog/ci/test_session.rb
 - lib/datadog/ci/test_suite.rb
+- lib/datadog/ci/test_visibility/component.rb
 - lib/datadog/ci/test_visibility/context/global.rb
 - lib/datadog/ci/test_visibility/context/local.rb
 - lib/datadog/ci/test_visibility/flush.rb
-- lib/datadog/ci/test_visibility/null_recorder.rb
-- lib/datadog/ci/test_visibility/recorder.rb
+- lib/datadog/ci/test_visibility/null_component.rb
 - lib/datadog/ci/test_visibility/serializers/base.rb
 - lib/datadog/ci/test_visibility/serializers/factories/test_level.rb
 - lib/datadog/ci/test_visibility/serializers/factories/test_suite_level.rb