datadog-ci 1.26.0 → 1.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1f81920de6f72669d918ab0ea703312868d380d069df7d17f131c0d64e6925a
-  data.tar.gz: 90b37b85ef042fea0b15987d98fa5cf35aad89c599c54ad6ef01d7151dee1386
+  metadata.gz: 47e2dae93f942112cea718e6772f7c586214d97a4d3fb9d8ecf9643826c4e9a0
+  data.tar.gz: 80558ee95a33818f80f937981b9c0533c8e638444ac181a31683ea22d53c7ad7
 SHA512:
-  metadata.gz: 3cd6c023dcd0c239605084ffc9822766ebbde643af95a44bfc2362e8b4a8339cb30ceef649791a1392322de5c0c25ab5d42b80cdbb777ff1f9da1eed717962a7
-  data.tar.gz: f5a196eadb710b862e99d59560971ef5dc35bf5ace1a43733558be8bf1f8a467055b61c637d283ec9ed5cd1f511b6c734fb4085e28c518696ed31a0e90fbec14
+  metadata.gz: d442d8921f4ba7fd8ae372544f518edeaac97a6a4b89aa52d2cc8e6ff8035e3131d61104fc4bce7030634970fc2cd52a13d929944ad08497e7abfcf174634ccb
+  data.tar.gz: 4f58631b0792099fdff630a65c10f162e3c933ac2e5c32b53addbaebc4533daf4c87ae7112b69abbd4cf113257a4ac1cc58dc59fb2f8b63184ba3f9abb1aec8d

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 ## [Unreleased]
 
