datadog-ci 1.33.0 → 1.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e5dd4e5fdf647baf9134e9fdcc5eb6d1215c48b08bf1905dd69e731a8ebe18e
-  data.tar.gz: 851eadff7367e69480490eea9fb7e5e074c2099008de2537c07efba2de9366bf
+  metadata.gz: d2adf2fb252fdff7c6d0e1e73c2b6ade74c53bc5e8a238d447793da6833837c0
+  data.tar.gz: a49b2d09ae48bb2dc90c9846c6aae128a05d75353a2e7dc9df248960f165f556
 SHA512:
-  metadata.gz: 22bedcab49da1df468ae63d217b160d7e3a976a5b722aaa012622564629d8760afc39165b47dc8be7454b406db8e073be46524d0de02fa2b6fd13a4e685713c8
-  data.tar.gz: 9affe9fe044871139755c3fbbb0b28146bc07c2b36ed79627ad0db67ee254764fbca12bebafc9a317224bd275f9c60e5a978a3c526b8a11c0a4a92150152f104
+  metadata.gz: 75d99396decbd20bb93cc2e061295be1e55c033b41980216bc0bb9229fd36269e7ad8bd5ad1104203ca10a32bed668aa65f41d01ddd5c8ebef34d206397a7c25
+  data.tar.gz: 3a0efeaaad0042cd836c51a7232a0348b377acf959bc6e10670e01ed5d7ea863caf60853142cb7e2d563da1c64ef1dadee5c3735a69bf482dfdb7b611239767d

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [1.34.0] - 2026-06-25
+
+### Added
+
+* Add configurable TIA skipping mode ([#530][])
+
 ## [1.33.0] - 2026-06-19
 
 ### Added
@@ -659,7 +665,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.33.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.34.0...main
+[1.34.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.33.0...v1.34.0
 [1.33.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.32.0...v1.33.0
 [1.32.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.31.0...v1.32.0
 [1.31.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.30.0...v1.31.0
@@ -933,4 +940,5 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#516]: https://github.com/DataDog/datadog-ci-rb/issues/516
 [#521]: https://github.com/DataDog/datadog-ci-rb/issues/521
 [#522]: https://github.com/DataDog/datadog-ci-rb/issues/522
-[#527]: https://github.com/DataDog/datadog-ci-rb/issues/527
+[#527]: https://github.com/DataDog/datadog-ci-rb/issues/527
+[#530]: https://github.com/DataDog/datadog-ci-rb/issues/530

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

@@ -210,6 +210,7 @@ module Datadog
             api: test_visibility_api,
             dd_env: settings.env,
             config_tags: custom_configuration(settings),
+            test_skipping_mode: settings.ci.tia_test_skipping_mode,
             coverage_writer: build_coverage_writer(settings, test_visibility_api),
             enabled: settings.ci.enabled && settings.ci.itr_enabled,
             bundle_location: settings.ci.itr_code_coverage_excluded_bundle_path,
@@ -293,6 +294,7 @@ module Datadog
           Remote::LibrarySettingsClient.new(
             api: api,
             dd_env: settings.env,
+            test_skipping_mode: settings.ci.tia_test_skipping_mode,
             config_tags: custom_configuration(settings)
           )
         end

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

@@ -2,8 +2,10 @@
 
 require_relative "../contrib/instrumentation"
 require_relative "../ext/settings"
+require_relative "../ext/test"
 require_relative "../ext/test_optimization_cache"
 require_relative "../utils/bundle"
+require_relative "../utils/configuration"
 require_relative "../utils/parsing"
 
 module Datadog
@@ -79,6 +81,15 @@ module Datadog
                 o.default true
               end
 
+              option :tia_test_skipping_mode do |o|
+                o.type :string
+                o.env CI::Ext::Settings::ENV_TIA_TEST_SKIPPING_MODE
+                o.default CI::Ext::Test::TIATestSkippingMode::TEST
+                o.setter do |mode|
+                  Utils::Configuration.normalize_tia_test_skipping_mode(mode)
+                end
+              end
+
               option :git_metadata_upload_enabled do |o|
                 o.type :bool
                 o.env CI::Ext::Settings::ENV_GIT_METADATA_UPLOAD_ENABLED

data/lib/datadog/ci/contrib/cucumber/formatter.rb

@@ -72,9 +72,14 @@ module Datadog
             end
 
             unless same_test_suite_as_current?(test_suite_name)
+              suite_tags = test_suite_source_file_tags(event.test_case)
+              if test_suite_unskippable?(event.test_case)
+                suite_tags[CI::Ext::Test::TAG_ITR_UNSKIPPABLE] = "true"
+              end
+
               start_test_suite(
                 test_suite_name,
-                tags: test_suite_source_file_tags(event.test_case)
+                tags: suite_tags
               )
             end
 
@@ -228,6 +233,51 @@ module Datadog
               CI::Ext::Test::TAG_SOURCE_START => line_number.to_s
             }
           end
+
+          def test_suite_unskippable?(test_case)
+            feature = if test_case.respond_to?(:feature)
+              test_case.feature
+            else
+              @ast_lookup&.gherkin_document(test_case.location.file)&.feature
+            end
+
+            node_has_unskippable_tag?(feature) || test_case_unskippable?(test_case)
+          rescue
+            test_case_unskippable?(test_case)
+          end
+
+          def node_has_unskippable_tag?(node)
+            return false if node.nil?
+            return true if node_tags_include_unskippable?(node)
+
+            if node.respond_to?(:scenario) && node.scenario
+              return true if node_has_unskippable_tag?(node.scenario)
+            end
+
+            if node.respond_to?(:rule) && node.rule
+              return true if node_has_unskippable_tag?(node.rule)
+            end
+
+            return false unless node.respond_to?(:children)
+
+            node.children.any? { |child| node_has_unskippable_tag?(child) }
+          end
+
+          def node_tags_include_unskippable?(node)
+            return false unless node.respond_to?(:tags)
+
+            node.tags.any? { |tag| tag.respond_to?(:name) && tag.name == datadog_itr_unskippable_tag }
+          end
+
+          def test_case_unskippable?(test_case)
+            test_case.match_tags?(datadog_itr_unskippable_tag)
+          rescue
+            false
+          end
+
+          def datadog_itr_unskippable_tag
+            "@#{CI::Ext::Test::ITR_UNSKIPPABLE_OPTION}"
+          end
         end
       end
     end

data/lib/datadog/ci/contrib/cucumber/instrumentation.rb

@@ -37,6 +37,11 @@ module Datadog
             end
 
             def begin_scenario(test_case)
+              active_suite = Datadog::CI.active_test_suite
+              if active_suite&.should_skip?
+                raise ::Cucumber::Core::Test::Result::Skipped, active_suite.datadog_skip_reason
+              end
+
               datadog_test = Datadog::CI.active_test
 
               # special case for cucumber-ruby: we skip quarantined tests, thus for cucumber quarantined is the same as disabled.

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

@@ -7,6 +7,31 @@ module Datadog
     module Contrib
       module Minitest
         module Helpers
+          module RunnableClassMethods
+            def datadog_itr_unskippable(*args)
+              if args.nil? || args.empty?
+                @datadog_itr_unskippable_suite = true
+              else
+                @datadog_itr_unskippable_tests = args
+              end
+            end
+
+            def dd_suite_unskippable?
+              @datadog_itr_unskippable_suite
+            end
+
+            def dd_test_unskippable?(test_name)
+              tests = @datadog_itr_unskippable_tests
+              return false unless tests
+
+              tests.include?(test_name)
+            end
+
+            def dd_any_unskippable?
+              dd_suite_unskippable? || !!@datadog_itr_unskippable_tests
+            end
+          end
+
           def self.start_test_suite(klass)
             method = klass.runnable_methods.first
             return nil if method.nil?
@@ -22,6 +47,9 @@ module Datadog
             else
               {}
             end
+            if klass.dd_any_unskippable?
+              test_suite_tags[CI::Ext::Test::TAG_ITR_UNSKIPPABLE] = "true"
+            end
 
             test_tracing_component = Datadog.send(:components).test_tracing
             test_suite = test_tracing_component.start_test_suite(
@@ -60,6 +88,11 @@ module Datadog
             source_location
           end
 
+          def self.skip_test_suite(test_suite)
+            test_suite&.finish
+            []
+          end
+
           def self.parallel?(klass)
             klass.ancestors.include?(::Minitest::Parallel::Test) || ci_queue?
           end

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

@@ -10,11 +10,16 @@ module Datadog
           end
 
           module ClassMethods
+            include Helpers::RunnableClassMethods
+
             def run(*args)
               return super unless datadog_configuration[:enabled]
               return super if Helpers.parallel?(self)
 
               test_suite = Helpers.start_test_suite(self)
+              if test_suite&.should_skip?
+                return Helpers.skip_test_suite(test_suite)
+              end
 
               results = super
               return results unless test_suite

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

@@ -10,11 +10,16 @@ module Datadog
           end
 
           module ClassMethods
+            include Helpers::RunnableClassMethods
+
             def run_suite(*args)
               return super unless datadog_configuration[:enabled]
               return super if Helpers.parallel?(self)
 
               test_suite = Helpers.start_test_suite(self)
+              if test_suite&.should_skip?
+                return Helpers.skip_test_suite(test_suite)
+              end
 
               results = super
               return results unless test_suite

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

@@ -37,6 +37,11 @@ module Datadog
 
               return run_without_datadog_reentry if datadog_run_reentered?
 
+              test_suite = start_datadog_test_suite_if_parallel
+              if test_suite&.should_skip?
+                return skip_datadog_suite(test_suite)
+              end
+
               test_span = start_datadog_test
               return skip_datadog_test(test_span) if test_span&.should_skip?
 
@@ -76,10 +81,6 @@ module Datadog
             end
 
             def start_datadog_test
-              if Helpers.parallel?(self.class)
-                Helpers.start_test_suite(self.class)
-              end
-
               test_suite_name = Helpers.test_suite_name(self.class, name)
 
               # @type var tags : Hash[String, String]
@@ -103,15 +104,17 @@ module Datadog
                 tags: tags,
                 service: datadog_configuration[:service_name]
               )
-              # Steep type checker doesn't know that we patched Minitest::Test class definition
-              #
-              # steep:ignore:start
               test_span&.itr_unskippable! if self.class.dd_suite_unskippable? || self.class.dd_test_unskippable?(name)
-              # steep:ignore:end
 
               test_span
             end
 
+            def start_datadog_test_suite_if_parallel
+              return unless Helpers.parallel?(self.class)
+
+              Helpers.start_test_suite(self.class)
+            end
+
             def skip_datadog_test(test_span)
               time_it do
                 capture_exceptions do
@@ -124,6 +127,16 @@ module Datadog
               ::Minitest::Result.from(self)
             end
 
+            def skip_datadog_suite(test_suite)
+              time_it do
+                capture_exceptions do
+                  skip(test_suite.datadog_skip_reason)
+                end
+              end
+
+              ::Minitest::Result.from(self)
+            end
+
             def finish_with_result(span, result_code)
               return unless span
 
@@ -158,25 +171,6 @@ module Datadog
             ensure
               super
             end
-
-            def datadog_itr_unskippable(*args)
-              if args.nil? || args.empty?
-                @datadog_itr_unskippable_suite = true
-              else
-                @datadog_itr_unskippable_tests = args
-              end
-            end
-
-            def dd_suite_unskippable?
-              @datadog_itr_unskippable_suite
-            end
-
-            def dd_test_unskippable?(test_name)
-              tests = @datadog_itr_unskippable_tests
-              return false unless tests
-
-              tests.include?(test_name)
-            end
           end
         end
       end

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

@@ -29,13 +29,9 @@ module Datadog
             return unless defined?(super)
 
             patch_only_once.run do
-              # There is no way to tell Steep that we prepend these methods to modules that have .patch method
-              #
-              # steep:ignore:start
               super.tap do
                 @patch_successful = true
               end
-              # steep:ignore:end
             rescue => e
               on_patch_error(e)
             end

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

@@ -24,7 +24,7 @@ module Datadog
               # even if it is a nested context
               metadata[:skip] = true if all_examples_skipped_by_datadog?
 
-              # Start context coverage for this example group (for TIA suite-level coverage).
+              # Start context coverage for this example group (for TIA context 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
@@ -39,6 +39,9 @@ module Datadog
                   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
                 }
+                if descendant_filtered_examples.any?(&:datadog_unskippable?)
+                  suite_tags = suite_tags.merge(CI::Ext::Test::TAG_ITR_UNSKIPPABLE => "true")
+                end
 
                 test_suite =
                   test_tracing_component&.start_test_suite(
@@ -47,6 +50,8 @@ module Datadog
                     service: datadog_configuration[:service_name]
                   )
 
+                return skip_test_suite(test_suite) if test_suite&.should_skip?
+
                 success = super
 
                 return success unless test_suite
@@ -61,6 +66,11 @@ module Datadog
 
             private
 
+            def skip_test_suite(test_suite)
+              test_suite&.finish
+              true
+            end
+
             def all_examples_skipped_by_datadog?
               descendant_filtered_examples.all? do |example|
                 datadog_test_id = example.datadog_test_id

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

@@ -12,6 +12,7 @@ module Datadog
         ENV_EXPERIMENTAL_TEST_SUITE_LEVEL_VISIBILITY_ENABLED = "DD_CIVISIBILITY_EXPERIMENTAL_TEST_SUITE_LEVEL_VISIBILITY_ENABLED"
         ENV_FORCE_TEST_LEVEL_VISIBILITY = "DD_CIVISIBILITY_FORCE_TEST_LEVEL_VISIBILITY"
         ENV_ITR_ENABLED = "DD_CIVISIBILITY_ITR_ENABLED"
+        ENV_TIA_TEST_SKIPPING_MODE = "DD_TESTOPTIMIZATION_TIA_TEST_SKIPPING_MODE"
         ENV_GIT_METADATA_UPLOAD_ENABLED = "DD_CIVISIBILITY_GIT_METADATA_UPLOAD_ENABLED"
         ENV_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH"
         ENV_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE"

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

@@ -44,6 +44,7 @@ module Datadog
         METRIC_ITR_SKIPPABLE_TESTS_REQUEST_ERRORS = "itr_skippable_tests.request_errors"
         METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_BYTES = "itr_skippable_tests.response_bytes"
         METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS = "itr_skippable_tests.response_tests"
+        METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_SUITES = "itr_skippable_tests.response_suites"
 
         METRIC_ITR_SKIPPED = "itr_skipped"
         METRIC_ITR_UNSKIPPABLE = "itr_unskippable"

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

@@ -162,7 +162,14 @@ module Datadog
         ].freeze
 
         # 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
+        module TIATestSkippingMode
+          TEST = "test"
+          SUITE = "suite"
+
+          ALL = [TEST, SUITE].freeze
+        end
+
+        DEFAULT_TIA_TEST_SKIPPING_MODE = TIATestSkippingMode::TEST
         ITR_UNSKIPPABLE_OPTION = :datadog_itr_unskippable
 
         EARLY_FLAKE_FAULTY = "faulty"

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

@@ -17,10 +17,11 @@ module Datadog
     module Remote
       # Calls settings endpoint to fetch library settings for given service and env
       class LibrarySettingsClient
-        def initialize(dd_env:, api: nil, config_tags: {})
+        def initialize(dd_env:, api: nil, config_tags: {}, test_skipping_mode: Ext::Test::TIATestSkippingMode::TEST)
           @api = api
           @dd_env = dd_env
           @config_tags = config_tags || {}
+          @test_skipping_mode = test_skipping_mode
         end
 
         def fetch(test_session)
@@ -87,7 +88,7 @@ module Datadog
                 "repository_url" => test_session.git_repository_url,
                 "branch" => test_session.git_branch || test_session.git_tag,
                 "sha" => test_session.git_commit_sha,
-                "test_level" => Ext::Test::ITR_TEST_SKIPPING_MODE,
+                "test_level" => @test_skipping_mode,
                 "configurations" => {
                   Ext::Test::TAG_OS_PLATFORM => test_session.os_platform,
                   Ext::Test::TAG_OS_ARCHITECTURE => test_session.os_architecture,

data/lib/datadog/ci/source_code/method_inspect.rb

@@ -16,11 +16,8 @@ module Datadog
           return nil if target.nil?
           return nil unless LAST_LINE_AVAILABLE
 
-          # Ruby has outdated RBS for RubyVM::InstructionSequence where method `of` is not defined
-          # steep:ignore:start
           iseq = RubyVM::InstructionSequence.of(target)
           return nil unless iseq.is_a?(RubyVM::InstructionSequence)
-          # steep:ignore:end
 
           # this function is implemented in ext/datadog_ci_native/datadog_method_inspect.c
           _native_last_line_from_iseq(iseq)

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

@@ -30,8 +30,8 @@ module Datadog
 
         FILE_STORAGE_KEY = "test_impact_analysis_component_state"
 
-        attr_reader :correlation_id, :skippable_tests, :skippable_tests_fetch_error,
-          :enabled, :test_skipping_enabled, :code_coverage_enabled
+        attr_reader :correlation_id, :skippable_tests, :skippable_suites, :skippable_tests_fetch_error,
+          :enabled, :test_skipping_enabled, :code_coverage_enabled, :test_skipping_mode
 
         def initialize(
           dd_env:,
@@ -39,6 +39,7 @@ module Datadog
           api: nil,
           coverage_writer: nil,
           enabled: false,
+          test_skipping_mode: Ext::Test::TIATestSkippingMode::TEST,
           bundle_location: nil,
           use_single_threaded_coverage: false,
           use_allocation_tracing: true,
@@ -48,6 +49,7 @@ module Datadog
           @api = api
           @dd_env = dd_env
           @config_tags = config_tags || {}
+          @test_skipping_mode = test_skipping_mode
 
           @bundle_location = if bundle_location && !File.absolute_path?(bundle_location)
             File.join(Git::LocalRepository.root, bundle_location)
@@ -65,6 +67,7 @@ module Datadog
 
           @correlation_id = nil
           @skippable_tests = Set.new
+          @skippable_suites = Set.new
 
           @mutex = Mutex.new
 
@@ -92,8 +95,7 @@ module Datadog
 
           test_session.set_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_ENABLED, @test_skipping_enabled)
           test_session.set_tag(Ext::Test::TAG_CODE_COVERAGE_ENABLED, @code_coverage_enabled)
-          # we skip tests, not suites
-          test_session.set_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_TYPE, Ext::Test::ITR_TEST_SKIPPING_MODE)
+          test_session.set_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_TYPE, @test_skipping_mode)
 
           if @code_coverage_enabled
             load_datadog_cov!
@@ -102,10 +104,10 @@ module Datadog
           end
 
           # Load external cache or component state first, and if successful, skip fetching skippable tests
-          if skipping_tests?
+          if skipping_tests? || skipping_suites?
             return if load_component_state
 
-            fetch_skippable_tests(test_session)
+            fetch_skippables(test_session)
             store_component_state if test_session.distributed
           end
 
@@ -117,7 +119,19 @@ module Datadog
         end
 
         def skipping_tests?
-          @test_skipping_enabled
+          @test_skipping_enabled && test_skipping_mode?
+        end
+
+        def skipping_suites?
+          @test_skipping_enabled && suite_skipping_mode?
+        end
+
+        def test_skipping_mode?
+          @test_skipping_mode == Ext::Test::TIATestSkippingMode::TEST
+        end
+
+        def suite_skipping_mode?
+          @test_skipping_mode == Ext::Test::TIATestSkippingMode::SUITE
         end
 
         def code_coverage?
@@ -174,6 +188,7 @@ module Datadog
         # @return [void]
         def on_test_started(test)
           return if !enabled? || !code_coverage?
+          return if suite_skipping_mode?
 
           # Stop any in-progress context coverage and store it
           stop_context_coverage_and_store
@@ -200,6 +215,7 @@ module Datadog
         # @return [Datadog::CI::TestImpactAnalysis::Coverage::Event, nil] The coverage event or nil
         def on_test_finished(test, context)
           return unless enabled?
+          return if suite_skipping_mode?
 
           # Handle ITR statistics
           if test.skipped_by_test_impact_analysis?
@@ -222,33 +238,13 @@ module Datadog
           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
-          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)
-
-          coverage_event = Coverage::Event.new(
+          write_coverage_event(
             test_id: test.id.to_s,
             test_suite_id: test.test_suite_id.to_s,
             test_session_id: test.test_session_id.to_s,
+            source_file: test.source_file,
             coverage: coverage
           )
-
-          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.
@@ -271,7 +267,7 @@ module Datadog
         #
         # @return [Boolean]
         def context_coverage_enabled?
-          enabled? && code_coverage? && !@use_single_threaded_coverage
+          enabled? && code_coverage? && !suite_skipping_mode? && !@use_single_threaded_coverage
         end
 
         def skippable?(datadog_test_id)
@@ -280,6 +276,12 @@ module Datadog
           @mutex.synchronize { @skippable_tests.include?(datadog_test_id) }
         end
 
+        def skippable_suite?(test_suite_name)
+          return false if !enabled? || !skipping_suites?
+
+          @mutex.synchronize { @skippable_suites.include?(test_suite_name) }
+        end
+
         def mark_if_skippable(test)
           return if !enabled? || !skipping_tests?
 
@@ -292,6 +294,66 @@ module Datadog
           end
         end
 
+        def mark_if_suite_skippable(test_suite)
+          return if !enabled? || !skipping_suites?
+
+          unskippable = test_suite.itr_unskippable?
+          Telemetry.itr_unskippable if unskippable
+
+          unless skippable_suite?(test_suite.name)
+            Datadog.logger.debug { "Test suite is not skippable: #{test_suite.name}" }
+            return
+          end
+
+          if unskippable
+            Telemetry.itr_forced_run
+            test_suite.set_tag(Ext::Test::TAG_ITR_FORCED_RUN, "true")
+
+            Datadog.logger.debug { "Forced run of skippable test suite: #{test_suite.name}" }
+            return
+          end
+
+          test_suite.set_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR, "true")
+          test_suite.skipped!(reason: Ext::Test::SkipReason::TEST_IMPACT_ANALYSIS)
+
+          Datadog.logger.debug { "Marked test suite as skippable: #{test_suite.name}" }
+        end
+
+        def on_test_suite_started(test_suite)
+          return unless enabled? && suite_skipping_mode?
+
+          mark_if_suite_skippable(test_suite)
+          return if test_suite.should_skip?
+          return unless code_coverage?
+
+          Telemetry.code_coverage_started(test_suite)
+          coverage_collector&.start
+        end
+
+        def on_test_suite_finished(test_suite, context)
+          return unless enabled? && suite_skipping_mode?
+
+          if test_suite.skipped_by_test_impact_analysis?
+            Telemetry.itr_skipped
+            context.incr_tests_skipped_by_tia_count
+            return
+          end
+
+          return unless code_coverage?
+
+          Telemetry.code_coverage_finished(test_suite)
+
+          coverage = coverage_collector&.stop
+
+          write_coverage_event(
+            test_id: nil,
+            test_suite_id: test_suite.id.to_s,
+            test_session_id: test_suite.get_tag(Ext::Test::TAG_TEST_SESSION_ID).to_s,
+            source_file: test_suite.source_file,
+            coverage: coverage
+          )
+        end
+
         def write_test_session_tags(test_session, skipped_tests_count)
           return if !enabled?
 
@@ -302,8 +364,8 @@ module Datadog
           test_session.set_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_COUNT, skipped_tests_count)
         end
 
-        def skippable_tests_count
-          skippable_tests.count
+        def skippables_count
+          current_skippables.count
         end
 
         def shutdown!
@@ -314,15 +376,17 @@ module Datadog
         def serialize_state
           {
             correlation_id: @correlation_id,
-            skippable_tests: @skippable_tests
+            skippable_tests: @skippable_tests,
+            skippable_suites: @skippable_suites
           }
         end
 
         def restore_state(state)
-          @mutex.synchronize do
-            @correlation_id = state[:correlation_id]
-            @skippable_tests = state[:skippable_tests]
-          end
+          set_skippables(
+            correlation_id: state[:correlation_id],
+            tests: state[:skippable_tests] || Set.new,
+            suites: state[:skippable_suites] || Set.new
+          )
         end
 
         def storage_key
@@ -330,24 +394,20 @@ module Datadog
         end
 
         def restore_state_from_datadog_test_runner
-          Datadog.logger.debug { "Restoring skippable tests from Test Optimization cache" }
+          Datadog.logger.debug { "Restoring skippables from Test Optimization cache" }
 
-          skippable_tests_data = load_cached_skippable_tests
-          if skippable_tests_data.nil?
-            Datadog.logger.debug { "Restoring skippable tests failed, will request again" }
+          skippables_data = load_cached_skippable_tests
+          if skippables_data.nil?
+            Datadog.logger.debug { "Restoring skippables failed, will request again" }
             return false
           end
 
-          Datadog.logger.debug { "Restored skippable tests from Test Optimization: #{skippable_tests_data}" }
+          Datadog.logger.debug { "Restored skippables from Test Optimization: #{skippables_data}" }
 
-          skippable_response = Skippable::Response.from_json(skippable_tests_data)
+          skippable_response = Skippable::Response.from_json(skippables_data)
+          apply_skippable_response(skippable_response)
 
-          @mutex.synchronize do
-            @correlation_id = skippable_response.correlation_id
-            @skippable_tests = skippable_response.tests
-          end
-
-          Datadog.logger.debug { "Found [#{@skippable_tests.size}] skippable tests from context" }
+          Datadog.logger.debug { "Found [#{skippables_count}] skippable #{@test_skipping_mode}s from context" }
           Datadog.logger.debug { "ITR correlation ID from context: #{@correlation_id}" }
 
           true
@@ -406,27 +466,84 @@ module Datadog
           coverage[absolute_test_source_file_path] = true
         end
 
-        def fetch_skippable_tests(test_session)
-          return unless skipping_tests?
+        def write_coverage_event(test_id:, test_suite_id:, test_session_id:, source_file:, coverage:)
+          coverage ||= {}
+          if coverage.empty?
+            Telemetry.code_coverage_is_empty
+            return
+          end
+
+          ensure_test_source_covered(source_file, coverage) unless source_file.nil?
+
+          enrich_coverage_with_static_dependencies(coverage)
+
+          Telemetry.code_coverage_files(coverage.size)
+
+          coverage_event = Coverage::Event.new(
+            test_id: test_id,
+            test_suite_id: test_suite_id,
+            test_session_id: test_session_id,
+            coverage: coverage
+          )
+
+          Datadog.logger.debug { "Writing coverage event \n #{coverage_event.pretty_inspect}" }
+
+          write(coverage_event)
+
+          coverage_event
+        end
+
+        def fetch_skippables(test_session)
+          return unless skipping_tests? || skipping_suites?
 
           # we can only request skippable tests if git metadata is already uploaded
           git_tree_upload_worker.wait_until_done
 
           skippable_response =
-            Skippable.new(api: @api, dd_env: @dd_env, config_tags: @config_tags)
-              .fetch_skippable_tests(test_session)
+            Skippable.new(
+              api: @api,
+              dd_env: @dd_env,
+              config_tags: @config_tags,
+              test_skipping_mode: @test_skipping_mode
+            )
+              .fetch_skippables(test_session)
           @skippable_tests_fetch_error = skippable_response.error_message unless skippable_response.ok?
 
+          apply_skippable_response(skippable_response)
+
+          Datadog.logger.debug { "Fetched skippable #{@test_skipping_mode}s: \n #{current_skippables}" }
+          Datadog.logger.debug { "Found #{skippables_count} skippable #{@test_skipping_mode}s." }
+          Datadog.logger.debug { "ITR correlation ID: #{@correlation_id}" }
+
+          Utils::Telemetry.inc(skippable_response_metric, skippables_count)
+        end
+
+        def apply_skippable_response(skippable_response)
+          set_skippables(
+            correlation_id: skippable_response.correlation_id,
+            tests: skippable_response.tests,
+            suites: skippable_response.suites
+          )
+        end
+
+        def set_skippables(correlation_id:, tests:, suites:)
           @mutex.synchronize do
-            @correlation_id = skippable_response.correlation_id
-            @skippable_tests = skippable_response.tests
+            @correlation_id = correlation_id
+            @skippable_tests = tests
+            @skippable_suites = suites
           end
+        end
 
-          Datadog.logger.debug { "Fetched skippable tests: \n #{@skippable_tests}" }
-          Datadog.logger.debug { "Found #{@skippable_tests.count} skippable tests." }
-          Datadog.logger.debug { "ITR correlation ID: #{@correlation_id}" }
+        def current_skippables
+          suite_skipping_mode? ? @skippable_suites : @skippable_tests
+        end
 
-          Utils::Telemetry.inc(Ext::Telemetry::METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS, @skippable_tests.count)
+        def skippable_response_metric
+          if skipping_suites?
+            Ext::Telemetry::METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_SUITES
+          else
+            Ext::Telemetry::METRIC_ITR_SKIPPABLE_TESTS_RESPONSE_TESTS
+          end
         end
 
         def code_coverage_mode

data/lib/datadog/ci/test_impact_analysis/coverage/event.rb

@@ -21,7 +21,7 @@ module Datadog
           def valid?
             valid = true
 
-            %i[test_id test_suite_id test_session_id coverage].each do |key|
+            %i[test_suite_id test_session_id coverage].each do |key|
               next unless send(key).nil?
 
               Datadog.logger.warn("citestcov event is invalid: [#{key}] is nil. Event: #{self}")
@@ -34,7 +34,7 @@ module Datadog
           def to_msgpack(packer = nil)
             packer ||= MessagePack::Packer.new
 
-            packer.write_map_header(4)
+            packer.write_map_header(test_id.nil? ? 3 : 4)
 
             packer.write("test_session_id")
             packer.write(test_session_id.to_i)
@@ -42,8 +42,10 @@ module Datadog
             packer.write("test_suite_id")
             packer.write(test_suite_id.to_i)
 
-            packer.write("span_id")
-            packer.write(test_id.to_i)
+            unless test_id.nil?
+              packer.write("span_id")
+              packer.write(test_id.to_i)
+            end
 
             files = coverage.keys
             packer.write("files")

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

@@ -2,13 +2,16 @@
 
 require "set"
 
+require_relative "../ext/test"
+
 module Datadog
   module CI
     module TestImpactAnalysis
       # No-op implementation used when test impact analysis is disabled.
       class NullComponent
         attr_reader :enabled, :skippable_tests_fetch_error, :test_skipping_enabled,
-          :code_coverage_enabled, :skippable_tests, :correlation_id
+          :code_coverage_enabled, :skippable_tests, :skippable_suites, :correlation_id,
+          :test_skipping_mode
 
         def initialize
           @enabled = false
@@ -16,7 +19,9 @@ module Datadog
           @code_coverage_enabled = false
           @skippable_tests_fetch_error = nil
           @skippable_tests = Set.new
+          @skippable_suites = Set.new
           @correlation_id = nil
+          @test_skipping_mode = Ext::Test::TIATestSkippingMode::TEST
         end
 
         def configure(_remote_configuration = nil, _test_session = nil)
@@ -30,6 +35,10 @@ module Datadog
           false
         end
 
+        def skipping_suites?
+          false
+        end
+
         def code_coverage?
           false
         end
@@ -51,6 +60,13 @@ module Datadog
           nil
         end
 
+        def on_test_suite_started(_test_suite)
+        end
+
+        def on_test_suite_finished(_test_suite, _context)
+          nil
+        end
+
         def clear_context_coverage(_context_id)
         end
 
@@ -65,10 +81,17 @@ module Datadog
           false
         end
 
+        def skippable_suite?(_test_suite_name)
+          false
+        end
+
         def write_test_session_tags(_test_session, _skipped_tests_count)
         end
 
-        def skippable_tests_count
+        def mark_if_suite_skippable(_test_suite)
+        end
+
+        def skippables_count
           0
         end
 

data/lib/datadog/ci/test_impact_analysis/skippable.rb

@@ -36,7 +36,7 @@ module Datadog
 
             payload.fetch("data", [])
               .each do |test_data|
-                next unless test_data["type"] == Ext::Test::ITR_TEST_SKIPPING_MODE
+                next unless test_data["type"] == Ext::Test::TIATestSkippingMode::TEST
 
                 attrs = test_data["attributes"] || {}
                 res << Utils::TestRun.datadog_test_id(attrs["name"], attrs["suite"], attrs["parameters"])
@@ -45,6 +45,20 @@ module Datadog
             res
           end
 
+          def suites
+            res = Set.new
+
+            payload.fetch("data", [])
+              .each do |test_data|
+                next unless test_data["type"] == Ext::Test::TIATestSkippingMode::SUITE
+
+                suite = (test_data["attributes"] || {})["suite"]
+                res << suite unless suite.nil?
+              end
+
+            res
+          end
+
           def error_message
             return nil if ok?
 
@@ -74,18 +88,19 @@ module Datadog
           end
         end
 
-        def initialize(dd_env:, api: nil, config_tags: {})
+        def initialize(dd_env:, api: nil, config_tags: {}, test_skipping_mode: Ext::Test::TIATestSkippingMode::TEST)
           @api = api
           @dd_env = dd_env
           @config_tags = config_tags
+          @test_skipping_mode = test_skipping_mode
         end
 
-        def fetch_skippable_tests(test_session)
+        def fetch_skippables(test_session)
           api = @api
           return Response.from_http_response(nil) unless api
 
           request_payload = payload(test_session)
-          Datadog.logger.debug("Fetching skippable tests with request: #{request_payload}")
+          Datadog.logger.debug("Fetching skippable #{@test_skipping_mode}s with request: #{request_payload}")
 
           http_response = api.api_request(
             path: Ext::Transport::DD_API_SKIPPABLE_TESTS_PATH,
@@ -127,7 +142,7 @@ module Datadog
             "data" => {
               "type" => Ext::Transport::DD_API_SKIPPABLE_TESTS_TYPE,
               "attributes" => {
-                "test_level" => Ext::Test::ITR_TEST_SKIPPING_MODE,
+                "test_level" => @test_skipping_mode,
                 "service" => test_session.service,
                 "env" => @dd_env,
                 "repository_url" => test_session.git_repository_url,

data/lib/datadog/ci/test_impact_analysis/skippable_percentage/estimator.rb

@@ -48,13 +48,13 @@ module Datadog
 
             # starting and finishing a test session is required to get the skippable tests response
             Datadog::CI.start_test_session(total_tests_count: estimated_tests_count)&.finish
-            skippable_tests_count = test_impact_analysis.skippable_tests_count
+            skippables_count = test_impact_analysis.skippables_count
 
             log("Estimated tests count: #{estimated_tests_count}")
-            log("Skippable tests count: #{skippable_tests_count}")
+            log("Skippables count: #{skippables_count}")
             validate_test_impact_analysis_state!
 
-            [(skippable_tests_count.to_f / estimated_tests_count).floor(2), 0.99].min || 0.0
+            [(skippables_count.to_f / estimated_tests_count).floor(2), 0.99].min || 0.0
           end
         end
       end

data/lib/datadog/ci/test_optimization_cache/readers/legacy.rb

@@ -49,7 +49,7 @@ module Datadog
               tests_hash.each_value.flat_map do |test_configs|
                 test_configs.map do |test_config|
                   {
-                    "type" => Ext::Test::ITR_TEST_SKIPPING_MODE,
+                    "type" => Ext::Test::DEFAULT_TIA_TEST_SKIPPING_MODE,
                     "attributes" => {
                       "suite" => test_config["suite"],
                       "name" => test_config["name"],

data/lib/datadog/ci/test_suite.rb

@@ -111,6 +111,26 @@ module Datadog
         end
       end
 
+      # @internal
+      def datadog_skip_reason
+        get_tag(Ext::Test::TAG_SKIP_REASON)
+      end
+
+      # @internal
+      def should_skip?
+        skipped_by_test_impact_analysis?
+      end
+
+      # @internal
+      def skipped_by_test_impact_analysis?
+        get_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR) == "true"
+      end
+
+      # @internal
+      def itr_unskippable?
+        get_tag(Ext::Test::TAG_ITR_UNSKIPPABLE) == "true"
+      end
+
       private
 
       def set_status_from_stats!

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

@@ -272,6 +272,7 @@ module Datadog
 
         def on_test_suite_started(test_suite)
           set_codeowners(test_suite)
+          test_impact_analysis.on_test_suite_started(test_suite)
         end
 
         def on_test_started(test)
@@ -318,6 +319,7 @@ module Datadog
         end
 
         def on_test_suite_finished(test_suite)
+          test_impact_analysis.on_test_suite_finished(test_suite, maybe_remote_context)
           Telemetry.event_finished(test_suite)
         end
 

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "../ext/test"
 require_relative "../git/local_repository"
 
 module Datadog
@@ -13,6 +14,17 @@ module Datadog
         def self.service_name_provided_by_user?
           !!Datadog.configuration.service_without_fallback
         end
+
+        def self.normalize_tia_test_skipping_mode(mode)
+          return mode if Ext::Test::TIATestSkippingMode::ALL.include?(mode)
+
+          Datadog.logger.warn(
+            "Invalid Test Impact Analysis skipping mode #{mode.inspect}. " \
+            "Falling back to #{Ext::Test::TIATestSkippingMode::TEST.inspect}."
+          )
+
+          Ext::Test::TIATestSkippingMode::TEST
+        end
       end
     end
   end

data/lib/datadog/ci/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.33.0
+  version: 1.34.0
 platform: ruby
 authors:
 - Datadog, Inc.