datadog-ci 1.11.0 → 1.13.0

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "datadog/core/telemetry/logging"
+
 require_relative "git"
 require_relative "environment/extractor"
 
@@ -73,6 +75,7 @@ module Datadog
           return if !repo_url.nil? && !repo_url.empty?
 
           Datadog.logger.error("DD_GIT_REPOSITORY_URL is not set or empty; no repo URL was automatically extracted")
+          Core::Telemetry::Logger.error("DD_GIT_REPOSITORY_URL is not set or empty; no repo URL was automatically extracted")
         end
 
         def validate_git_sha(git_sha)
@@ -89,6 +92,7 @@ module Datadog
           end
 
           Datadog.logger.error(message)
+          Core::Telemetry::Logger.error(message)
         end
       end
     end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Ext
+      # Defines constants for Git tags
+      module RUM
+        ENV_RUM_FLUSH_WAIT_MILLIS = "DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS"
+
+        COOKIE_TEST_EXECUTION_ID = "datadog-ci-visibility-test-execution-id"
+
+        SCRIPT_IS_RUM_ACTIVE = <<~JS
+          return !!window.DD_RUM
+        JS
+        SCRIPT_STOP_RUM_SESSION = <<~JS
+          if (window.DD_RUM && window.DD_RUM.stopSession) {
+            window.DD_RUM.stopSession();
+            return true;
+          } else {
+            return false;
+          }
+        JS
+      end
+    end
+  end
+end

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

@@ -20,6 +20,8 @@ module Datadog
         ENV_RETRY_FAILED_TESTS_TOTAL_LIMIT = "DD_CIVISIBILITY_TOTAL_FLAKY_RETRY_COUNT"
         ENV_RETRY_NEW_TESTS_ENABLED = "DD_CIVISIBILITY_EARLY_FLAKE_DETECTION_ENABLED"
         ENV_TEST_SESSION_NAME = "DD_TEST_SESSION_NAME"
