datadog-ci 1.24.0 → 1.26.0

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

@@ -0,0 +1,49 @@
+require_relative "helpers"
+
+module Datadog
+  module CI
+    module Contrib
+      module Minitest
+        module RunnableMinitest6
+          def self.included(base)
+            base.singleton_class.prepend(ClassMethods)
+          end
+
+          module ClassMethods
+            def run_suite(*args)
+              return super unless datadog_configuration[:enabled]
+              return super if Helpers.parallel?(self)
+
+              test_suite = Helpers.start_test_suite(self)
+
+              results = super
+              return results unless test_suite
+
+              test_suite.finish
+              results
+            end
+
+            def run(klass, method_name, reporter)
+              reporter.prerecord klass, method_name
+              reporter.record ::Minitest.run_one_method(klass, method_name)
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration.ci[:minitest]
+            end
+
+            def _dd_test_visibility_component
+              Datadog.send(:components).test_visibility
+            end
+
+            def _dd_test_retries_component
+              Datadog.send(:components).test_retries
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -35,14 +35,20 @@ module Datadog
               test_visibility_component.start_test_module(Ext::FRAMEWORK)
             end
 
+            def old_run_one_method(klass, method_name)
+              result = klass.new(method_name).run
+              raise "#{klass}#run _must_ return a Result" unless ::Minitest::Result === result
+              result
+            end
+
             def run_one_method(klass, method_name)
-              return super unless datadog_configuration[:enabled]
+              return old_run_one_method(klass, method_name) unless datadog_configuration[:enabled]
 
               # @type var result: untyped
               result = nil
 
               test_retries_component.with_retries do
-                result = super
+                result = old_run_one_method(klass, method_name)
               end
 
               # get the current test suite and mark this method as done, so we can check if all tests were executed

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,13 +38,13 @@ 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
               tags[CI::Ext::Test::TAG_SOURCE_END] = last_line_number.to_s if last_line_number
 
-              test_span = test_visibility_component.trace_test(
+              test_span = _dd_test_visibility_component.trace_test(
                 name,
                 test_suite_name,
                 tags: tags,
@@ -59,7 +59,7 @@ module Datadog
             end
 
             def after_teardown
-              test_span = test_visibility_component.active_test
+              test_span = _dd_test_visibility_component.active_test
               return super unless test_span
 
               finish_with_result(test_span, result_code)
@@ -95,7 +95,7 @@ module Datadog
               Datadog.configuration.ci[:minitest]
             end
 
-            def test_visibility_component
+            def _dd_test_visibility_component
               Datadog.send(:components).test_visibility
             end
           end

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/test_retries/null_component.rb

@@ -13,8 +13,7 @@ module Datadog
         end
 
         def with_retries(&block)
-          no_action = proc {}
-          yield no_action
+          yield
         end
 
         def reset_retries!

data/lib/datadog/ci/version.rb

@@ -4,7 +4,7 @@ module Datadog
   module CI
     module VERSION
       MAJOR = 1
-      MINOR = 24
+      MINOR = 26
       PATCH = 0
       PRE = nil
       BUILD = nil
@@ -22,7 +22,7 @@ module Datadog
       # To allow testing with the next unreleased version of Ruby, the version check is performed
       # as `< #{MAXIMUM_RUBY_VERSION}`, meaning prereleases of MAXIMUM_RUBY_VERSION are allowed
       # but not stable MAXIMUM_RUBY_VERSION releases.
-      MAXIMUM_RUBY_VERSION = "4.0"
+      MAXIMUM_RUBY_VERSION = "4.1"
     end
   end
 end