datadog-ci 1.25.0 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e68ff85fe19330eb395ad72da915dbad1bf98c02f5c917402da73b4f5ebab745
-  data.tar.gz: aa30fff0bb9f8349e3c9caa5d9ff77cbdd57b7c1cf8e61fdd19d98ebcb271711
+  metadata.gz: b1f81920de6f72669d918ab0ea703312868d380d069df7d17f131c0d64e6925a
+  data.tar.gz: 90b37b85ef042fea0b15987d98fa5cf35aad89c599c54ad6ef01d7151dee1386
 SHA512:
-  metadata.gz: '0668a4e35ef63218065e169ab00dfe7e7bfc4439c35f6020611d35a2a625dbdb20d38aa3e7edd3a5cf3769e15bd31077717141029223637cabeb34b172069aa8'
-  data.tar.gz: 119fef9be7bd8ab89c013fa545dd3d09b8013fa6ef79db438e59c12b8fd1acc42734bc9faa8f0f3ff63d28fec0b3480c7f43e89ca10a5ce83ee7b6e7a26b1422
+  metadata.gz: 3cd6c023dcd0c239605084ffc9822766ebbde643af95a44bfc2362e8b4a8339cb30ceef649791a1392322de5c0c25ab5d42b80cdbb777ff1f9da1eed717962a7
+  data.tar.gz: f5a196eadb710b862e99d59560971ef5dc35bf5ace1a43733558be8bf1f8a467055b61c637d283ec9ed5cd1f511b6c734fb4085e28c518696ed31a0e90fbec14

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [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
@@ -571,7 +578,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.25.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
@@ -809,5 +817,6 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#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
+[#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/parallel_executor_minitest_6.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../ext/test"
-require_relative "../../git/local_repository"
-require_relative "../../utils/source_code"
-require_relative "../instrumentation"
-require_relative "ext"
-require_relative "helpers"
-
 module Datadog
   module CI
     module Contrib

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

@@ -2,7 +2,7 @@
 
 require_relative "../../ext/test"
 require_relative "../../git/local_repository"
-require_relative "../../utils/source_code"
+require_relative "../../source_code/method_inspect"
 require_relative "../instrumentation"
 require_relative "ext"
 require_relative "helpers"
@@ -38,7 +38,7 @@ module Datadog
               # try to find out where test method starts and ends
               test_method = method(name)
               source_file, first_line_number = test_method.source_location
-              last_line_number = Utils::SourceCode.last_line(test_method)
+              last_line_number = SourceCode::MethodInspect.last_line(test_method)
 
               tags[CI::Ext::Test::TAG_SOURCE_FILE] = Git::LocalRepository.relative_to_root(source_file) if source_file
               tags[CI::Ext::Test::TAG_SOURCE_START] = first_line_number.to_s if first_line_number

data/lib/datadog/ci/contrib/rspec/example.rb

@@ -2,7 +2,7 @@
 
 require_relative "../../ext/test"
 require_relative "../../git/local_repository"
-require_relative "../../utils/source_code"
+require_relative "../../source_code/method_inspect"
 require_relative "../../utils/test_run"
 require_relative "../instrumentation"
 require_relative "ext"
@@ -36,7 +36,7 @@ module Datadog
                 CI::Ext::Test::TAG_PARAMETERS => datadog_test_parameters
               }
 
-              end_line = Utils::SourceCode.last_line(@example_block)
+              end_line = SourceCode::MethodInspect.last_line(@example_block)
               tags[CI::Ext::Test::TAG_SOURCE_END] = end_line.to_s if end_line
 
               test_retries_component.with_retries do

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

@@ -29,6 +29,7 @@ module Datadog
         ENV_TEST_DISCOVERY_MODE_ENABLED = "DD_TEST_OPTIMIZATION_DISCOVERY_ENABLED"
         ENV_TEST_DISCOVERY_OUTPUT_PATH = "DD_TEST_OPTIMIZATION_DISCOVERY_FILE"
         ENV_AUTO_INSTRUMENTATION_PROVIDER = "DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER"
+        ENV_TIA_STATIC_DEPENDENCIES_TRACKING_ENABLED = "DD_TEST_OPTIMIZATION_TIA_STATIC_DEPS_COVERAGE_ENABLED"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = %w[

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module SourceCode
+      # ConstantResolver resolves Ruby constant names to their source file locations.
+      #
+      # This module uses Object.const_source_location to find where a constant is defined.
+      # Constants defined in C extensions or built-in Ruby classes have no source location.
+      #
+      # This module mirrors the C implementation in datadog_common.c (dd_ci_resolve_const_to_file).
+      module ConstantResolver
+        # Resolve a constant name to its source file path.
+        #
+        # @param constant_name [String] The fully qualified constant name (e.g., "Foo::Bar::Baz")
+        # @return [String, nil] The absolute file path where the constant is defined, or nil if not found
+        def self.resolve_path(constant_name)
+          return nil unless constant_name.is_a?(String)
+          return nil if constant_name.empty?
+
+          source_location = safely_get_const_source_location(constant_name)
+          return nil unless source_location.is_a?(Array) && !source_location.empty?
+
+          filename = source_location[0]
+          return nil unless filename.is_a?(String)
+
+          filename
+        end
+
+        # Safely get source location for a constant, returning nil on any exception.
+        # This handles cases like anonymous classes, C-defined constants, etc.
+        #
+        # @param constant_name [String] The constant name to look up
+        # @return [Array, nil] The [filename, lineno] array or nil
+        def self.safely_get_const_source_location(constant_name)
+          Object.const_source_location(constant_name)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/{utils/source_code.rb → source_code/method_inspect.rb}

@@ -2,8 +2,8 @@
 
 module Datadog
   module CI
-    module Utils
-      module SourceCode
+    module SourceCode
+      module MethodInspect
         begin
           require "datadog_ci_native.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
 
@@ -22,7 +22,7 @@ module Datadog
           return nil unless iseq.is_a?(RubyVM::InstructionSequence)
           # steep:ignore:end
 
-          # this function is implemented in ext/datadog_ci_native/datadog_source_code.c
+          # this function is implemented in ext/datadog_ci_native/datadog_method_inspect.c
           _native_last_line_from_iseq(iseq)
         end
       end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module SourceCode
+      # 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)
+      #
+      # This module mirrors the C implementation in datadog_common.c (dd_ci_is_path_included).
+      module PathFilter
+        # Check if a file path should be included in analysis.
+        #
+        # @param path [String] The file path to check
+        # @param root_path [String] The root path prefix (required)
+        # @param ignored_path [String, nil] Path prefix to exclude (optional)
+        # @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)
+
+          if ignored_path.is_a?(String) && !ignored_path.empty?
+            return false if path.start_with?(ignored_path)
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "static_dependencies_extractor"
+
+module Datadog
+  module CI
+    module SourceCode
+      # ISeqCollector provides native access to Ruby's object space
+      # for collecting instruction sequences (ISeqs).
+      #
+      # @api private
+      module ISeqCollector
+        STATIC_DEPENDENCIES_EXTRACTION_AVAILABLE = begin
+          # We support Ruby >= 3.2 even though technically it is possible to support 3.1
+          # The issue is that Ruby 3.1 and earlier doesn't have opt_getconstant_path YARV instruction
+          # which makes it a lot harder to parse fully qualified constant access.
+          #
+          # See the PR https://github.com/DataDog/datadog-ci-rb/pull/442 for more context
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.2")
+            require "datadog_ci_native.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+            true
+          else
+            false
+          end
+        rescue LoadError
+          false
+        end
+
+        # Collect all live ISeqs from the Ruby object space.
+        # Falls back to empty array if native extension is not available.
+        #
+        # @return [Array<RubyVM::InstructionSequence>] Array of all live ISeqs
+        def self.collect
+          return [] unless STATIC_DEPENDENCIES_EXTRACTION_AVAILABLE
+
+          collect_iseqs
+        end
+      end
+
+      module StaticDependencies
+        # Populate the static dependencies map by scanning all live ISeqs.
+        #
+        # @param root_path [String] Only process files under this path
+        # @param ignored_path [String, nil] Exclude files under this path
+        # @return [Hash{String => Hash{String => Boolean}}] The dependencies map
+        def self.populate!(root_path, ignored_path = nil)
+          raise ArgumentError, "root_path must be a String and not nil" if root_path.nil? || !root_path.is_a?(String)
+
+          extractor = StaticDependenciesExtractor.new(root_path, ignored_path)
+
+          ISeqCollector.collect.each do |iseq|
+            extractor.extract(iseq)
+          end
+
+          @dependencies_map = extractor.dependencies_map
+        end
+
+        # Fetch static dependencies for a given file.
+        #
+        # @param file [String, nil] The file path to look up
+        # @return [Hash{String => Boolean}] Dependencies hash or empty hash
+        def self.fetch_static_dependencies(file)
+          return {} unless @dependencies_map
+          return {} if file.nil?
+
+          @dependencies_map.fetch(file, {})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require_relative "path_filter"
+require_relative "constant_resolver"
+
+module Datadog
+  module CI
+    module SourceCode
+      # StaticDependenciesExtractor extracts static constant dependencies from Ruby bytecode.
+      #
+      # For each ISeq (compiled Ruby code), it:
+      # 1. Extracts the source file path
+      # 2. Filters by root_path and ignored_path
+      # 3. Scans bytecode for constant references
+      # 4. Resolves constants to their source file locations
+      # 5. Filters dependency paths by root_path and ignored_path
+      #
+      # @example
+      #   extractor = StaticDependenciesExtractor.new("/app", "/app/vendor")
+      #   iseq = RubyVM::InstructionSequence.of(some_method)
+      #   extractor.extract(iseq)
+      #   deps = extractor.dependencies_map
+      #   # => { "/app/foo.rb" => { "/app/bar.rb" => true } }
+      #
+      class StaticDependenciesExtractor
+        # BytecodeScanner scans Ruby bytecode instructions for constant references.
+        #
+        # This class traverses the ISeq#to_a representation to find:
+        # - :getconstant instructions - simple constant references
+        # - :opt_getconstant_path instructions - optimized qualified constant paths
+        #
+        # @api private
+        class BytecodeScanner
+          # Scan an ISeq body for constant references.
+          #
+          # @param body [Array] The ISeq body array (last element of ISeq#to_a)
+          # @return [Array<String>] Array of constant name strings found in the bytecode
+          def scan(body)
+            return [] unless body.is_a?(Array)
+
+            constants = []
+            scan_value(body, constants)
+            constants
+          end
+
+          # Build a qualified constant name from an array of symbols.
+          # e.g., [:Foo, :Bar, :Baz] -> "Foo::Bar::Baz"
+          #
+          # @param symbol_array [Array<Symbol>] Array of constant name symbols
+          # @return [String] The qualified constant path string
+          def build_constant_path(symbol_array)
+            symbol_array
+              .select { |part| part.is_a?(Symbol) }
+              .map(&:to_s)
+              .join("::")
+          end
+
+          private
+
+          # Recursively scan a Ruby value for constant references.
+          #
+          # @param value [Object] Any Ruby value from the ISeq representation
+          # @param constants [Array<String>] Accumulator for found constants
+          def scan_value(value, constants)
+            case value
+            when Array
+              scan_array(value, constants)
+            when Hash
+              scan_hash(value, constants)
+            end
+          end
+
+          # Scan an array for instructions and nested values.
+          #
+          # @param arr [Array] Array to scan
+          # @param constants [Array<String>] Accumulator for found constants
+          def scan_array(arr, constants)
+            handle_instruction(arr, constants)
+
+            arr.each do |elem|
+              scan_value(elem, constants)
+            end
+          end
+
+          # Scan a hash for constant references in keys and values.
+          #
+          # @param hash [Hash] Hash to scan
+          # @param constants [Array<String>] Accumulator for found constants
+          def scan_hash(hash, constants)
+            hash.each do |key, val|
+              scan_value(key, constants)
+              scan_value(val, constants)
+            end
+          end
+
+          # Check if an array is a bytecode instruction and handle it.
+          # Instructions have the form [:instruction_name, ...args].
+          #
+          # @param arr [Array] Potential instruction array
+          # @param constants [Array<String>] Accumulator for found constants
+          def handle_instruction(arr, constants)
+            return if arr.size < 2
+            return unless arr[0].is_a?(Symbol)
+
+            case arr[0]
+            when :getconstant
+              handle_getconstant(arr, constants)
+            when :opt_getconstant_path
+              handle_opt_getconstant_path(arr, constants)
+            end
+          end
+
+          # Handle [:getconstant, :CONST_NAME, ...] instruction.
+          #
+          # @param instruction [Array] The instruction array
+          # @param constants [Array<String>] Accumulator for found constants
+          def handle_getconstant(instruction, constants)
+            const_name = instruction[1]
+            return unless const_name.is_a?(Symbol)
+
+            constants << const_name.to_s
+          end
+
+          # Handle [:opt_getconstant_path, cache_entry] instruction.
+          # The cache entry is an array of symbols: [:Foo, :Bar, :Baz]
+          #
+          # @param instruction [Array] The instruction array
+          # @param constants [Array<String>] Accumulator for found constants
+          def handle_opt_getconstant_path(instruction, constants)
+            cache_entry = instruction[1]
+            return unless cache_entry.is_a?(Array) && !cache_entry.empty?
+
+            path = build_constant_path(cache_entry)
+            constants << path unless path.empty?
+          end
+        end
+
+        # @return [Hash{String => Hash{String => Boolean}}] Map of source file to dependencies
+        attr_reader :dependencies_map
+
+        # @return [String] Root path prefix for filtering
+        attr_reader :root_path
+
+        # @return [String, nil] Ignored path prefix for exclusion
+        attr_reader :ignored_path
+
+        # Initialize a new StaticDependenciesExtractor.
+        #
+        # @param root_path [String] Only process files under this path
+        # @param ignored_path [String, nil] Exclude files under this path
+        def initialize(root_path, ignored_path = nil)
+          @root_path = root_path
+          @ignored_path = ignored_path
+          @dependencies_map = {}
+          @bytecode_scanner = BytecodeScanner.new
+        end
+
+        # Extract constant dependencies from an ISeq.
+        #
+        # @param iseq [RubyVM::InstructionSequence] The instruction sequence to process
+        # @return [void]
+        def extract(iseq)
+          path = extract_absolute_path(iseq)
+          return if path.nil?
+          return unless PathFilter.included?(path, root_path, ignored_path)
+
+          body = extract_body(iseq)
+          return if body.nil?
+
+          deps = get_or_create_deps(path)
+          constant_names = @bytecode_scanner.scan(body)
+
+          constant_names.each do |const_name|
+            resolve_and_store_dependency(const_name, deps)
+          end
+        end
+
+        # Reset the dependencies map.
+        #
+        # @return [void]
+        def reset
+          @dependencies_map = {}
+        end
+
+        private
+
+        # Extract the absolute path from an ISeq.
+        # Returns nil for eval'd code (which has no file).
+        #
+        # @param iseq [RubyVM::InstructionSequence]
+        # @return [String, nil]
+        def extract_absolute_path(iseq)
+          path = iseq.absolute_path
+          return nil unless path.is_a?(String)
+
+          path
+        end
+
+        # Extract the body array from an ISeq's SimpleDataFormat.
+        # The body is the last element of ISeq#to_a.
+        #
+        # @param iseq [RubyVM::InstructionSequence]
+        # @return [Array, nil]
+        def extract_body(iseq)
+          arr = iseq.to_a
+          return nil unless arr.is_a?(Array) && !arr.empty?
+
+          body = arr[-1]
+          return nil unless body.is_a?(Array)
+
+          body
+        end
+
+        # Get or create dependencies hash for a given path.
+        #
+        # @param path [String]
+        # @return [Hash{String => Boolean}]
+        def get_or_create_deps(path)
+          @dependencies_map[path] ||= {}
+        end
+
+        # Resolve a constant name to its file and store in dependencies.
+        #
+        # @param constant_name [String]
+        # @param deps [Hash{String => Boolean}]
+        # @return [void]
+        def resolve_and_store_dependency(constant_name, deps)
+          file_path = ConstantResolver.resolve_path(constant_name)
+          return if file_path.nil?
+          return unless PathFilter.included?(file_path, root_path, ignored_path)
+
+          deps[file_path] = true
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,8 @@ require_relative "../ext/dd_test"
 
 require_relative "../git/local_repository"
 
+require_relative "../source_code/static_dependencies"
+
 require_relative "../utils/parsing"
 require_relative "../utils/stateful"
 require_relative "../utils/telemetry"
@@ -40,7 +42,8 @@ module Datadog
           enabled: false,
           bundle_location: nil,
           use_single_threaded_coverage: false,
-          use_allocation_tracing: true
+          use_allocation_tracing: true,
+          static_dependencies_tracking_enabled: false
         )
           @enabled = enabled
           @api = api
@@ -54,6 +57,7 @@ module Datadog
           end
           @use_single_threaded_coverage = use_single_threaded_coverage
           @use_allocation_tracing = use_allocation_tracing
+          @static_dependencies_tracking_enabled = static_dependencies_tracking_enabled
 
           @test_skipping_enabled = false
           @code_coverage_enabled = false
@@ -82,7 +86,11 @@ module Datadog
           # we skip tests, not suites
           test_session.set_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_TYPE, Ext::Test::ITR_TEST_SKIPPING_MODE)
 