+        ENV_TEST_MANAGEMENT_ENABLED = "DD_TEST_MANAGEMENT_ENABLED"
+        ENV_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES = "DD_TEST_MANAGEMENT_ATTEMPT_TO_FIX_RETRIES"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = %w[

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

@@ -54,11 +54,17 @@ module Datadog
         METRIC_CODE_COVERAGE_IS_EMPTY = "code_coverage.is_empty"
         METRIC_CODE_COVERAGE_FILES = "code_coverage.files"
 
-        METRIC_EFD_UNIQUE_TESTS_REQUEST = "early_flake_detection.request"
-        METRIC_EFD_UNIQUE_TESTS_REQUEST_MS = "early_flake_detection.request_ms"
-        METRIC_EFD_UNIQUE_TESTS_REQUEST_ERRORS = "early_flake_detection.request_errors"
-        METRIC_EFD_UNIQUE_TESTS_RESPONSE_BYTES = "early_flake_detection.response_bytes"
-        METRIC_EFD_UNIQUE_TESTS_RESPONSE_TESTS = "early_flake_detection.response_tests"
+        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"
+        METRIC_KNOWN_TESTS_RESPONSE_BYTES = "known_tests.response_bytes"
+        METRIC_KNOWN_TESTS_RESPONSE_TESTS = "known_tests.response_tests"
+
+        METRIC_TEST_MANAGEMENT_TESTS_REQUEST = "test_management_tests.request"
+        METRIC_TEST_MANAGEMENT_TESTS_REQUEST_MS = "test_management_tests.request_ms"
+        METRIC_TEST_MANAGEMENT_TESTS_REQUEST_ERRORS = "test_management_tests.request_errors"
+        METRIC_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES = "test_management_tests.response_bytes"
+        METRIC_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS = "test_management_tests.response_tests"
 
         METRIC_TEST_SESSION = "test_session"
 
@@ -69,6 +75,7 @@ module Datadog
         TAG_BROWSER_DRIVER = "browser_driver"
         TAG_IS_RUM = "is_rum"
         TAG_IS_RETRY = "is_retry"
+        TAG_RETRY_REASON = "retry_reason"
         TAG_EARLY_FLAKE_DETECTION_ABORT_REASON = "early_flake_detection_abort_reason"
         TAG_IS_NEW = "is_new"
         TAG_LIBRARY = "library"
@@ -79,6 +86,10 @@ module Datadog
         TAG_REQUEST_COMPRESSED = "rq_compressed"
         TAG_RESPONSE_COMPRESSED = "rs_compressed"
         TAG_COMMAND = "command"
+        TAG_IS_ATTEMPT_TO_FIX = "is_attempt_to_fix"
+        TAG_IS_QUARANTINED = "is_quarantined"
+        TAG_IS_TEST_DISABLED = "is_disabled"
+        TAG_HAS_FAILED_ALL_RETRIES = "has_failed_all_retries"
         # tags for git_requests.settings_response metric
         TAG_COVERAGE_ENABLED = "coverage_enabled"
         TAG_ITR_ENABLED = "itr_enabled"
@@ -86,6 +97,7 @@ module Datadog
         TAG_REQUIRE_GIT = "require_git"
         TAG_EARLY_FLAKE_DETECTION_ENABLED = "early_flake_detection_enabled"
         TAG_FLAKY_TEST_RETRIES_ENABLED = "flaky_test_retries_enabled"
+        TAG_KNOWN_TESTS_ENABLED = "known_tests_enabled"
         # tags for test_session metric
         TAG_PROVIDER = "provider"
         TAG_AUTO_INJECTED = "auto_injected"

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

@@ -58,21 +58,42 @@ module Datadog
         # version of the browser, if multiple browsers or multiple versions then this tag is empty
         TAG_BROWSER_VERSION = "test.browser.version"
 
+        # known and new tests
+        TAG_IS_NEW = "test.is_new" # true if test is new (it was not known to Datadog before)
+
         # Tags for retries
         TAG_IS_RETRY = "test.is_retry" # true if test was retried by datadog-ci library
-        TAG_IS_NEW = "test.is_new" # true if test was marked as new by new test retries (early flake detection)
+        TAG_RETRY_REASON = "test.retry_reason" # reason why test was retried
         TAG_EARLY_FLAKE_ENABLED = "test.early_flake.enabled" # true if early flake detection is enabled
         TAG_EARLY_FLAKE_ABORT_REASON = "test.early_flake.abort_reason" # reason why early flake detection was aborted
 
         # Tags for total code coverage
         TAG_CODE_COVERAGE_LINES_PCT = "test.code_coverage.lines_pct"
 
+        # Tags for test managament
+        TAG_TEST_MANAGEMENT_ENABLED = "test.test_management.enabled" # true if test management is enabled, set on test_session_end event
+        TAG_IS_ATTEMPT_TO_FIX = "test.test_management.is_attempt_to_fix" # true if test is marked as "attempted to fix"
+        TAG_IS_TEST_DISABLED = "test.test_management.is_test_disabled" # true if test is marked as disabled in test management view
+        TAG_IS_QUARANTINED = "test.test_management.is_quarantined" # true if test is quarantined in test management view
+        TAG_HAS_FAILED_ALL_RETRIES = "test.has_failed_all_retries" # true if test was retried and none of the retries passed
+        TAG_ATTEMPT_TO_FIX_PASSED = "test.test_management.attempt_to_fix_passed" # true if test was marked as "attempted to fix" and all of the retries passed
+
+        # a set of tag indicating which capabilities (features) are supported by the library
+        module LibraryCapabilities
+          TAG_TEST_IMPACT_ANALYSIS = "_dd.library_capabilities.test_impact_analysis"
+          TAG_EARLY_FLAKE_DETECTION = "_dd.library_capabilities.early_flake_detection"
+          TAG_AUTO_TEST_RETRIES = "_dd.library_capabilities.auto_test_retries"
+          TAG_TEST_MANAGEMENT_QUARANTINE = "_dd.library_capabilities.test_management.quarantine"
+          TAG_TEST_MANAGEMENT_DISABLE = "_dd.library_capabilities.test_management.disable"
+          TAG_TEST_MANAGEMENT_ATTEMPT_TO_FIX = "_dd.library_capabilities.test_management.attempt_to_fix"
+        end
+
         # internal APM tag to mark a span as a test span
         TAG_SPAN_KIND = "span.kind"
         SPAN_KIND_TEST = "test"
 
-        # common tags that are serialized directly in msgpack header in metadata field
-        METADATA_TAG_TEST_SESSION_NAME = "test_session.name"
+        # DD_TEST_SESSION_NAME value
+        TAG_TEST_SESSION_NAME = "test_session.name"
 
         # internal tag indicating if datadog service was configured by the user
         TAG_USER_PROVIDED_TEST_SERVICE = "_dd.test.is_user_provided_service"
@@ -85,7 +106,6 @@ module Datadog
 
         # could be either "test" or "suite" depending on whether we skip individual tests or whole suites
         ITR_TEST_SKIPPING_MODE = "test" # we always skip tests (not suites) in Ruby
-        ITR_TEST_SKIP_REASON = "Skipped by Datadog's intelligent test runner"
         ITR_UNSKIPPABLE_OPTION = :datadog_itr_unskippable
 
         EARLY_FLAKE_FAULTY = "faulty"
@@ -97,12 +117,30 @@ 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"
           BROWSER = "browser"
           BENCHMARK = "benchmark" # DEV: not used yet, will be used when benchmarks are supported
         end
+
+        # possible reasons why a test was retried
+        module RetryReason
+          RETRY_NEW = "efd"
+          RETRY_FAILED = "atr"
+          RETRY_FLAKY_FIXED = "attempt_to_fix"
+        end
+
+        # possible reasons why a test was skipped
+        module SkipReason
+          TEST_IMPACT_ANALYSIS = "Skipped by Datadog's Test Impact Analysis"
+          TEST_MANAGEMENT_DISABLED = "Flaky test is disabled by Datadog"
+        end
       end
     end
   end

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

@@ -38,10 +38,13 @@ module Datadog
         DD_API_SETTINGS_RESPONSE_TESTS_SKIPPING_KEY = "tests_skipping"
         DD_API_SETTINGS_RESPONSE_REQUIRE_GIT_KEY = "require_git"
         DD_API_SETTINGS_RESPONSE_FLAKY_TEST_RETRIES_KEY = "flaky_test_retries_enabled"
+        DD_API_SETTINGS_RESPONSE_KNOWN_TESTS_ENABLED_KEY = "known_tests_enabled"
         DD_API_SETTINGS_RESPONSE_EARLY_FLAKE_DETECTION_KEY = "early_flake_detection"
         DD_API_SETTINGS_RESPONSE_ENABLED_KEY = "enabled"
         DD_API_SETTINGS_RESPONSE_SLOW_TEST_RETRIES_KEY = "slow_test_retries"
         DD_API_SETTINGS_RESPONSE_FAULTY_SESSION_THRESHOLD_KEY = "faulty_session_threshold"
+        DD_API_SETTINGS_RESPONSE_TEST_MANAGEMENT_KEY = "test_management"
+        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_GIT_SEARCH_COMMITS_PATH = "/api/v2/git/repository/search_commits"
@@ -54,6 +57,9 @@ module Datadog
         DD_API_UNIQUE_TESTS_PATH = "/api/v2/ci/libraries/tests"
         DD_API_UNIQUE_TESTS_TYPE = "ci_app_libraries_tests_request"
 
+        DD_API_TEST_MANAGEMENT_TESTS_PATH = "/api/v2/test/libraries/test-management/tests"
+        DD_API_TEST_MANAGEMENT_TESTS_TYPE = "ci_app_libraries_tests_request"
+
         CONTENT_TYPE_MESSAGEPACK = "application/msgpack"
         CONTENT_TYPE_JSON = "application/json"
         CONTENT_TYPE_MULTIPART_FORM_DATA = "multipart/form-data"

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

@@ -32,7 +32,9 @@ module Datadog
           # configure different components in parallel because they might block on HTTP requests
           configuration_workers = [
             Worker.new { test_optimisation.configure(library_configuration, test_session) },
-            Worker.new { test_retries.configure(library_configuration, test_session) }
+            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) }
           ]
 
           # launch configuration workers