+## [1.27.0] - 2026-01-22
+
+
+### Added
+
+* Add context-level code coverage tracking for RSpec to improve Test Impact Analysis correctness ([#460][])
+* Add automatic uploading of code coverage reports to Datadog Code Coverage product ([#456][])
+
+### Changed
+
+* Use pagination for known tests API ([#455][]) ([#458][])
+* GitHub Actions: extract numeric job ID for accurate job URLs ([#457][])
+
+### Fixed
+
+* RSpec: take into account Test Management disabled tests when deciding to skip context hooks ([#463][])
+* Fix for attempt-to-fix flow: don't mask failures for flaky tests being fixed ([#464][])
+* Pass -c safe.directory to all git commands to fix dubious ownership errors ([#454][])
+* fix: rename DD_TRACE_CI_ENABLED to DD_CIVISIBILITY_ENABLED with backwards compatibility ([#453][])
+
 ## [1.26.0] - 2026-01-09
 
 ========== Changelog ==========
@@ -578,7 +598,8 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 
 - Ruby versions < 2.7 no longer supported ([#8][])
 
-[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.26.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.27.0...main
+[1.27.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.26.0...v1.27.0
 [1.26.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.25.0...v1.26.0
 [1.25.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.24.0...v1.25.0
 [1.24.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.3...v1.24.0
@@ -819,4 +840,13 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#440]: https://github.com/DataDog/datadog-ci-rb/issues/440
 [#442]: https://github.com/DataDog/datadog-ci-rb/issues/442
 [#444]: https://github.com/DataDog/datadog-ci-rb/issues/444
-[#446]: https://github.com/DataDog/datadog-ci-rb/issues/446
+[#446]: https://github.com/DataDog/datadog-ci-rb/issues/446
+[#453]: https://github.com/DataDog/datadog-ci-rb/issues/453
+[#454]: https://github.com/DataDog/datadog-ci-rb/issues/454
+[#455]: https://github.com/DataDog/datadog-ci-rb/issues/455
+[#456]: https://github.com/DataDog/datadog-ci-rb/issues/456
+[#457]: https://github.com/DataDog/datadog-ci-rb/issues/457
+[#458]: https://github.com/DataDog/datadog-ci-rb/issues/458
+[#460]: https://github.com/DataDog/datadog-ci-rb/issues/460
+[#463]: https://github.com/DataDog/datadog-ci-rb/issues/463
+[#464]: https://github.com/DataDog/datadog-ci-rb/issues/464

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../ext/environment"
+require_relative "transport"
+
+module Datadog
+  module CI
+    module CodeCoverage
+      # CodeCoverage component is responsible for uploading code coverage reports
+      # to Datadog's Code Coverage product.
+      class Component
+        COVERAGE_REPORT_TYPE = "coverage_report"
+
+        attr_reader :enabled
+
+        def initialize(enabled:, transport:)
+          @enabled = enabled
+          @transport = transport
+        end
+
+        def configure(library_configuration)
+          @enabled &&= library_configuration.coverage_report_upload_enabled?
+
+          Datadog.logger.debug do
+            "[#{self.class.name}] Configured with enabled=#{@enabled}"
+          end
+        end
+
+        def upload(serialized_report:, format:)
+          return unless @enabled
+          return if serialized_report.nil?
+
+          Datadog.logger.debug { "[#{self.class.name}] Uploading coverage report..." }
+
+          event = build_event(format)
+
+          @transport.send_coverage_report(event: event, coverage_report: serialized_report)
+        end
+
+        def shutdown!
+          # noop - transport is synchronous
+        end
+
+        private
+
+        def build_event(format)
+          {
+            "type" => COVERAGE_REPORT_TYPE,
+            "format" => format
+          }.merge(Ext::Environment.tags(ENV))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module CodeCoverage
+      class NullComponent
+        attr_reader :enabled
+
+        def initialize
+          @enabled = false
+        end
+
+        def configure(library_configuration)
+        end
+
+        def upload(serialized_report:, format:)
+        end
+
+        def shutdown!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "../ext/telemetry"
+require_relative "../ext/transport"
+require_relative "../transport/gzip"
+require_relative "../transport/telemetry"
+require_relative "../utils/telemetry"
+
+module Datadog
+  module CI
+    module CodeCoverage
+      class Transport
+        attr_reader :api
+
+        def initialize(api:)
+          @api = api
+        end
+
+        def send_coverage_report(event:, coverage_report:)
+          return nil if api.nil?
+
+          Datadog.logger.debug { "[#{self.class.name}] Sending coverage report..." }
+
+          compressed_coverage_report = CI::Transport::Gzip.compress(coverage_report)
+          event_json = event.to_json
+
+          response = api.cicovreprt_request(
+            path: Ext::Transport::CODE_COVERAGE_REPORT_INTAKE_PATH,
+            event_payload: event_json,
+            compressed_coverage_report: compressed_coverage_report
+          )
+
+          CI::Transport::Telemetry.api_requests(
+            Ext::Telemetry::METRIC_COVERAGE_UPLOAD_REQUEST,
+            1,
+            compressed: response.request_compressed
+          )
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_COVERAGE_UPLOAD_REQUEST_MS,
+            response.duration_ms
+          )
+          Utils::Telemetry.distribution(
+            Ext::Telemetry::METRIC_COVERAGE_UPLOAD_REQUEST_BYTES,
+            compressed_coverage_report.bytesize.to_f,
+            {Ext::Telemetry::TAG_REQUEST_COMPRESSED => response.request_compressed.to_s}
+          )
+
+          unless response.ok?
+            CI::Transport::Telemetry.api_requests_errors(
+              Ext::Telemetry::METRIC_COVERAGE_UPLOAD_REQUEST_ERRORS,
+              1,
+              error_type: response.telemetry_error_type,
+              status_code: response.code
+            )
+
+            Datadog.logger.warn { "[#{self.class.name}] Failed to send coverage report: #{response.inspect}" }
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/configuration/components.rb

@@ -3,6 +3,9 @@
 require "datadog/core/telemetry/ext"
 
 require_relative "../ext/settings"
+require_relative "../code_coverage/component"
+require_relative "../code_coverage/null_component"
+require_relative "../code_coverage/transport"
 require_relative "../git/tree_uploader"
 require_relative "../impacted_tests_detection/component"
 require_relative "../impacted_tests_detection/null_component"
@@ -42,7 +45,7 @@ module Datadog
       # Adds CI behavior to Datadog trace components
       module Components
         attr_reader :test_visibility, :test_optimisation, :git_tree_upload_worker, :ci_remote, :test_retries,
-          :test_management, :agentless_logs_submission, :impacted_tests_detection, :test_discovery
+          :test_management, :agentless_logs_submission, :impacted_tests_detection, :test_discovery, :code_coverage
 
         def initialize(settings)
           @test_optimisation = TestOptimisation::NullComponent.new
@@ -53,6 +56,7 @@ module Datadog
           @test_management = TestManagement::NullComponent.new
           @impacted_tests_detection = ImpactedTestsDetection::NullComponent.new
           @test_discovery = TestDiscovery::NullComponent.new
+          @code_coverage = CodeCoverage::NullComponent.new
 
           # Activate CI mode if enabled
           if settings.ci.enabled
@@ -69,6 +73,7 @@ module Datadog
           @test_optimisation&.shutdown!
           @agentless_logs_submission&.shutdown!
           @test_discovery&.shutdown!
+          @code_coverage&.shutdown!
           @git_tree_upload_worker&.stop
         end
 
@@ -158,6 +163,8 @@ module Datadog
           @agentless_logs_submission = build_agentless_logs_component(settings, test_visibility_api)
 
           @impacted_tests_detection = ImpactedTestsDetection::Component.new(enabled: settings.ci.impacted_tests_detection_enabled)
+
+          @code_coverage = build_code_coverage(settings, test_visibility_api)
         end
 
         def build_test_optimisation(settings, test_visibility_api)
@@ -283,6 +290,15 @@ module Datadog
           )
         end
 
+        def build_code_coverage(settings, api)
+          return CodeCoverage::NullComponent.new if api.nil? || settings.ci.discard_traces
+
+          CodeCoverage::Component.new(
+            enabled: settings.ci.code_coverage_report_upload_enabled,
+            transport: CodeCoverage::Transport.new(api: api)
+          )
+        end
+
         def build_agentless_logs_component(settings, api)
           if settings.ci.agentless_logs_submission_enabled && !settings.ci.agentless_mode_enabled
             Datadog.logger.warn(

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

@@ -3,6 +3,7 @@
 require_relative "../contrib/instrumentation"
 require_relative "../ext/settings"
 require_relative "../utils/bundle"
+require_relative "../utils/parsing"
 
 module Datadog
   module CI
@@ -19,8 +20,19 @@ module Datadog
             settings :ci do
               option :enabled do |o|
                 o.type :bool
-                o.env CI::Ext::Settings::ENV_MODE_ENABLED
-                o.default false
+                o.env CI::Ext::Settings::ENV_ENABLED
+                o.default do
+                  env_value = ENV[CI::Ext::Settings::ENV_MODE_ENABLED]
+                  if env_value && !ENV[CI::Ext::Settings::ENV_ENABLED]
+                    Datadog::Core.log_deprecation do
+                      "#{CI::Ext::Settings::ENV_MODE_ENABLED} environment variable is deprecated, " \
+                        "use #{CI::Ext::Settings::ENV_ENABLED} instead."
+                    end
+                    Utils::Parsing.convert_to_bool(env_value)
+                  else
+                    false
+                  end
+                end
               end
 
               option :test_session_name do |o|
@@ -174,6 +186,12 @@ module Datadog
                 o.default false
               end
 
+              option :code_coverage_report_upload_enabled do |o|
+                o.type :bool
+                o.env CI::Ext::Settings::ENV_CODE_COVERAGE_REPORT_UPLOAD_ENABLED
+                o.default true
+              end
+
               define_method(:instrument) do |integration_name, options = {}, &block|
                 return unless enabled
 

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

@@ -64,7 +64,7 @@ module Datadog
 
               finish_with_result(test_span, result_code)
 
-              # remove failures if test passed at least once on retries or quarantined
+              # remove failures if failure can be ignored because of retries
               self.failures = [] if test_span.should_ignore_failures?
 
               super

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

@@ -39,6 +39,9 @@ module Datadog
               end_line = SourceCode::MethodInspect.last_line(@example_block)
               tags[CI::Ext::Test::TAG_SOURCE_END] = end_line.to_s if end_line
 
+              # we keep track of the last test failure if we encounter any
+              test_failure = nil
+
               test_retries_component.with_retries do
                 test_visibility_component.trace_test(
                   datadog_test_name,
@@ -46,6 +49,9 @@ module Datadog
                   tags: tags,
                   service: datadog_configuration[:service_name]
                 ) do |test_span|
+                  # Set context IDs on the test span for TIA context coverage merging
+                  test_span&.context_ids = datadog_context_ids
+
                   test_span&.itr_unskippable! if datadog_unskippable?
 
                   metadata[:skip] = test_span&.datadog_skip_reason if test_span&.should_skip?
@@ -65,8 +71,10 @@ module Datadog
                     test_span&.passed!
                   when :failed
                     test_span&.failed!(exception: execution_result.exception)
+
                     # if any of the retries passed or test is quarantined, we don't fail the test run
                     @exception = nil if test_span&.should_ignore_failures?
+                    test_failure = @exception
                   else
                     # :pending or nil
                     test_span&.skipped!(
@@ -92,6 +100,12 @@ module Datadog
                       metadata[Ext::METADATA_DD_SKIPPED_BY_ITR] = true
                     end
                   end
+
+                  # at this point if we have encountered any test failure in any of the previous retries
+                  # we restore the @exception internal state if we should not skip failures for this run
+                  if test_failure && !test_span&.should_ignore_failures?
+                    @exception = test_failure
+                  end
                 end
               end
 
@@ -172,19 +186,45 @@ module Datadog
               Git::LocalRepository.relative_to_root(metadata[:rerun_file_path])
             end
 
+            # Returns list of context IDs for this example, from outermost to innermost.
+            # Used for merging context-level coverage into test coverage.
+            def datadog_context_ids
+              traverse_example_group_hierarchy unless defined?(@datadog_context_ids)
+              @datadog_context_ids
+            end
+
             private
 
-            def fetch_top_level_example_group
+            def datadog_top_level_example_group
+              traverse_example_group_hierarchy unless defined?(@datadog_top_level_example_group)
+              @datadog_top_level_example_group
+            end
+
+            # Traverses the example group hierarchy once, populating both
+            # @datadog_context_ids and @top_level_example_group.
+            def traverse_example_group_hierarchy
+              context_ids = []
               example_group = metadata[:example_group]
-              parent_example_group = example_group[:parent_example_group]
+              top_level = example_group
+
+              # Walk up the example group hierarchy
+              while example_group
+                # Use scoped_id as the stable identifier, fallback to file:line
+                context_id = example_group[:scoped_id] ||
+                  "#{example_group[:file_path]}:#{example_group[:line_number]}"
+
+                context_ids << context_id
+                top_level = example_group
+
+                example_group = example_group[:parent_example_group]
+              end
 
-              return example_group unless parent_example_group
+              @datadog_context_ids = context_ids
+              @datadog_top_level_example_group = top_level
 
-              res = parent_example_group
-              while (parent = res[:parent_example_group])
-                res = parent
+              Datadog.logger.debug do
+                "RSpec: Built context chain for the test: #{context_ids.inspect}"
               end
-              res
             end
 
             def datadog_integration
@@ -196,7 +236,7 @@ module Datadog
             end
 
             def datadog_test_suite_description
-              @datadog_test_suite_description ||= fetch_top_level_example_group[:description]
+              @datadog_test_suite_description ||= datadog_top_level_example_group[:description]
             end
 
             def test_visibility_component

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

@@ -24,47 +24,79 @@ module Datadog
               # even if it is a nested context
               metadata[:skip] = true if all_examples_skipped_by_datadog?
 
-              # return early because we create Datadog::CI::TestSuite only for top-level example groups
-              return super unless top_level?
-
-              suite_name = "#{description} at #{file_path}"
-              suite_tags = {
-                CI::Ext::Test::TAG_SOURCE_FILE => Git::LocalRepository.relative_to_root(metadata[:file_path]),
-                CI::Ext::Test::TAG_SOURCE_START => metadata[:line_number].to_s
-              }
-
-              test_suite =
-                test_visibility_component&.start_test_suite(
-                  suite_name,
-                  tags: suite_tags,
-                  service: datadog_configuration[:service_name]
-                )
-
-              success = super
-              return success unless test_suite
-
-              if success && test_suite.any_passed?
-                test_suite.passed!
-              elsif success
-                test_suite.skipped!
-              else
-                test_suite.failed!
+              # Start context coverage for this example group (for TIA suite-level coverage).
+              # This captures code executed in before(:context)/before(:all) hooks.
+              # The context_id uses scoped_id which is a stable identifier for RSpec example groups.
+              context_id = datadog_context_id
+              start_context_coverage(context_id)
+
+              begin
+                # return early because we create Datadog::CI::TestSuite only for top-level example groups
+                return super unless top_level?
+
+                suite_name = "#{description} at #{file_path}"
+                suite_tags = {
+                  CI::Ext::Test::TAG_SOURCE_FILE => Git::LocalRepository.relative_to_root(metadata[:file_path]),
+                  CI::Ext::Test::TAG_SOURCE_START => metadata[:line_number].to_s
+                }
+
+                test_suite =
+                  test_visibility_component&.start_test_suite(
+                    suite_name,
+                    tags: suite_tags,
+                    service: datadog_configuration[:service_name]
+                  )
+
+                success = super
+
+                return success unless test_suite
+
+                test_suite.finish
+
+                success
+              ensure
+                clear_context_coverage(context_id)
               end
-
-              test_suite.finish
-
-              success
             end
 
             private
 
             def all_examples_skipped_by_datadog?
               descendant_filtered_examples.all? do |example|
-                !example.datadog_unskippable? && test_optimisation_component&.skippable?(example.datadog_test_id) &&
-                  !test_management_component&.attempt_to_fix?(example.datadog_fqn_test_id)
+                datadog_test_id = example.datadog_test_id
+                datadog_fqn_test_id = example.datadog_fqn_test_id
+
+                # Don't skip if the test is marked as attempt_to_fix (it should run and be retried)
+                next false if test_management_component&.attempt_to_fix?(datadog_fqn_test_id)
+
+                # Skip by Test Impact Analysis: test is skippable and not marked as unskippable
+                tia_skipped = !example.datadog_unskippable? &&
+                  test_optimisation_component&.skippable?(datadog_test_id)
+
+                # Skip by Test Management: test is disabled
+                test_management_disabled = test_management_component&.disabled?(datadog_fqn_test_id)
+
+                tia_skipped || test_management_disabled
               end
             end
 
+            # Returns a stable context ID for this example group.
+            # Uses RSpec's scoped_id which uniquely identifies each example group.
+            def datadog_context_id
+              metadata[:scoped_id] || "#{metadata[:file_path]}:#{metadata[:line_number]}"
+            end
+
+            # Starts context coverage collection for this example group.
+            # This captures code executed in before(:context)/before(:all) hooks.
+            def start_context_coverage(context_id)
+              test_optimisation_component&.on_test_context_started(context_id)
+            end
+
+            # Clears context coverage for this example group after it finishes.
+            def clear_context_coverage(context_id)
+              test_optimisation_component&.clear_context_coverage(context_id)
+            end
+
             def datadog_configuration
               Datadog.configuration.ci[:rspec]
             end

data/lib/datadog/ci/contrib/simplecov/ext.rb

@@ -8,6 +8,8 @@ module Datadog
         # @public_api
         module Ext
           ENV_ENABLED = "DD_CIVISIBILITY_SIMPLECOV_INSTRUMENTATION_ENABLED"
+
+          COVERAGE_FORMAT = "simplecov-internal"
         end
       end
     end

data/lib/datadog/ci/contrib/simplecov/patcher.rb

@@ -2,6 +2,7 @@
 
 require_relative "../patcher"
 
+require_relative "report_uploader"
 require_relative "result_extractor"
 
 module Datadog
@@ -16,6 +17,7 @@ module Datadog
 
           def patch
             ::SimpleCov.include(ResultExtractor)
+            ::SimpleCov.include(ReportUploader)
           end
         end
       end

data/lib/datadog/ci/contrib/simplecov/report_uploader.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative "ext"
+
+module Datadog
+  module CI
+    module Contrib
+      module Simplecov
+        # Module that hooks into SimpleCov.process_results_and_report_error to upload coverage reports
+        module ReportUploader
+          def self.included(base)
+            base.singleton_class.prepend(ClassMethods)
+          end
+
+          module ClassMethods
+            def process_results_and_report_error(*args)
+              result = super
+
+              upload_coverage_report
+
+              result
+            end
+
+            private
+
+            def upload_coverage_report
+              return unless datadog_configuration[:enabled]
+
+              code_coverage = ::Datadog.send(:components).code_coverage
+              return unless code_coverage.enabled
+
+              serialized_report = read_coverage_result
+              return if serialized_report.nil?
+
+              code_coverage.upload(serialized_report: serialized_report, format: Ext::COVERAGE_FORMAT)
+            rescue => e
+              Datadog.logger.warn("Failed to upload coverage report: #{e.message}")
+            end
+
+            def read_coverage_result
+              coverage_file = File.join(::SimpleCov.coverage_path, ".resultset.json")
+
+              unless File.exist?(coverage_file)
+                Datadog.logger.debug { "Coverage result file not found at #{coverage_file}" }
+                return nil
+              end
+
+              File.read(coverage_file)
+            end
+
+            def datadog_configuration
+              Datadog.configuration.ci[:simplecov]
+            end
+          end
+        end
+      end
+    end
+  end
+end