datadog-ci 1.25.0 → 1.27.0

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

@@ -6,6 +6,7 @@ module Datadog
       # Defines constants for test tags
       module Settings
         ENV_MODE_ENABLED = "DD_TRACE_CI_ENABLED"
+        ENV_ENABLED = "DD_CIVISIBILITY_ENABLED"
         ENV_AGENTLESS_MODE_ENABLED = "DD_CIVISIBILITY_AGENTLESS_ENABLED"
         ENV_AGENTLESS_URL = "DD_CIVISIBILITY_AGENTLESS_URL"
         ENV_EXPERIMENTAL_TEST_SUITE_LEVEL_VISIBILITY_ENABLED = "DD_CIVISIBILITY_EXPERIMENTAL_TEST_SUITE_LEVEL_VISIBILITY_ENABLED"
@@ -29,6 +30,8 @@ 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"
+        ENV_CODE_COVERAGE_REPORT_UPLOAD_ENABLED = "DD_CIVISIBILITY_CODE_COVERAGE_REPORT_UPLOAD_ENABLED"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = %w[

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

@@ -54,6 +54,11 @@ module Datadog
         METRIC_CODE_COVERAGE_IS_EMPTY = "code_coverage.is_empty"
         METRIC_CODE_COVERAGE_FILES = "code_coverage.files"
 
+        METRIC_COVERAGE_UPLOAD_REQUEST = "coverage_upload.request"
+        METRIC_COVERAGE_UPLOAD_REQUEST_ERRORS = "coverage_upload.request_errors"
+        METRIC_COVERAGE_UPLOAD_REQUEST_MS = "coverage_upload.request_ms"
+        METRIC_COVERAGE_UPLOAD_REQUEST_BYTES = "coverage_upload.request_bytes"
+
         METRIC_KNOWN_TESTS_REQUEST = "known_tests.request"
         METRIC_KNOWN_TESTS_REQUEST_MS = "known_tests.request_ms"
         METRIC_KNOWN_TESTS_REQUEST_ERRORS = "known_tests.request_errors"

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

@@ -155,11 +155,6 @@ module Datadog
           SKIP = "skip"
         end
 
-        # test statuses that we use for execution stats but don't report to Datadog (e.g. fail_ignored)
-        module ExecutionStatsStatus
-          FAIL_IGNORED = "fail_ignored"
-        end
-
         # test types (e.g. test, benchmark, browser)
         module Type
           TEST = "test"

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

@@ -28,6 +28,9 @@ module Datadog
         TEST_COVERAGE_INTAKE_HOST_PREFIX = "citestcov-intake"
         TEST_COVERAGE_INTAKE_PATH = "/api/v2/citestcov"
 
+        CODE_COVERAGE_REPORT_INTAKE_HOST_PREFIX = "ci-intake"
+        CODE_COVERAGE_REPORT_INTAKE_PATH = "/api/v2/cicovreprt"
+
         LOGS_INTAKE_HOST_PREFIX = "http-intake.logs"
 
         DD_API_HOST_PREFIX = "api"
@@ -49,6 +52,7 @@ module Datadog
         DD_API_SETTINGS_RESPONSE_ATTEMPT_TO_FIX_RETRIES_KEY = "attempt_to_fix_retries"
         DD_API_SETTINGS_RESPONSE_DEFAULT = {DD_API_SETTINGS_RESPONSE_ITR_ENABLED_KEY => false}.freeze
         DD_API_SETTINGS_RESPONSE_IMPACTED_TESTS_ENABLED_KEY = "impacted_tests_enabled"
+        DD_API_SETTINGS_RESPONSE_COVERAGE_REPORT_UPLOAD_KEY = "coverage_report_upload_enabled"
 
         DD_API_GIT_SEARCH_COMMITS_PATH = "/api/v2/git/repository/search_commits"
 

data/lib/datadog/ci/git/cli.rb

@@ -25,6 +25,10 @@ module Datadog
 
         # Execute a git command with optional stdin input and timeout
         #
+        # All git commands are executed with the `-c safe.directory` option
+        # to handle cases where the repository is owned by a different user
+        # (common in CI environments with containerized builds).
+        #
         # @param cmd [Array<String>] The git command as an array of strings
         # @param stdin [String, nil] Optional stdin data to pass to the command
         # @param timeout [Integer] Timeout in seconds for the command execution
@@ -33,7 +37,11 @@ module Datadog
         def self.exec_git_command(cmd, stdin: nil, timeout: SHORT_TIMEOUT)
           # @type var out: String
           # @type var status: Process::Status?
-          out, status = Utils::Command.exec_command(["git"] + cmd, stdin_data: stdin, timeout: timeout)
+          out, status = Utils::Command.exec_command(
+            ["git", "-c", "safe.directory=#{safe_directory}"] + cmd,
+            stdin_data: stdin,
+            timeout: timeout
+          )
 
           if status.nil? || !status.success?
             # Convert command to string representation for error message
@@ -50,6 +58,56 @@ module Datadog
 
           out
         end
+
+        # Returns the directory to use for git's safe.directory config.
+        # This is cached to avoid repeated filesystem lookups.
+        #
+        # Traverses up from current directory to find the nearest .git folder
+        # and returns its parent (the repository root). Falls back to current
+        # working directory if no .git folder is found.
+        #
+        # @return [String] The safe directory path
+        def self.safe_directory
+          return @safe_directory if defined?(@safe_directory)
+
+          @safe_directory = find_git_directory(Dir.pwd)
+          Datadog.logger.debug { "Git safe.directory configured to: #{@safe_directory}" }
+          @safe_directory
+        end
+
+        # Traverses up from the given directory to find the nearest .git folder or file.
+        # Returns the repository root (parent of .git) if found, otherwise the original directory.
+        #
+        # Note: .git can be either a directory (regular repos) or a file (worktrees/submodules).
+        # In worktrees and submodules, .git is a file containing a pointer to the actual git directory.
+        #
+        # @param start_dir [String] The directory to start searching from
+        # @return [String] The repository root path or the start directory if not found
+        def self.find_git_directory(start_dir)
+          Datadog.logger.debug { "Searching for .git starting from: #{start_dir}" }
+          current_dir = File.expand_path(start_dir)
+
+          loop do
+            git_path = File.join(current_dir, ".git")
+
+            # Check for both directory (.git in regular repos) and file (.git in worktrees/submodules)
+            if File.exist?(git_path)
+              Datadog.logger.debug { "Found .git at: #{git_path} (#{File.directory?(git_path) ? "directory" : "file"})" }
+              return current_dir
+            end
+
+            parent_dir = File.dirname(current_dir)
+
+            # Reached the root directory
+            break if parent_dir == current_dir
+
+            current_dir = parent_dir
+          end
+
+          # Fallback to original directory if no .git found
+          Datadog.logger.debug { "No .git found, using fallback: #{start_dir}" }
+          start_dir
+        end
       end
     end
   end

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

@@ -29,7 +29,8 @@ module Datadog
             Worker.new { test_retries.configure(@library_configuration, test_session) },
             Worker.new { test_visibility.configure(@library_configuration, test_session) },
             Worker.new { test_management.configure(@library_configuration, test_session) },
-            Worker.new { impacted_tests_detection.configure(@library_configuration, test_session) }
+            Worker.new { impacted_tests_detection.configure(@library_configuration, test_session) },
+            Worker.new { code_coverage.configure(@library_configuration) }
           ]
 
           # launch configuration workers
