datadog-ci 1.25.0 → 1.27.0

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

@@ -19,6 +19,14 @@ module Datadog
 
         def tag_test_from_properties(_)
         end
+
+        def attempt_to_fix?(_datadog_fqn_test_id)
+          false
+        end
+
+        def disabled?(_datadog_fqn_test_id)
+          false
+        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
@@ -65,6 +69,16 @@ module Datadog
 
           @mutex = Mutex.new
 
+          # Context coverage: stores coverage collected during before(:context)/before(:all) hooks
+          # keyed by context_id (e.g., RSpec scoped_id for example groups)
+          # Only used when use_single_threaded_coverage is false (multi-threaded mode)
+          @context_coverages = {}
+          @context_coverages_mutex = Mutex.new
+
+          # Currently active context ID for context coverage collection
+          @current_context_id = nil
+          @current_context_id_mutex = Mutex.new
+
           Datadog.logger.debug("TestOptimisation initialized with enabled: #{@enabled}")
         end
 
@@ -82,7 +96,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
@@ -109,47 +127,154 @@ module Datadog
           @code_coverage_enabled
         end
 
-        def start_coverage(test)
+        # Starts coverage collection.
+        # This is a low-level method that only starts the collector.
+        #
+        # @return [void]
+        def start_coverage
           return if !enabled? || !code_coverage?
 
-          Telemetry.code_coverage_started(test)
           coverage_collector&.start
         end
 
-        def stop_coverage(test)
+        # Stops coverage collection and returns raw coverage data.
+        # This is a low-level method that only stops the collector.
+        #
+        # @return [Hash, nil] Raw coverage data or nil
+        def stop_coverage
+          return if !enabled? || !code_coverage?
+
+          coverage_collector&.stop
+        end
+
+        # Called when a test context (e.g., RSpec example group with before(:context)) starts.
+        # Starts collecting coverage that will be merged into all tests within this context.
+        #
+        # @param context_id [String] A stable identifier for the context (e.g., RSpec scoped_id)
+        # @return [void]
+        def on_test_context_started(context_id)
+          return unless context_coverage_enabled?
+
+          # Stop and store any existing context coverage before starting new one.
+          # This ensures that outer context coverage is preserved when nested contexts start.
+          stop_context_coverage_and_store
+
+          Datadog.logger.debug { "Starting context coverage collection for context [#{context_id}]" }
+
+          # Store the context_id we're collecting for
+          @current_context_id_mutex.synchronize do
+            @current_context_id = context_id
+          end
+
+          coverage_collector&.start
+        end
+
+        # Called when a test starts within a context. This method:
+        # 1. Stops any in-progress context coverage collection and stores it
+        # 2. Starts coverage collection for the test itself
+        #
+        # @param test [Datadog::CI::Test] The test that is starting
+        # @return [void]
+        def on_test_started(test)
           return if !enabled? || !code_coverage?
 
+          # Stop any in-progress context coverage and store it
+          stop_context_coverage_and_store
+
+          Telemetry.code_coverage_started(test)
+
+          context_ids = test.context_ids || []
+
+          Datadog.logger.debug do
+            "Starting test coverage for [#{test.name}] with context chain: #{context_ids.inspect}"
+          end
+
+          coverage_collector&.start
+        end
+
+        # Called when a test finishes. This method:
+        # 1. Stops test coverage collection
+        # 2. Merges context coverage from all relevant contexts
+        # 3. Writes the combined coverage event
+        # 4. Records ITR statistics if test was skipped by TIA
+        #
+        # @param test [Datadog::CI::Test] The test that finished
+        # @param context [Datadog::CI::TestVisibility::Context] The test visibility context for ITR stats
+        # @return [Datadog::CI::TestOptimisation::Coverage::Event, nil] The coverage event or nil
+        def on_test_finished(test, context)
+          return unless enabled?
+
+          # Handle ITR statistics
+          if test.skipped_by_test_impact_analysis?
+            Telemetry.itr_skipped
+
+            context.incr_tests_skipped_by_tia_count
+          end
+
+          # Handle code coverage
+          return unless code_coverage?
           Telemetry.code_coverage_finished(test)
 
           coverage = coverage_collector&.stop
 
           # if test was skipped, we discard coverage data
           return if test.skipped?