@@ -44,6 +46,14 @@ module Datadog
 
         private
 
+        def test_management
+          Datadog.send(:components).test_management
+        end
+
+        def test_visibility
+          Datadog.send(:components).test_visibility
+        end
+
         def test_optimisation
           Datadog.send(:components).test_optimisation
         end

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

@@ -98,6 +98,14 @@ module Datadog
           )
         end
 
+        def known_tests_enabled?
+          return @known_tests_enabled if defined?(@known_tests_enabled)
+
+          @known_tests_enabled = Utils::Parsing.convert_to_bool(
+            payload.fetch(Ext::Transport::DD_API_SETTINGS_RESPONSE_KNOWN_TESTS_ENABLED_KEY, false)
+          )
+        end
+
         def slow_test_retries
           return @slow_test_retries if defined?(@slow_test_retries)
 
@@ -114,8 +122,31 @@ module Datadog
           )
         end
 
+        def test_management_enabled?
+          return @test_management_enabled if defined?(@test_management_enabled)
+
+          @test_management_enabled = Utils::Parsing.convert_to_bool(
+            test_management_payload.fetch(Ext::Transport::DD_API_SETTINGS_RESPONSE_ENABLED_KEY, false)
+          )
+        end
+
+        def attempt_to_fix_retries_count
+          return @attempt_to_fix_retries_count if defined?(@attempt_to_fix_retries_count)
+
+          @attempt_to_fix_retries_count = test_management_payload.fetch(
+            Ext::Transport::DD_API_SETTINGS_RESPONSE_ATTEMPT_TO_FIX_RETRIES_KEY, nil
+          )
+        end
+
         private
 