@@ -123,6 +124,10 @@ module Datadog
         def git_tree_upload_worker
           Datadog.send(:components).git_tree_upload_worker
         end
+
+        def code_coverage
+          Datadog.send(:components).code_coverage
+        end
       end
     end
   end

data/lib/datadog/ci/remote/library_settings.rb

@@ -117,6 +117,14 @@ module Datadog
           )
         end
 
+        def coverage_report_upload_enabled?
+          return @coverage_report_upload_enabled if defined?(@coverage_report_upload_enabled)
+
+          @coverage_report_upload_enabled = Utils::Parsing.convert_to_bool(
+            payload.fetch(Ext::Transport::DD_API_SETTINGS_RESPONSE_COVERAGE_REPORT_UPLOAD_KEY, false)
+          )
+        end
+
         def slow_test_retries
           return @slow_test_retries if defined?(@slow_test_retries)
 

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.rb

@@ -12,6 +12,11 @@ module Datadog
     #
     # @public_api
     class Test < Span
+      # Context IDs for this test (used for TIA context coverage merging).
+      # Contains list of context identifiers from outermost to innermost.
+      # @return [Array<String>] list of context IDs
+      attr_accessor :context_ids
+
       # @return [String] the name of the test.
       def name
         get_tag(Ext::Test::TAG_NAME)