+          coverage ||= {}
 
-          if coverage.nil? || coverage.empty?
+          # Merge context coverage from all relevant contexts
+          context_ids = test.context_ids || []
+          merge_context_coverages_into_test(coverage, context_ids)
+
+          if coverage.empty?
             Telemetry.code_coverage_is_empty
             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(
+          coverage_event = Coverage::Event.new(
             test_id: test.id.to_s,
             test_suite_id: test.test_suite_id.to_s,
             test_session_id: test.test_session_id.to_s,
             coverage: coverage
           )
 
-          Datadog.logger.debug { "Writing coverage event \n #{event.pretty_inspect}" }
+          Datadog.logger.debug { "Writing coverage event \n #{coverage_event.pretty_inspect}" }
+
+          write(coverage_event)
+
+          coverage_event
+        end
+
+        # Clears stored context coverage for a specific context.
+        # Should be called when a context finishes (e.g., after(:context) completes).
+        #
+        # @param context_id [String] The context ID to clear
+        # @return [void]
+        def clear_context_coverage(context_id)
+          return unless context_coverage_enabled?
 
-          write(event)
+          @context_coverages_mutex.synchronize do
+            @context_coverages.delete(context_id)
 
-          event
+            Datadog.logger.debug { "Cleared context coverage for [#{context_id}]" }
+          end
+        end
+
+        # Returns whether context coverage collection is enabled.
+        # Context coverage is disabled in single-threaded mode.
+        #
+        # @return [Boolean]
+        def context_coverage_enabled?
+          enabled? && code_coverage? && !@use_single_threaded_coverage
         end
 
         def skippable?(datadog_test_id)
@@ -170,14 +295,6 @@ module Datadog
           end
         end
 
-        def on_test_finished(test, context)
-          return if !test.skipped? || !test.skipped_by_test_impact_analysis?
-
-          Telemetry.itr_skipped
-
-          context.incr_tests_skipped_by_tia_count
-        end
-
         def write_test_session_tags(test_session, skipped_tests_count)
           return if !enabled?
 
@@ -323,6 +440,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)
@@ -360,6 +496,52 @@ module Datadog
         def git_tree_upload_worker
           Datadog.send(:components).git_tree_upload_worker
         end
+
+        # Stops any in-progress context coverage collection and stores it.
+        # Called when a test starts to capture coverage from before(:context) hooks.
+        def stop_context_coverage_and_store
+          return unless context_coverage_enabled?
+
+          context_id = @current_context_id_mutex.synchronize do
+            id = @current_context_id
+            @current_context_id = nil
+            id
+          end
+          return if context_id.nil?
+
+          coverage = coverage_collector&.stop
+          return if coverage.nil? || coverage.empty?
+
+          @context_coverages_mutex.synchronize do
+            @context_coverages[context_id] = coverage
+          end
+
+          Datadog.logger.debug do
+            "Stored context coverage for [#{context_id}] with #{coverage.size} files"
+          end
+        end
+
+        # Merges context coverage from all relevant contexts into the test's coverage.
+        #
+        # @param coverage [Hash] The test's coverage hash to merge into
+        # @param context_ids [Array<String>] List of context IDs to merge coverage from
+        def merge_context_coverages_into_test(coverage, context_ids)
+          return if @use_single_threaded_coverage
+          return if context_ids.empty?
+
+          @context_coverages_mutex.synchronize do
+            context_ids.each do |context_id|
+              context_coverage = @context_coverages[context_id]
+              next unless context_coverage
+
+              coverage.merge!(context_coverage)
+            end
+          end
+
+          Datadog.logger.debug do
+            "Merged context coverage for contexts: #{context_ids.inspect} into test coverage"
+          end
+        end
       end
     end
   end

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