+        def test_management_payload
+          payload.fetch(
+            Ext::Transport::DD_API_SETTINGS_RESPONSE_TEST_MANAGEMENT_KEY,
+            {}
+          )
+        end
+
         def early_flake_detection_payload
           payload.fetch(
             Ext::Transport::DD_API_SETTINGS_RESPONSE_EARLY_FLAKE_DETECTION_KEY,

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

@@ -62,7 +62,8 @@ module Datadog
               Ext::Telemetry::TAG_EARLY_FLAKE_DETECTION_ENABLED => library_settings.early_flake_detection_enabled?.to_s,
               Ext::Telemetry::TAG_FLAKY_TEST_RETRIES_ENABLED => library_settings.flaky_test_retries_enabled?.to_s,
               Ext::Telemetry::TAG_ITR_ENABLED => library_settings.itr_enabled?.to_s,
-              Ext::Telemetry::TAG_REQUIRE_GIT => library_settings.require_git?.to_s
+              Ext::Telemetry::TAG_REQUIRE_GIT => library_settings.require_git?.to_s,
+              Ext::Telemetry::TAG_KNOWN_TESTS_ENABLED => library_settings.known_tests_enabled?.to_s
             }
           )
 

data/lib/datadog/ci/test.rb

@@ -62,19 +62,37 @@ module Datadog
         get_tag(Ext::Test::TAG_TEST_SESSION_ID)
       end
 
-      # Returns "true" if the test is skipped by the intelligent test runner.
-      # @return [Boolean] true if the test is skipped by the intelligent test runner, false otherwise.
-      def skipped_by_itr?
-        get_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR) == "true"
-      end
-
       # Returns "true" if test span represents a retry.
       # @return [Boolean] true if this test is a retry, false otherwise.
       def is_retry?
         get_tag(Ext::Test::TAG_IS_RETRY) == "true"
       end
 
-      # Marks this test as unskippable by the intelligent test runner.
+      # Returns "true" if this span represents a test that wasn't known to Datadog before.
+      # @return [Boolean] true if this test is a new one, false otherwise.
+      def is_new?
+        get_tag(Ext::Test::TAG_IS_NEW) == "true"
+      end
+
+      # Returns "true" if this test is quarantined by Datadog test management.
+      # @return [Boolean] true if this test is quarantined, false otherwise.
+      def quarantined?
+        get_tag(Ext::Test::TAG_IS_QUARANTINED) == "true"
+      end
+
+      # Returns "true" if this test is disabled by Datadog test management.
+      # @return [Boolean] true if this test is disabled, false otherwise.
+      def disabled?
+        get_tag(Ext::Test::TAG_IS_TEST_DISABLED) == "true"
+      end
+
+      # Returns "true" if this flaky test has fixing attempts (determined by Datadog backend).
+      # @return [Boolean] true if this test is attempted to be fixed.
+      def attempt_to_fix?
+        get_tag(Ext::Test::TAG_IS_ATTEMPT_TO_FIX) == "true"
+      end
+
+      # Marks this test as unskippable by the Test Impact Analysis.
       # This must be done before the test execution starts.
       #
       # Examples of tests that should be unskippable:
@@ -88,7 +106,7 @@ module Datadog
         TestOptimisation::Telemetry.itr_unskippable
         set_tag(Ext::Test::TAG_ITR_UNSKIPPABLE, "true")
 
-        if skipped_by_itr?
+        if skipped_by_test_impact_analysis?
           clear_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR)
 
           TestOptimisation::Telemetry.itr_forced_run
@@ -110,7 +128,13 @@ module Datadog
       def failed!(exception: nil)
         super
 