@@ -166,13 +171,7 @@ module Datadog
       def failed!(exception: nil)
         super
 
-        # if we should ignore failures, we consider this test to be passed
-        if should_ignore_failures?
-          # use a special "fail_ignored" status to mark this test as failed but ignored
-          record_test_result(Ext::Test::ExecutionStatsStatus::FAIL_IGNORED)
-        else
-          record_test_result(Ext::Test::Status::FAIL)
-        end
+        record_test_result(Ext::Test::Status::FAIL)
       end
 
       # Sets the status of the span to "skip".
@@ -236,7 +235,10 @@ module Datadog
 
       # @internal
       def should_ignore_failures?
-        quarantined? || disabled? || any_retry_passed?
+        return true if quarantined? || disabled?
+        return false if attempt_to_fix?
+
+        any_retry_passed?
       end
 
       # @internal
@@ -249,16 +251,9 @@ module Datadog
         status = get_tag(Ext::Test::TAG_STATUS)
         return if status.nil?
 
-        if [Ext::Test::Status::PASS, Ext::Test::Status::SKIP].include?(status)
-          set_tag(Ext::Test::TAG_FINAL_STATUS, status)
-          return
-        end
-
-        if should_ignore_failures?
-          set_tag(Ext::Test::TAG_FINAL_STATUS, Ext::Test::Status::PASS)
-        else
-          set_tag(Ext::Test::TAG_FINAL_STATUS, Ext::Test::Status::FAIL)
-        end
+        final_status = compute_final_status(status)
+        set_tag(Ext::Test::TAG_FINAL_STATUS, final_status)
+        test_suite&.record_test_final_status(datadog_test_id, final_status)
       end
 
       # @internal
@@ -272,6 +267,20 @@ module Datadog
 
       private
 
+      def compute_final_status(status)
+        # Skip status is always preserved
+        return status if status == Ext::Test::Status::SKIP
+
+        # For attempt_to_fix tests (not quarantined/disabled), any failure means the fix didn't work
+        if attempt_to_fix? && !quarantined? && !disabled?
+          return all_executions_passed? ? Ext::Test::Status::PASS : Ext::Test::Status::FAIL
+        end
+
+        return status if status == Ext::Test::Status::PASS
+
+        should_ignore_failures? ? Ext::Test::Status::PASS : Ext::Test::Status::FAIL
+      end
+
       def record_test_result(datadog_status)
         # if this test was already executed in this test suite, mark it as retried
         if test_suite&.test_executed?(datadog_test_id)

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

@@ -75,6 +75,15 @@ module Datadog
           test_properties.fetch("attempt_to_fix", false)
         end
 
+        def disabled?(datadog_fqn_test_id)
+          return false unless @enabled
+
+          test_properties = @tests_properties[datadog_fqn_test_id]
+          return false if test_properties.nil?
+
+          test_properties.fetch("disabled", false)
+        end
+
         def restore_state_from_datadog_test_runner
           Datadog.logger.debug { "Restoring test management tests from DDTest cache" }