@@ -34,21 +34,35 @@ module Datadog
           false
         end
 
-        def start_coverage(_test)
+        def start_coverage
         end
 
-        def stop_coverage(_test)
+        def stop_coverage
           nil
         end
 
-        def mark_if_skippable(_test)
+        def on_test_context_started(_context_id)
         end
 
-        def skippable?(_datadog_test_id)
-          false
+        def on_test_started(_test)
         end
 
         def on_test_finished(_test, _context)
+          nil
+        end
+
+        def clear_context_coverage(_context_id)
+        end
+
+        def context_coverage_enabled?
+          false
+        end
+
+        def mark_if_skippable(_test)
+        end
+
+        def skippable?(_datadog_test_id)
+          false
         end
 
         def write_test_session_tags(_test_session, _skipped_tests_count)

data/lib/datadog/ci/test_suite.rb

@@ -19,6 +19,10 @@ module Datadog
         # counts how many times every test in this suite was executed with each status:
         #   { "MySuite.mytest.a:1" => { "pass" => 3, "fail" => 2 } }
         @execution_stats_per_test = {}
+
+        # tracks final status for each test (the status that is reported after all retries):
+        #   { "MySuite.mytest.a:1" => "pass" }
+        @final_statuses_per_test = {}
       end
 
       # Finishes this test suite.
@@ -42,6 +46,13 @@ module Datadog
         end
       end
 
+      # @internal
+      def record_test_final_status(test_id, final_status)
+        synchronize do
+          @final_statuses_per_test[test_id] = final_status
+        end
+      end
+
       # @internal
       def any_passed?
         synchronize do
@@ -63,8 +74,7 @@ module Datadog
       def all_executions_failed?(test_id)
         synchronize do
           stats = @execution_stats_per_test[test_id]
-          stats && (stats[Ext::Test::Status::FAIL] > 0 || stats[Ext::Test::ExecutionStatsStatus::FAIL_IGNORED] > 0) &&
-            stats[Ext::Test::Status::PASS] == 0
+          stats && stats[Ext::Test::Status::FAIL] > 0 && stats[Ext::Test::Status::PASS] == 0
         end
       end
 
@@ -72,8 +82,7 @@ module Datadog
       def all_executions_passed?(test_id)
         synchronize do
           stats = @execution_stats_per_test[test_id]
-          stats && stats[Ext::Test::Status::PASS] > 0 && stats[Ext::Test::Status::FAIL] == 0 &&
-            stats[Ext::Test::ExecutionStatsStatus::FAIL_IGNORED] == 0
+          stats && stats[Ext::Test::Status::PASS] > 0 && stats[Ext::Test::Status::FAIL] == 0
         end
       end
 
@@ -106,9 +115,9 @@ module Datadog
 
       def set_status_from_stats!
         synchronize do
-          # count how many tests passed, failed and skipped
-          test_suite_stats = @execution_stats_per_test.each_with_object(Hash.new(0)) do |(_test_id, stats), acc|
-            acc[derive_test_status_from_execution_stats(stats)] += 1
+          # count how many tests have each final status
+          test_suite_stats = @final_statuses_per_test.each_with_object(Hash.new(0)) do |(_test_id, final_status), acc|
+            acc[final_status] += 1
           end
 
           # test suite is considered failed if at least one test failed
@@ -123,20 +132,6 @@ module Datadog
           end
         end
       end
-
-      def derive_test_status_from_execution_stats(test_execution_stats)
-        # test is passed if it passed at least once or it failed but fail was ignored
-        if test_execution_stats[Ext::Test::Status::PASS] > 0 ||
-            test_execution_stats[Ext::Test::ExecutionStatsStatus::FAIL_IGNORED] > 0
-          Ext::Test::Status::PASS
-        # if test was never passed, it is failed if it failed at least once
-        elsif test_execution_stats[Ext::Test::Status::FAIL] > 0
-          Ext::Test::Status::FAIL
-        # otherwise it is skipped
-        else
-          Ext::Test::Status::SKIP
-        end
-      end
     end
   end
 end

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