-        record_test_result(Ext::Test::Status::FAIL)
+        # 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
       end
 
       # Sets the status of the span to "skip".
@@ -148,6 +172,40 @@ module Datadog
         !!test_suite&.any_test_retry_passed?(datadog_test_id)
       end
 
+      # @internal
+      def all_executions_failed?
+        !!test_suite&.all_executions_failed?(datadog_test_id)
+      end
+
+      # @internal
+      def all_executions_passed?
+        !!test_suite&.all_executions_passed?(datadog_test_id)
+      end
+
+      # @internal
+      def datadog_skip_reason
+        if skipped_by_test_impact_analysis?
+          Ext::Test::SkipReason::TEST_IMPACT_ANALYSIS
+        elsif disabled? || quarantined?
+          Ext::Test::SkipReason::TEST_MANAGEMENT_DISABLED
+        end
+      end
+
+      # @internal
+      def should_skip?
+        skipped_by_test_impact_analysis? || (disabled? && !attempt_to_fix?)
+      end
+
+      # @internal
+      def should_ignore_failures?
+        quarantined? || disabled? || any_retry_passed?
+      end
+
+      # @internal
+      def skipped_by_test_impact_analysis?
+        get_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR) == "true"
+      end
+
       private
 
       def record_test_result(datadog_status)

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../ext/telemetry"
+require_relative "../ext/test"
+require_relative "../utils/telemetry"
+require_relative "../utils/test_run"
+
+module Datadog
+  module CI
+    module TestManagement
+      # Test management is a feature that lets people manage their flaky tests in Datadog.
+      # It includes:
+      # - marking test as quarantined causes test to continue running but not failing the build
+      # - marking test as disabled causes test to be skipped
+      # - marking test as "attempted to fix" causes test to be retried many times to confirm that fix worked
+      class Component
+        attr_reader :enabled, :tests_properties
+
+        def initialize(enabled:, tests_properties_client:)
+          @enabled = enabled
+
+          @tests_properties_client = tests_properties_client
+          @tests_properties = {}
+        end
+
+        def configure(library_settings, test_session)
+          @enabled &&= library_settings.test_management_enabled?
+
+          return unless @enabled
+
+          test_session.set_tag(Ext::Test::TAG_TEST_MANAGEMENT_ENABLED, "true")
+
+          @tests_properties = @tests_properties_client.fetch(test_session)
+
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
+            @tests_properties.count.to_f
+          )
+        end
+
+        def tag_test_from_properties(test_span)
+          return unless @enabled
+
+          datadog_test_id = Utils::TestRun.datadog_test_id(test_span.name, test_span.test_suite_name)
+          test_properties = @tests_properties[datadog_test_id]
+
+          if test_properties.nil?
+            Datadog.logger.debug { "Test properties not found for test: #{datadog_test_id}" }
+            return
+          end
+
+          Datadog.logger.debug { "Test properties for test #{datadog_test_id} are: [#{test_properties}]" }
+
+          test_span.set_tag(Ext::Test::TAG_IS_QUARANTINED, "true") if test_properties["quarantined"]
+          test_span.set_tag(Ext::Test::TAG_IS_TEST_DISABLED, "true") if test_properties["disabled"]
+          test_span.set_tag(Ext::Test::TAG_IS_ATTEMPT_TO_FIX, "true") if test_properties["attempt_to_fix"]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../ext/telemetry"
+require_relative "../utils/telemetry"
+
+module Datadog
+  module CI
+    module TestManagement
+      class NullComponent
+        attr_reader :enabled, :tests_properties
+
+        def initialize
+          @enabled = false
+          @tests_properties = {}
+        end
+
+        def configure(_, _)
+        end
+
+        def tag_test_from_properties(_)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "../ext/telemetry"
+require_relative "../ext/transport"
+require_relative "../transport/telemetry"
+require_relative "../utils/parsing"
+require_relative "../utils/telemetry"
+require_relative "../utils/test_run"
+
+module Datadog
+  module CI
+    module TestManagement
+      # fetches and stores a map of tests to their test management properties from the backend
+      class TestsProperties
+        class Response
+          def initialize(http_response)
+            @http_response = http_response
+            @json = nil
+          end
+
+          def ok?
+            resp = @http_response
+            !resp.nil? && resp.ok?
+          end
+
+          def tests
+            tests_map = {}
+
+            payload
+              .fetch("data", {})
+              .fetch("attributes", {})
+              .fetch("modules", {})
+              .each do |_test_module, module_hash|
+                module_hash
+                  .fetch("suites", {})
+                  .each do |test_suite, suite_hash|
+                    suite_hash.fetch("tests", {})
+                      .each do |test_name, properties_hash|
+                        properties = properties_hash.fetch("properties", {})
+                        properties.transform_values! { |v| Utils::Parsing.convert_to_bool(v) }
+
+                        tests_map[Utils::TestRun.datadog_test_id(test_name, test_suite)] = properties
+                      end
+                  end
+              end
+
+            tests_map
+          end
+
+          private
+
+          def payload
+            cached = @json
+            return cached unless cached.nil?
+
+            resp = @http_response
+            return @json = {} if resp.nil? || !ok?
+
+            begin
+              @json = JSON.parse(resp.payload)
+            rescue JSON::ParserError => e
+              Datadog.logger.error(
+                "Failed to parse test management tests response payload: #{e}. Payload was: #{resp.payload}"
+              )
+              @json = {}
+            end
+          end
+        end
+
+        def initialize(api: nil)
+          @api = api
+        end
+
+        def fetch(test_session)
+          api = @api
+          return {} unless api
+
+          request_payload = payload(test_session)
+          Datadog.logger.debug("Fetching test management tests with request: #{request_payload}")
+
+          http_response = api.api_request(
+            path: Ext::Transport::DD_API_TEST_MANAGEMENT_TESTS_PATH,
+            payload: request_payload
+          )
+
+          CI::Transport::Telemetry.api_requests(
+            Ext::Telemetry::METRIC_TEST_MANAGEMENT_TESTS_REQUEST,
+            1,
+            compressed: http_response.request_compressed
+          )
+          Utils::Telemetry.distribution(Ext::Telemetry::METRIC_TEST_MANAGEMENT_TESTS_REQUEST_MS, http_response.duration_ms)
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_TEST_MANAGEMENT_TESTS_RESPONSE_BYTES,
+            http_response.response_size.to_f,
+            {Ext::Telemetry::TAG_RESPONSE_COMPRESSED => http_response.gzipped_content?.to_s}
+          )
+
+          unless http_response.ok?
+            CI::Transport::Telemetry.api_requests_errors(
+              Ext::Telemetry::METRIC_TEST_MANAGEMENT_TESTS_REQUEST_ERRORS,
+              1,
+              error_type: http_response.telemetry_error_type,
+              status_code: http_response.code
+            )
+          end
+
+          Response.new(http_response).tests
+        end
+
+        private
+
+        def payload(test_session)
+          {
+            "data" => {
+              "id" => Datadog::Core::Environment::Identity.id,
+              "type" => Ext::Transport::DD_API_TEST_MANAGEMENT_TESTS_TYPE,
+              "attributes" => {
+                "repository_url" => test_session.git_repository_url
+              }
+            }
+          }.to_json
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require "pp"
 