-          load_datadog_cov! if @code_coverage_enabled
+          if @code_coverage_enabled
+            load_datadog_cov!
+
+            populate_static_dependencies_map!
+          end
 
           # Load component state first, and if successful, skip fetching skippable tests
           # Also try to restore from DDTest cache if available
@@ -131,11 +139,14 @@ module Datadog
             return
           end
 
+          # cucumber's gherkin files are not covered by the code coverage collector - we add them here explicitly
           test_source_file = test.source_file
-
-          # cucumber's gherkin files are not covered by the code coverage collector
           ensure_test_source_covered(test_source_file, coverage) unless test_source_file.nil?
 
+          # if we have static dependencies tracking enabled then we can make the coverage
+          # more precise by fetching which files we depend on based on constants usage
+          enrich_coverage_with_static_dependencies(coverage)
+
           Telemetry.code_coverage_files(coverage.size)
 
           event = Coverage::Event.new(
@@ -323,6 +334,25 @@ module Datadog
           @code_coverage_enabled = false
         end
 
+        def populate_static_dependencies_map!
+          return unless @code_coverage_enabled
+          return unless @static_dependencies_tracking_enabled
+
+          Datadog::CI::SourceCode::StaticDependencies.populate!(Git::LocalRepository.root, @bundle_location)
+        end
+
+        def enrich_coverage_with_static_dependencies(coverage)
+          return unless @static_dependencies_tracking_enabled
+
+          static_dependencies_map = {}
+          coverage.keys.each do |file|
+            static_dependencies_map.merge!(
+              Datadog::CI::SourceCode::StaticDependencies.fetch_static_dependencies(file)
+            )
+          end
+          coverage.merge!(static_dependencies_map)
+        end
+
         def ensure_test_source_covered(test_source_file, coverage)
           absolute_test_source_file_path = File.join(Git::LocalRepository.root, test_source_file)
           return if coverage.key?(absolute_test_source_file_path)

data/lib/datadog/ci/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.25.0
+  version: 1.26.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -72,11 +72,18 @@ files:
 - README.md
 - exe/ddcirb
 - ext/datadog_ci_native/ci.c
+- ext/datadog_ci_native/datadog_common.c
+- ext/datadog_ci_native/datadog_common.h
 - ext/datadog_ci_native/datadog_cov.c
 - ext/datadog_ci_native/datadog_cov.h
-- ext/datadog_ci_native/datadog_source_code.c
-- ext/datadog_ci_native/datadog_source_code.h
+- 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/imemo_helpers.c
+- ext/datadog_ci_native/imemo_helpers.h
+- ext/datadog_ci_native/iseq_collector.c
+- ext/datadog_ci_native/iseq_collector.h
+- ext/datadog_ci_native/ruby_internal.h
 - lib/datadog/ci.rb
 - lib/datadog/ci/async_writer.rb
 - lib/datadog/ci/auto_instrument.rb
@@ -223,6 +230,11 @@ files:
 - lib/datadog/ci/remote/library_settings_client.rb
 - lib/datadog/ci/remote/null_component.rb
 - lib/datadog/ci/remote/slow_test_retries.rb
+- lib/datadog/ci/source_code/constant_resolver.rb
+- lib/datadog/ci/source_code/method_inspect.rb
+- lib/datadog/ci/source_code/path_filter.rb
+- lib/datadog/ci/source_code/static_dependencies.rb
+- lib/datadog/ci/source_code/static_dependencies_extractor.rb
 - lib/datadog/ci/span.rb
 - lib/datadog/ci/test.rb
 - lib/datadog/ci/test_discovery/component.rb
@@ -293,7 +305,6 @@ files:
 - lib/datadog/ci/utils/git.rb
 - lib/datadog/ci/utils/parsing.rb
 - lib/datadog/ci/utils/rum.rb
-- lib/datadog/ci/utils/source_code.rb
 - lib/datadog/ci/utils/stateful.rb
 - lib/datadog/ci/utils/telemetry.rb
 - lib/datadog/ci/utils/test_run.rb

data/ext/datadog_ci_native/datadog_source_code.c

@@ -1,28 +0,0 @@
-#include <ruby.h>
-
-// These structs and functions are not exported by MRI because they are part of
-// the internal API. We declare them here to use them via dynamic linking.
-typedef struct rb_iseq_struct rb_iseq_t;
-const rb_iseq_t *rb_iseqw_to_iseq(VALUE iseqw);
-void rb_iseq_code_location(const rb_iseq_t *, int *first_lineno,
-                           int *first_column, int *last_lineno,
-                           int *last_column);
-
-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_source_code(void) {
-  VALUE mDatadog = rb_define_module("Datadog");
-  VALUE mCI = rb_define_module_under(mDatadog, "CI");
-  VALUE mUtils = rb_define_module_under(mCI, "Utils");
-  VALUE mSourceCode = rb_define_module_under(mUtils, "SourceCode");
-
-  rb_define_singleton_method(mSourceCode, "_native_last_line_from_iseq",
-                             last_line_from_iseq, 1);
-}

data/ext/datadog_ci_native/datadog_source_code.h

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