@@ -302,7 +302,7 @@ module Datadog
           test_management.tag_test_from_properties(test)
 
           test_optimisation.mark_if_skippable(test)
-          test_optimisation.start_coverage(test)
+          test_optimisation.on_test_started(test)
 
           test_retries.record_test_started(test)
         end
@@ -328,7 +328,6 @@ module Datadog
         end
 
         def on_test_finished(test)
-          test_optimisation.stop_coverage(test)
           test_optimisation.on_test_finished(test, maybe_remote_context)
 
           validate_source_location(test)

data/lib/datadog/ci/test_visibility/known_tests.rb

@@ -45,6 +45,14 @@ module Datadog
             res
           end
 
+          def cursor
+            page_info.fetch("cursor", nil)
+          end
+
+          def has_next?
+            page_info.fetch("has_next", false)
+          end
+
           private
 
           def initialize(http_response, json)
@@ -66,6 +74,13 @@ module Datadog
               @json = {}
             end
           end
+
+          def page_info
+            payload
+              .fetch("data", {})
+              .fetch("attributes", {})
+              .fetch("page_info", {})
+          end
         end
 
         def initialize(dd_env:, api: nil, config_tags: {})
@@ -78,8 +93,45 @@ module Datadog
           api = @api
           return Set.new unless api
 
-          request_payload = payload(test_session)
-          Datadog.logger.debug("Fetching unique known tests with request: #{request_payload}")
+          result = Set.new
+          page_state = nil
+          page_number = 1
+
+          loop do
+            Datadog.logger.debug { "Fetching known tests page ##{page_number}#{" with cursor" if page_state}" }
+
+            response = fetch_page(api, test_session, page_state: page_state)
+
+            unless response.ok?
+              Datadog.logger.debug(
+                "Failed to fetch known tests page ##{page_number}, bailing out of known tests fetch. " \
+                "Early flake detection will not work."
+              )
+              return Set.new
+            end
+
+            page_tests = response.tests
+            result.merge(page_tests)
+            Datadog.logger.debug { "Received #{page_tests.size} known tests from page ##{page_number} (total so far: #{result.size})" }
+
+            unless response.has_next?
+              Datadog.logger.debug { "Stopping known tests fetch: no more pages after page ##{page_number}" }
+              break
+            end
+
+            page_state = response.cursor
+            page_number += 1
+          end
+
+          Datadog.logger.debug { "Finished fetching known tests: #{result.size} tests total from #{page_number} page(s)" }
+          result
+        end
+
+        private
+
+        def fetch_page(api, test_session, page_state: nil)
+          request_payload = payload(test_session, page_state: page_state)
+          Datadog.logger.debug { "Known tests request payload: #{request_payload}" }
 
           http_response = api.api_request(
             path: Ext::Transport::DD_API_UNIQUE_TESTS_PATH,
@@ -107,12 +159,12 @@ module Datadog
             )
           end
 
-          Response.from_http_response(http_response).tests
+          Response.from_http_response(http_response)
         end
 
-        private
+        def payload(test_session, page_state: nil)
+          page_info = page_state ? {"page_state" => page_state} : {}
 
-        def payload(test_session)
           {
             "data" => {
               "id" => Datadog::Core::Environment::Identity.id,
@@ -129,7 +181,8 @@ module Datadog
                   Ext::Test::TAG_RUNTIME_NAME => test_session.runtime_name,
                   Ext::Test::TAG_RUNTIME_VERSION => test_session.runtime_version,
                   "custom" => @config_tags
-                }
+                },
+                "page_info" => page_info
               }
             }
           }.to_json

data/lib/datadog/ci/transport/api/agentless.rb

@@ -10,12 +10,13 @@ module Datadog
         class Agentless < Base
           attr_reader :api_key
 