+require "datadog/core/telemetry/logging"
 require "datadog/core/utils/forking"
 
 require_relative "../ext/test"
@@ -19,7 +20,7 @@ require_relative "telemetry"
 module Datadog
   module CI
     module TestOptimisation
-      # Intelligent test runner implementation
+      # Test Impact Analysis implementation
       # Integrates with backend to provide test impact analysis data and
       # skip tests that are not impacted by the changes
       class Component
@@ -155,7 +156,7 @@ module Datadog
 
           if skippable?(test)
             if forked?
-              Datadog.logger.warn { "Intelligent test runner is not supported for forking test runners yet" }
+              Datadog.logger.warn { "Test Impact Analysis is not supported for forking test runners yet" }
               return
             end
 
@@ -171,7 +172,7 @@ module Datadog
           @mutex.synchronize do
             @total_tests_count += 1
 
-            return if !test.skipped? || !test.skipped_by_itr?
+            return if !test.skipped? || !test.skipped_by_test_impact_analysis?
 
             if forked?
               Datadog.logger.warn { "ITR is not supported for forking test runners yet" }
@@ -224,6 +225,7 @@ module Datadog
           Datadog.logger.debug("Loaded Datadog code coverage collector, using coverage mode: #{code_coverage_mode}")
         rescue LoadError => e
           Datadog.logger.error("Failed to load coverage collector: #{e}. Code coverage will not be collected.")
+          Core::Telemetry::Logger.report(e, description: "Failed to load coverage collector")
 
           @code_coverage_enabled = false
         end