datadog-ci 1.24.0 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30bc86afa5d05d656f9abfa7ffb5ff21d6f9a8fc5edeb5924651de4cdc6df10d
-  data.tar.gz: c846a97a47a74120d9926350360cefa4ca3fcdadea6819337ad2990f7856e267
+  metadata.gz: b1f81920de6f72669d918ab0ea703312868d380d069df7d17f131c0d64e6925a
+  data.tar.gz: 90b37b85ef042fea0b15987d98fa5cf35aad89c599c54ad6ef01d7151dee1386
 SHA512:
-  metadata.gz: 2e2a5b3efa12f1c64176e1751e86ebf803f8c894aba7c53453abb22732e0ed16a6087292538b2e03f0657dc9433ceba9e452f5899a95ace325a004ee12c37fbc
-  data.tar.gz: 461912b9cb9f406c4fd1cb9975ece506df7e979ed7b373b46c9e0060977f397b2da63095be353351d74b4273ea3cc1a354c12a4ef9dc7bf75a0a5ed065a16fa3
+  metadata.gz: 3cd6c023dcd0c239605084ffc9822766ebbde643af95a44bfc2362e8b4a8339cb30ceef649791a1392322de5c0c25ab5d42b80cdbb777ff1f9da1eed717962a7
+  data.tar.gz: f5a196eadb710b862e99d59560971ef5dc35bf5ace1a43733558be8bf1f8a467055b61c637d283ec9ed5cd1f511b6c734fb4085e28c518696ed31a0e90fbec14

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [1.26.0] - 2026-01-09
+
+========== Changelog ==========
+### Changed
+
+* Track constants usage in each Ruby file as a static dependency to enrich Test Impact Analysis data ([#442][])
+
+## [1.25.0] - 2025-12-19
+
+### Added
+* Minitest 6.0 support ([#446][])
+* Support Ruby 4.0 ([#444][])
+
 ## [1.24.0] - 2025-12-15
 
 ### Added
@@ -565,7 +578,9 @@ 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.24.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.26.0...main
+[1.26.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.25.0...v1.26.0
+[1.25.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.24.0...v1.25.0
 [1.24.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.3...v1.24.0
 [1.23.3]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.2...v1.23.3
 [1.23.2]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.1...v1.23.2
@@ -801,4 +816,7 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#430]: https://github.com/DataDog/datadog-ci-rb/issues/430
 [#433]: https://github.com/DataDog/datadog-ci-rb/issues/433
 [#436]: https://github.com/DataDog/datadog-ci-rb/issues/436
-[#440]: https://github.com/DataDog/datadog-ci-rb/issues/440
+[#440]: https://github.com/DataDog/datadog-ci-rb/issues/440
+[#442]: https://github.com/DataDog/datadog-ci-rb/issues/442
+[#444]: https://github.com/DataDog/datadog-ci-rb/issues/444
+[#446]: https://github.com/DataDog/datadog-ci-rb/issues/446

data/ext/datadog_ci_native/ci.c

@@ -1,10 +1,12 @@
 #include "datadog_cov.h"
-#include "datadog_source_code.h"
+#include "datadog_method_inspect.h"
+#include "iseq_collector.h"
 
 void Init_datadog_ci_native(void) {
   // Coverage::DDCov
   Init_datadog_cov();
 
-  // Utils::SourceCode
-  Init_datadog_source_code();
+  // SourceCode
+  Init_datadog_method_inspect();
+  Init_iseq_collector();
 }

data/ext/datadog_ci_native/datadog_common.c

@@ -0,0 +1,64 @@
+#include "datadog_common.h"
+#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) {
+    return false;
+  }
+  if (ignored_path_len > 0 &&
+      strncmp(ignored_path, path, ignored_path_len) == 0) {
+    return false;
+  }
+  return true;
+}
+
+char *dd_ci_ruby_strndup(const char *str, size_t size) {
+  char *dup;
+
+  dup = xmalloc(size + 1);
+  memcpy(dup, str, size);
+  dup[size] = '\0';
+
+  return dup;
+}
+
+VALUE dd_ci_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
+  VALUE result = rb_protect(function_to_call_safely,
+                            function_to_call_safely_arg, &exception_state);
+  if (exception_state != 0) {
+    rb_set_errinfo(Qnil); // Clear the exception
+    return Qnil;
+  }
+  return result;
+}
+
+VALUE dd_ci_get_const_source_location(VALUE const_name_str) {
+  return rb_funcall(rb_cObject, rb_intern("const_source_location"), 1,
+                    const_name_str);
+}
+
+VALUE dd_ci_safely_get_const_source_location(VALUE const_name_str) {
+  return dd_ci_rescue_nil(dd_ci_get_const_source_location, const_name_str);
+}
+
+VALUE dd_ci_resolve_const_to_file(VALUE const_name_str) {
+  VALUE source_location =
+      dd_ci_safely_get_const_source_location(const_name_str);
+  if (NIL_P(source_location) || !RB_TYPE_P(source_location, T_ARRAY) ||
+      RARRAY_LEN(source_location) == 0) {
+    return Qnil;
+  }
+
+  VALUE filename = RARRAY_AREF(source_location, 0);
+  if (NIL_P(filename) || !RB_TYPE_P(filename, T_STRING)) {
+    return Qnil;
+  }
+
+  return filename;
+}

data/ext/datadog_ci_native/datadog_common.h

@@ -0,0 +1,60 @@
+#ifndef DATADOG_COMMON_H
+#define DATADOG_COMMON_H
+
+#include <ruby.h>
+#include <stdbool.h>
+
+/* ---- Path filtering ----------------------------------------------------- */
+
+/**
+ * Check if a file path is under root_path and not under ignored_path.
+ * Returns true if the path should be included, false otherwise.
+ *
+ * @param path          The file path to check
+ * @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);
+
+/* ---- Utility functions -------------------------------------------------- */
+
+/**
+ * Duplicate a string of given size using Ruby's memory allocator.
+ * The returned string is null-terminated.
+ */
+char *dd_ci_ruby_strndup(const char *str, size_t size);
+
+/**
+ * Safe exception handling - equivalent to Ruby's "begin/rescue nil".
+ * Calls function_to_call_safely with the given argument and returns Qnil
+ * if an exception occurs (clearing the exception state).
+ */
+VALUE dd_ci_rescue_nil(VALUE (*function_to_call_safely)(VALUE),
+                       VALUE function_to_call_safely_arg);
+
+/**
+ * Get source location for a given constant name string.
+ * Calls Object.const_source_location(const_name_str).
+ * Returns an array [filename, lineno] or nil if not found.
+ */
+VALUE dd_ci_get_const_source_location(VALUE const_name_str);
+
+/**
+ * Safely get source location for a given constant name string.
+ * Returns Qnil if an exception occurs (e.g., for C-defined or anonymous
+ * classes).
+ */
+VALUE dd_ci_safely_get_const_source_location(VALUE const_name_str);
+
+/**
+ * Resolve a constant name to its source file path.
+ * Returns the filename (String) where the constant is defined, or Qnil if not
+ * found.
+ */
+VALUE dd_ci_resolve_const_to_file(VALUE const_name_str);
+
+#endif /* DATADOG_COMMON_H */

data/ext/datadog_ci_native/datadog_cov.c

@@ -4,6 +4,8 @@
 
 #include <stdbool.h>
 
+#include "datadog_common.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.
@@ -16,35 +18,6 @@ enum threading_mode { single, multi };
 // functions declarations
 static void on_newobj_event(VALUE tracepoint_data, void *data);
 
-// utility functions
-static char *ruby_strndup(const char *str, size_t size) {
-  char *dup;
-
-  dup = xmalloc(size + 1);
-  memcpy(dup, str, size);
-  dup[size] = '\0';
-
-  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
@@ -158,18 +131,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) {
-  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) {
-    return false;
-  }
-
-  // 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) {
+  if (!dd_ci_is_path_included(RSTRING_PTR(filename), dd_cov_data->root,
+                              dd_cov_data->root_len, dd_cov_data->ignored_path,
+                              dd_cov_data->ignored_path_len)) {
     return false;
   }
 
@@ -211,25 +175,14 @@ static void on_line_event(rb_event_flag_t event, VALUE data, VALUE self, ID id,
   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);
-}
-
 // Safely get class name, returns Qnil on any error
 static VALUE safely_get_class_name(VALUE klass) {
-  return rescue_nil(rb_class_name, klass);
+  return dd_ci_rescue_nil(rb_class_name, klass);
 }
 
 // Safely get module ancestors, returns Qnil on any error
 static VALUE safely_get_mod_ancestors(VALUE klass) {
-  return rescue_nil(rb_mod_ancestors, klass);
+  return dd_ci_rescue_nil(rb_mod_ancestors, klass);
 }
 
 static bool record_impacted_klass(struct dd_cov_data *dd_cov_data,
@@ -239,14 +192,8 @@ static bool record_impacted_klass(struct dd_cov_data *dd_cov_data,
     return false;
   }
 
-  VALUE source_location = safely_get_source_location(klass_name);
-  if (source_location == Qnil || !RB_TYPE_P(source_location, T_ARRAY) ||
-      RARRAY_LEN(source_location) == 0) {
-    return false;
-  }
-
-  VALUE filename = RARRAY_AREF(source_location, 0);
-  if (filename == Qnil || !RB_TYPE_P(filename, T_STRING)) {
+  VALUE filename = dd_ci_resolve_const_to_file(klass_name);
+  if (filename == Qnil) {
     return false;
   }
 
@@ -349,12 +296,13 @@ 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 = ruby_strndup(RSTRING_PTR(rb_root), dd_cov_data->root_len);
+  dd_cov_data->root =
+      dd_ci_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);
+    dd_cov_data->ignored_path = dd_ci_ruby_strndup(
+        RSTRING_PTR(rb_ignored_path), dd_cov_data->ignored_path_len);
   }
 
   if (rb_allocation_tracing_enabled == Qtrue) {

data/ext/datadog_ci_native/datadog_method_inspect.c

@@ -0,0 +1,22 @@
+#include <ruby.h>
+
+#include "ruby_internal.h"
+
+static VALUE last_line_from_iseq(VALUE self, VALUE iseqw) {
+  const rb_iseq_t *iseq = rb_iseqw_to_iseq(iseqw);
+
+  int line;
+  rb_iseq_code_location(iseq, NULL, NULL, &line, NULL);
+
+  return INT2NUM(line);
+}
+
+void Init_datadog_method_inspect(void) {
+  VALUE mDatadog = rb_define_module("Datadog");
+  VALUE mCI = rb_define_module_under(mDatadog, "CI");
+  VALUE mSourceCode = rb_define_module_under(mCI, "SourceCode");
+  VALUE mMethodInspect = rb_define_module_under(mSourceCode, "MethodInspect");
+
+  rb_define_singleton_method(mMethodInspect, "_native_last_line_from_iseq",
+                             last_line_from_iseq, 1);
+}

data/ext/datadog_ci_native/datadog_method_inspect.h

@@ -0,0 +1,4 @@
+#pragma once
+
+void Init_datadog_method_inspect(void);
+

data/ext/datadog_ci_native/imemo_helpers.c

@@ -0,0 +1,16 @@
+#include "imemo_helpers.h"
+#include "ruby_internal.h"
+
+int dd_ci_imemo_type(VALUE imemo) {
+  return (RBASIC(imemo)->flags >> FL_USHIFT) & DD_CI_IMEMO_MASK;
+}
+
+bool dd_ci_imemo_iseq_p(VALUE v) {
+  if (!rb_objspace_internal_object_p(v))
+    return false;
+  if (!RB_TYPE_P(v, T_IMEMO))
+    return false;
+  if (dd_ci_imemo_type(v) != DD_CI_IMEMO_TYPE_ISEQ)
+    return false;
+  return true;
+}

data/ext/datadog_ci_native/imemo_helpers.h

@@ -0,0 +1,32 @@
+#ifndef IMEMO_HELPERS_H
+#define IMEMO_HELPERS_H
+
+#include <ruby.h>
+#include <stdbool.h>
+
+/*
+  Here we are using the same trick that debug gem uses here:
+
+  https://github.com/ruby/debug/blob/master/ext/debug/iseq_collector.c
+
+  These functions allow us to check if the VALUE is an ISeq object
+*/
+
+/*
+ * IMEMO (internal memo) helpers for working with Ruby's internal objects.
+ */
+
+#define DD_CI_IMEMO_TYPE_ISEQ 7
+#define DD_CI_IMEMO_MASK 0x0f
+
+/**
+ * Get the IMEMO type from flags.
+ */
+int dd_ci_imemo_type(VALUE imemo);
+
+/**
+ * Check if a VALUE is an internal ISeq object.
+ */
+bool dd_ci_imemo_iseq_p(VALUE v);
+
+#endif /* IMEMO_HELPERS_H */

data/ext/datadog_ci_native/iseq_collector.c

@@ -0,0 +1,65 @@
+#include <ruby.h>
+
+#include "imemo_helpers.h"
+#include "ruby_internal.h"
+
+/*
+ * Callback for rb_objspace_each_objects.
+ *
+ * The callback receives a range of object slots [vstart, vend) with given
+ * stride. Each slot may contain a live object, a freed slot, or garbage.
+ * We check each slot for ISeq objects and add them to the result array.
+ *
+ * See:
+ * https://github.com/ruby/ruby/blob/c99670d6683fec770271d35c2ae082514b1abce3/gc.c#L3550
+ */
+static int collect_iseqs_callback(void *vstart, void *vend, size_t stride,
+                                  void *data) {
+  VALUE iseqs_array = (VALUE)data;
+
+  for (VALUE v = (VALUE)vstart; v != (VALUE)vend; v += stride) {
+    if (dd_ci_imemo_iseq_p(v)) {
+      VALUE iseq = rb_iseqw_new((void *)v);
+      rb_ary_push(iseqs_array, iseq);
+    }
+  }
+  return 0;
+}
+
+/*
+ * ISeqCollector.collect_iseqs
+ *
+ * Walk all live objects in the Ruby object space and collect all
+ * instruction sequences (ISeqs) into an array.
+ *
+ * @return [Array<RubyVM::InstructionSequence>] Array of all live ISeqs
+ *
+ * NOTE:
+ * - Only sees ISeqs that still exist (top-level file ISeqs might be GC'd).
+ *   Method ISeqs usually survive longer.
+ * - The returned ISeqs include all types: method bodies, class bodies,
+ *   blocks, etc.
+
+ * It is very similar to iseq_collector from debug gem:
+ * https://github.com/ruby/debug/blob/master/ext/debug/iseq_collector.c
+*/
+
+static VALUE iseq_collector_collect(VALUE self) {
+  VALUE iseqs_array = rb_ary_new();
+
+  rb_objspace_each_objects(collect_iseqs_callback, (void *)iseqs_array);
+
+  return iseqs_array;
+}
+
+/* ---- Module initialization ---------------------------------------------- */
+
+void Init_iseq_collector(void) {
+  VALUE mDatadog = rb_define_module("Datadog");
+  VALUE mCI = rb_define_module_under(mDatadog, "CI");
+  VALUE mSourceCode = rb_define_module_under(mCI, "SourceCode");
+  VALUE mISeqCollector = rb_define_module_under(mSourceCode, "ISeqCollector");
+
+  rb_define_singleton_method(mISeqCollector, "collect_iseqs",
+                             iseq_collector_collect, 0);
+}

data/ext/datadog_ci_native/iseq_collector.h

@@ -0,0 +1,6 @@
+#ifndef ISEQ_COLLECTOR_H
+#define ISEQ_COLLECTOR_H
+
+void Init_iseq_collector(void);
+
+#endif /* ISEQ_COLLECTOR_H */

data/ext/datadog_ci_native/ruby_internal.h

@@ -0,0 +1,48 @@
+#ifndef RUBY_INTERNAL_H
+#define RUBY_INTERNAL_H
+
+#include <ruby.h>
+
+/*
+ * Ruby MRI internal functions and structures.
+ *
+ * These are not part of Ruby's public C API and are resolved via dynamic
+ * linking against libruby. They may change between Ruby versions.
+ */
+
+/* ---- ISeq structures and functions -------------------------------------- */
+
+typedef struct rb_iseq_struct rb_iseq_t;
+
+/**
+ * Convert an ISeq wrapper VALUE to internal rb_iseq_t pointer.
+ */
+const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
+
+/**
+ * Get code location (line/column info) from an ISeq.
+ */
+void rb_iseq_code_location(const rb_iseq_t *iseq, int *first_lineno,
+                           int *first_column, int *last_lineno,
+                           int *last_column);
+
+/**
+ * Wrap an internal iseq pointer as RubyVM::InstructionSequence.
+ */
+VALUE rb_iseqw_new(const void *iseq);
+
+/* ---- Object space functions --------------------------------------------- */
+
+/**
+ * Check if an object is internal (not visible to Ruby code).
+ */
+int rb_objspace_internal_object_p(VALUE obj);
+
+/**
+ * Iterate over all objects in the Ruby object space.
+ */
+void rb_objspace_each_objects(int (*callback)(void *start, void *end,
+                                              size_t stride, void *data),
+                              void *data);
+
+#endif /* RUBY_INTERNAL_H */

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

@@ -192,7 +192,8 @@ module Datadog
             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,
-            use_allocation_tracing: settings.ci.itr_test_impact_analysis_use_allocation_tracing
+            use_allocation_tracing: settings.ci.itr_test_impact_analysis_use_allocation_tracing,
+            static_dependencies_tracking_enabled: settings.ci.tia_static_dependencies_tracking_enabled
           )
         end
 

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

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

data/lib/datadog/ci/contrib/minitest/helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../source_code/constant_resolver"
+
 module Datadog
   module CI
     module Contrib
@@ -66,9 +68,7 @@ module Datadog
           def self.extract_source_location_from_class(klass)
             return [] if klass.nil? || klass.name.nil?
 
-            klass.const_source_location(klass.name)
-          rescue
-            []
+            SourceCode::ConstantResolver.safely_get_const_source_location(klass.name) || []
           end
         end
       end

data/lib/datadog/ci/contrib/minitest/integration.rb

@@ -18,7 +18,7 @@ module Datadog
 
           def loaded?
             !defined?(::Minitest).nil? && !defined?(::Minitest::Runnable).nil? && !defined?(::Minitest::Test).nil? &&
-              !defined?(::Minitest::CompositeReporter).nil?
+              !defined?(::Minitest::CompositeReporter).nil? && !defined?(::Minitest::Parallel::Executor).nil?
           end
 
           def compatible?

data/lib/datadog/ci/contrib/minitest/parallel_executor_minitest_6.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Contrib
+      module Minitest
+        # Lifecycle hooks to instrument Minitest::Test
+        module ParallelExecutorMinitest6
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          module InstanceMethods
+            def start
+              return super unless datadog_configuration[:enabled]
+
+              @pool = Array.new(size) {
+                Thread.new @queue do |queue|
+                  Thread.current.abort_on_exception = true
+                  while (job = queue.pop)
+                    klass, method, reporter = job
+                    reporter.synchronize { reporter.prerecord klass, method }
+                    result = ::Minitest.run_one_method(klass, method)
+                    reporter.synchronize { reporter.record result }
+                  end
+                end
+              }
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration.ci[:minitest]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/contrib/minitest/patcher.rb

@@ -5,6 +5,9 @@ require_relative "reporter"
 require_relative "test"
 require_relative "runnable"
 
+require_relative "runnable_minitest_6"
+require_relative "parallel_executor_minitest_6"
+
 module Datadog
   module CI
     module Contrib
@@ -18,8 +21,15 @@ module Datadog
           def patch
             # test session start
             ::Minitest.include(Runner)
+
             # test suites (when not executed concurrently)
-            ::Minitest::Runnable.include(Runnable)
+            if ::Minitest::Runnable.respond_to?(:run_suite)
+              ::Minitest::Runnable.include(RunnableMinitest6)
+              ::Minitest::Parallel::Executor.include(ParallelExecutorMinitest6)
+            else
+              ::Minitest::Runnable.include(Runnable)
+            end
+
             # tests; test suites (when executed concurrently)
             ::Minitest::Test.include(Test)
             # test session finish

data/lib/datadog/ci/contrib/minitest/runnable.rb

@@ -20,7 +20,6 @@ module Datadog
               return results unless test_suite
 
               test_suite.finish
-
               results
             end
 
@@ -29,10 +28,6 @@ module Datadog
             def datadog_configuration
               Datadog.configuration.ci[:minitest]
             end
-
-            def test_visibility_component
-              Datadog.send(:components).test_visibility
-            end
           end
         end
       end