-          def initialize(api_key:, citestcycle_url:, api_url:, citestcov_url:, logs_intake_url:)
+          def initialize(api_key:, citestcycle_url:, api_url:, citestcov_url:, logs_intake_url:, cicovreprt_url:)
             @api_key = api_key
             @citestcycle_http = build_http_client(citestcycle_url, compress: true)
             @api_http = build_http_client(api_url, compress: false)
             @citestcov_http = build_http_client(citestcov_url, compress: true)
             @logs_intake_http = build_http_client(logs_intake_url, compress: true)
+            @cicovreprt_http = build_http_client(cicovreprt_url, compress: false)
           end
 
           def citestcycle_request(path:, payload:, headers: {}, verb: "post")
@@ -49,6 +50,12 @@ module Datadog
             perform_request(@logs_intake_http, path: path, payload: payload, headers: headers, verb: verb)
           end
 
+          def cicovreprt_request(path:, event_payload:, compressed_coverage_report:, headers: {}, verb: "post")
+            super
+
+            perform_request(@cicovreprt_http, path: path, payload: @cicovreprt_payload, headers: headers, verb: verb)
+          end
+
           private
 
           def perform_request(http_client, path:, payload:, headers:, verb:, accept_compressed_response: false)

data/lib/datadog/ci/transport/api/base.rb

@@ -42,6 +42,27 @@ module Datadog
             headers[Ext::Transport::HEADER_CONTENT_TYPE] ||= Ext::Transport::CONTENT_TYPE_JSON
           end
 
+          def cicovreprt_request(path:, event_payload:, compressed_coverage_report:, headers: {}, verb: "post")
+            cicovreprt_request_boundary = ::SecureRandom.uuid
+
+            headers[Ext::Transport::HEADER_CONTENT_TYPE] ||=
+              "#{Ext::Transport::CONTENT_TYPE_MULTIPART_FORM_DATA}; boundary=#{cicovreprt_request_boundary}"
+
+            @cicovreprt_payload = [
+              "--#{cicovreprt_request_boundary}",
+              'Content-Disposition: form-data; name="event"; filename="event.json"',
+              "Content-Type: application/json",
+              "",
+              event_payload,
+              "--#{cicovreprt_request_boundary}",
+              'Content-Disposition: form-data; name="coverage"; filename="coverage.gz"',
+              "Content-Type: application/octet-stream",
+              "",
+              compressed_coverage_report,
+              "--#{cicovreprt_request_boundary}--"
+            ].join("\r\n")
+          end
+
           def headers_with_default(headers)
             request_headers = default_headers
             request_headers.merge!(headers)

data/lib/datadog/ci/transport/api/builder.rb

@@ -30,12 +30,16 @@ module Datadog
             logs_intake_url = settings.ci.agentless_url ||
               "https://#{Ext::Transport::LOGS_INTAKE_HOST_PREFIX}.#{dd_site}:443"
 
+            cicovreprt_url = settings.ci.agentless_url ||
+              "https://#{Ext::Transport::CODE_COVERAGE_REPORT_INTAKE_HOST_PREFIX}.#{dd_site}:443"
+
             Agentless.new(
               api_key: settings.api_key,
               citestcycle_url: citestcycle_url,
               api_url: api_url,
               citestcov_url: citestcov_url,
-              logs_intake_url: logs_intake_url
+              logs_intake_url: logs_intake_url,
+              cicovreprt_url: cicovreprt_url
             )
           end
 

data/lib/datadog/ci/transport/api/evp_proxy.rb

@@ -50,6 +50,14 @@ module Datadog
             raise NotImplementedError, "Logs intake is not supported in EVP proxy mode"
           end
 
+          def cicovreprt_request(path:, event_payload:, compressed_coverage_report:, headers: {}, verb: "post")
+            super
+
+            headers[Ext::Transport::HEADER_EVP_SUBDOMAIN] = Ext::Transport::CODE_COVERAGE_REPORT_INTAKE_HOST_PREFIX
+
+            perform_request(@agent_intake_http, path: path, payload: @cicovreprt_payload, headers: headers, verb: verb)
+          end
+
           private
 
           def perform_request(http_client, path:, payload:, headers:, verb:)

data/lib/datadog/ci/version.rb

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