datadog-ci 1.23.3 → 1.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a911ce98b1577d684374a00e8efd9ecbcf34fac28f24bb543411dbb762163d8c
-  data.tar.gz: 93c277bf2fc40ccdede20e48102eb6b1c1721336d80b62e60c9a191b807f8754
+  metadata.gz: e68ff85fe19330eb395ad72da915dbad1bf98c02f5c917402da73b4f5ebab745
+  data.tar.gz: aa30fff0bb9f8349e3c9caa5d9ff77cbdd57b7c1cf8e61fdd19d98ebcb271711
 SHA512:
-  metadata.gz: eb8fef68d0b4e9e6dc02aa76c603b98e854b09ef47913c30c986d4e397e9b48c79ec14d5ebb9dd1e48db0737def7d73f7e33aefbb35039441e65b4005884051a
-  data.tar.gz: 072aa07eb4af30102c588a54c75398634e1b409cd1698a087b8e0cb030bc6bb6c5bd8b98ba2c57716e8d819b61ace6ed9ed4ea39a5eda0e1accedc0e232a1eaf
+  metadata.gz: '0668a4e35ef63218065e169ab00dfe7e7bfc4439c35f6020611d35a2a625dbdb20d38aa3e7edd3a5cf3769e15bd31077717141029223637cabeb34b172069aa8'
+  data.tar.gz: 119fef9be7bd8ab89c013fa545dd3d09b8013fa6ef79db438e59c12b8fd1acc42734bc9faa8f0f3ff63d28fec0b3480c7f43e89ca10a5ce83ee7b6e7a26b1422

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [1.25.0] - 2025-12-19
+
+### Added
+* Minitest 6.0 support ([#446][])
+* Support Ruby 4.0 ([#444][])
+
+## [1.24.0] - 2025-12-15
+
+### Added
+* Create final status tag on test events ([#433][])
+
+### Changed
+* Add `branch` parameter to `/test-management/tests` request ([#436][])
+
+### Fixed
+* Fix an inheritance blind spot for Test Impact Analysis ([#440][])
+
 ## [1.23.3] - 2025-11-19
 
 ### Fixed
@@ -554,7 +571,9 @@ 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.23.3...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.25.0...main
+[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
 [1.23.3]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.2...v1.23.3
 [1.23.2]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.1...v1.23.2
 [1.23.1]: https://github.com/DataDog/datadog-ci-rb/compare/v1.23.0...v1.23.1
@@ -786,4 +805,9 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#416]: https://github.com/DataDog/datadog-ci-rb/issues/416
 [#418]: https://github.com/DataDog/datadog-ci-rb/issues/418
 [#425]: https://github.com/DataDog/datadog-ci-rb/issues/425
-[#430]: https://github.com/DataDog/datadog-ci-rb/issues/430
+[#430]: https://github.com/DataDog/datadog-ci-rb/issues/430
+[#433]: https://github.com/DataDog/datadog-ci-rb/issues/433
+[#436]: https://github.com/DataDog/datadog-ci-rb/issues/436
+[#440]: https://github.com/DataDog/datadog-ci-rb/issues/440
+[#444]: https://github.com/DataDog/datadog-ci-rb/issues/444
+[#446]: https://github.com/DataDog/datadog-ci-rb/issues/446

data/ext/datadog_ci_native/datadog_cov.c

@@ -156,12 +156,12 @@ static VALUE dd_cov_allocate(VALUE klass) {
 
 // Checks if the filename is located under the root folder of the project (but
 // not in the ignored folder) and adds it to the impacted_files hash.
-static void record_impacted_file(struct dd_cov_data *dd_cov_data,
+static bool record_impacted_file(struct dd_cov_data *dd_cov_data,
                                  VALUE filename) {
   char *filename_ptr = RSTRING_PTR(filename);
   // if the current filename is not located under the root, we skip it
   if (strncmp(dd_cov_data->root, filename_ptr, dd_cov_data->root_len) != 0) {
-    return;
+    return false;
   }
 
   // if ignored_path is provided and the current filename is located under the
@@ -170,10 +170,11 @@ static void record_impacted_file(struct dd_cov_data *dd_cov_data,
   if (dd_cov_data->ignored_path_len != 0 &&
       strncmp(dd_cov_data->ignored_path, filename_ptr,
               dd_cov_data->ignored_path_len) == 0) {
-    return;
+    return false;
   }
 
   rb_hash_aset(dd_cov_data->impacted_files, filename, Qtrue);
+  return true;
 }
 
 // Executed on RUBY_EVENT_LINE event and captures the filename from
@@ -221,29 +222,61 @@ static VALUE safely_get_source_location(VALUE klass_name) {
   return rescue_nil(get_source_location, klass_name);
 }
 
-// This function is called for each class that was instantiated during the test
-// run.
-static int process_instantiated_klass(st_data_t key, st_data_t _value,
-                                      st_data_t data) {
-  VALUE klass = (VALUE)key;
-  struct dd_cov_data *dd_cov_data = (struct dd_cov_data *)data;
+// Safely get class name, returns Qnil on any error
+static VALUE safely_get_class_name(VALUE klass) {
+  return rescue_nil(rb_class_name, klass);
+}
 
-  VALUE klass_name = rb_class_name(klass);
+// Safely get module ancestors, returns Qnil on any error
+static VALUE safely_get_mod_ancestors(VALUE klass) {
+  return rescue_nil(rb_mod_ancestors, klass);
+}
+
+static bool record_impacted_klass(struct dd_cov_data *dd_cov_data,
+                                  VALUE klass) {
+  VALUE klass_name = safely_get_class_name(klass);
   if (klass_name == Qnil) {
-    return ST_CONTINUE;
+    return false;
   }
 
   VALUE source_location = safely_get_source_location(klass_name);
-  if (source_location == Qnil || RARRAY_LEN(source_location) == 0) {
-    return ST_CONTINUE;
+  if (source_location == Qnil || !RB_TYPE_P(source_location, T_ARRAY) ||
+      RARRAY_LEN(source_location) == 0) {
+    return false;
   }
 
   VALUE filename = RARRAY_AREF(source_location, 0);
   if (filename == Qnil || !RB_TYPE_P(filename, T_STRING)) {
+    return false;
+  }
+
+  return record_impacted_file(dd_cov_data, filename);
+}
+
+// This function is called for each class that was instantiated during the test
+// run.
+static int each_instantiated_klass(st_data_t key, st_data_t _value,
+                                   st_data_t data) {
+  VALUE klass = (VALUE)key;
+  struct dd_cov_data *dd_cov_data = (struct dd_cov_data *)data;
+
+  // rb_mod_ancestors returns an array containing the "klass" itself
+  // and all the parent classes and/or included/prepended modules
+  VALUE ancestors = safely_get_mod_ancestors(klass);
+  if (ancestors == Qnil || !RB_TYPE_P(ancestors, T_ARRAY)) {
     return ST_CONTINUE;
   }
 
-  record_impacted_file(dd_cov_data, filename);
+  long len = RARRAY_LEN(ancestors);
+  for (long i = 0; i < len; i++) {
+    VALUE mod = rb_ary_entry(ancestors, i);
+    if (mod == Qnil) {
+      continue;
+    }
+
+    record_impacted_klass(dd_cov_data, mod);
+  }
+
   return ST_CONTINUE;
 }
 
@@ -385,7 +418,7 @@ static VALUE dd_cov_stop(VALUE self) {
   }
 
   // process classes covered by allocation tracing
-  st_foreach(dd_cov_data->klasses_table, process_instantiated_klass,
+  st_foreach(dd_cov_data->klasses_table, each_instantiated_klass,
              (st_data_t)dd_cov_data);
   st_clear(dd_cov_data->klasses_table);
 

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

@@ -18,7 +18,7 @@ module Datadog
 
           def loaded?
             !defined?(::Minitest).nil? && !defined?(::Minitest::Runnable).nil? && !defined?(::Minitest::Test).nil? &&
-              !defined?(::Minitest::CompositeReporter).nil?
+              !defined?(::Minitest::CompositeReporter).nil? && !defined?(::Minitest::Parallel::Executor).nil?
           end
 
           def compatible?

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "../../ext/test"
+require_relative "../../git/local_repository"
+require_relative "../../utils/source_code"
+require_relative "../instrumentation"
+require_relative "ext"
+require_relative "helpers"
+
+module Datadog
+  module CI
+    module Contrib
+      module Minitest
+        # Lifecycle hooks to instrument Minitest::Test
+        module ParallelExecutorMinitest6
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          module InstanceMethods
+            def start
+              return super unless datadog_configuration[:enabled]
+
+              @pool = Array.new(size) {
+                Thread.new @queue do |queue|
+                  Thread.current.abort_on_exception = true
+                  while (job = queue.pop)
+                    klass, method, reporter = job
+                    reporter.synchronize { reporter.prerecord klass, method }
+                    result = ::Minitest.run_one_method(klass, method)
+                    reporter.synchronize { reporter.record result }
+                  end
+                end
+              }
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration.ci[:minitest]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,9 @@ require_relative "reporter"
 require_relative "test"
 require_relative "runnable"
 
+require_relative "runnable_minitest_6"
+require_relative "parallel_executor_minitest_6"
+
 module Datadog
   module CI
     module Contrib
@@ -18,8 +21,15 @@ module Datadog
           def patch
             # test session start
             ::Minitest.include(Runner)
+
             # test suites (when not executed concurrently)
-            ::Minitest::Runnable.include(Runnable)
+            if ::Minitest::Runnable.respond_to?(:run_suite)
+              ::Minitest::Runnable.include(RunnableMinitest6)
+              ::Minitest::Parallel::Executor.include(ParallelExecutorMinitest6)
+            else
+              ::Minitest::Runnable.include(Runnable)
+            end
+
             # tests; test suites (when executed concurrently)
             ::Minitest::Test.include(Test)
             # test session finish

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

@@ -20,7 +20,6 @@ module Datadog
               return results unless test_suite
 
               test_suite.finish
-
               results
             end
 
@@ -29,10 +28,6 @@ module Datadog
             def datadog_configuration
               Datadog.configuration.ci[:minitest]
             end
-
-            def test_visibility_component
-              Datadog.send(:components).test_visibility
-            end
           end
         end
       end

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

@@ -0,0 +1,49 @@
+require_relative "helpers"
+
+module Datadog
+  module CI
+    module Contrib
+      module Minitest
+        module RunnableMinitest6
+          def self.included(base)
+            base.singleton_class.prepend(ClassMethods)
+          end
+
+          module ClassMethods
+            def run_suite(*args)
+              return super unless datadog_configuration[:enabled]
+              return super if Helpers.parallel?(self)
+
+              test_suite = Helpers.start_test_suite(self)
+
+              results = super
+              return results unless test_suite
+
+              test_suite.finish
+              results
+            end
+
+            def run(klass, method_name, reporter)
+              reporter.prerecord klass, method_name
+              reporter.record ::Minitest.run_one_method(klass, method_name)
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration.ci[:minitest]
+            end
+
+            def _dd_test_visibility_component
+              Datadog.send(:components).test_visibility
+            end
+
+            def _dd_test_retries_component
+              Datadog.send(:components).test_retries
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -35,14 +35,20 @@ module Datadog
               test_visibility_component.start_test_module(Ext::FRAMEWORK)
             end
 
+            def old_run_one_method(klass, method_name)
+              result = klass.new(method_name).run
+              raise "#{klass}#run _must_ return a Result" unless ::Minitest::Result === result
+              result
+            end
+
             def run_one_method(klass, method_name)
-              return super unless datadog_configuration[:enabled]
+              return old_run_one_method(klass, method_name) unless datadog_configuration[:enabled]
 
               # @type var result: untyped
               result = nil
 
               test_retries_component.with_retries do
-                result = super
+                result = old_run_one_method(klass, method_name)
               end
 
               # get the current test suite and mark this method as done, so we can check if all tests were executed

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

@@ -44,7 +44,7 @@ module Datadog
               tags[CI::Ext::Test::TAG_SOURCE_START] = first_line_number.to_s if first_line_number
               tags[CI::Ext::Test::TAG_SOURCE_END] = last_line_number.to_s if last_line_number
 
-              test_span = test_visibility_component.trace_test(
+              test_span = _dd_test_visibility_component.trace_test(
                 name,
                 test_suite_name,
                 tags: tags,
@@ -59,7 +59,7 @@ module Datadog
             end
 
             def after_teardown
-              test_span = test_visibility_component.active_test
+              test_span = _dd_test_visibility_component.active_test
               return super unless test_span
 
               finish_with_result(test_span, result_code)
@@ -95,7 +95,7 @@ module Datadog
               Datadog.configuration.ci[:minitest]
             end
 
-            def test_visibility_component
+            def _dd_test_visibility_component
               Datadog.send(:components).test_visibility
             end
           end

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

@@ -13,7 +13,21 @@ module Datadog
         TAG_FRAMEWORK_VERSION = "test.framework_version"
         TAG_NAME = "test.name"
         TAG_SKIP_REASON = "test.skip_reason"
+
+        # Status is the result of a single test run
+        # See the [Datadog::CI::Ext::Test::Status] module for the list of possible values of this tag
         TAG_STATUS = "test.status"
+        # Final status is the result that Datadog reports after all retries for a given test. It might be different
+        # from the status of the given test run:
+        #
+        # Example: new test was retried 10 times by Early Flake Detection. It succeeded 9 times and failed once.
+        # The final status will be "pass" because we keep CI green for flaky tests.
+        #
+        # This tag is useful to create monitors on hard failures: if test.final_status is "fail", then CI is red.
+        #
+        # See the [Datadog::CI::Ext::Test::Status] module for the list of possible values of this tag
+        TAG_FINAL_STATUS = "test.final_status"
+
         TAG_SUITE = "test.suite"
         TAG_MODULE = "test.module"
         TAG_TYPE = "test.type"

data/lib/datadog/ci/test.rb

@@ -244,6 +244,32 @@ module Datadog
         get_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR) == "true"
       end
 
+      # @internal
+      def record_final_status
+        status = get_tag(Ext::Test::TAG_STATUS)
+        return if status.nil?
+
+        if [Ext::Test::Status::PASS, Ext::Test::Status::SKIP].include?(status)
+          set_tag(Ext::Test::TAG_FINAL_STATUS, status)
+          return
+        end
+
+        if should_ignore_failures?
+          set_tag(Ext::Test::TAG_FINAL_STATUS, Ext::Test::Status::PASS)
+        else
+          set_tag(Ext::Test::TAG_FINAL_STATUS, Ext::Test::Status::FAIL)
+        end
+      end
+
+      # @internal
+      def peek_duration
+        end_time = Core::Utils::Time.now.utc
+        start_time = tracer_span.start_time
+
+        return 0.0 if start_time.nil? || end_time.nil?
+        end_time - start_time
+      end
+
       private
 
       def record_test_result(datadog_status)

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

@@ -127,7 +127,8 @@ module Datadog
               "attributes" => {
                 "repository_url" => test_session.git_repository_url,
                 "commit_message" => test_session.original_git_commit_message,
-                "sha" => test_session.original_git_commit_sha
+                "sha" => test_session.original_git_commit_sha,
+                "branch" => test_session.git_branch
               }
             }
           }.to_json

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

@@ -94,18 +94,27 @@ module Datadog
 
         def record_test_finished(test_span)
           if current_retry_driver.nil?
-            # we always run test at least once and after the first pass create a correct retry driver
+            # We always run test at least once and after the first pass create a correct retry driver
             self.current_retry_driver = build_driver(test_span)
           else
-            # after each retry we record the result, the driver will decide if we should retry again
+            # After each retry we let the driver to record the result.
+            # Then the driver will decide if we should retry again.
             current_retry_driver&.record_retry(test_span)
 
+            # We know that the test was already retried at least once so if we should not retry anymore, then this
+            # is the last retry.
             tag_last_retry(test_span) unless should_retry?
           end
-        end
 
-        def record_test_span_duration(tracer_span)
-          current_retry_driver&.record_duration(tracer_span.duration)
+          # Some retry strategies such as Early Flake Detection change the number of retries based on
+          # how long the test was.
+          current_retry_driver&.record_duration(test_span.peek_duration)
+
+          # We need to set the final status of the test (what will be reported to the test framework) on the last execution
+          # no matter if test was retried or not
+          #
+          # If we should not retry at this point, it means that this execution is the last one (it might the only one as well).
+          test_span.record_final_status unless should_retry?
         end
 
         # this API is targeted on Cucumber instrumentation or any other that cannot leverage #with_retries method

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

@@ -13,8 +13,7 @@ module Datadog
         end
 
         def with_retries(&block)
-          no_action = proc {}
-          yield no_action
+          yield
         end
 
         def reset_retries!

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

@@ -121,8 +121,6 @@ module Datadog
 
           if block
             @context.trace_test(test_name, test_suite, service: service, tags: tags) do |test|
-              subscribe_to_after_stop_event(test.tracer_span)
-
               on_test_started(test)
               res = block.call(test)
               on_test_finished(test)
@@ -130,7 +128,6 @@ module Datadog
             end
           else
             test = @context.trace_test(test_name, test_suite, service: service, tags: tags)
-            subscribe_to_after_stop_event(test.tracer_span)
             on_test_started(test)
             test
           end
@@ -340,10 +337,6 @@ module Datadog
           Telemetry.event_finished(test)
         end
 
-        def on_after_test_span_finished(tracer_span)
-          test_retries.record_test_span_duration(tracer_span)
-        end
-
         # HELPERS
         def single_active_test_suite
           # when fetching test_suite to use as test's context, try local context instance first
@@ -357,14 +350,6 @@ module Datadog
           block&.call(nil)
         end
 
-        def subscribe_to_after_stop_event(tracer_span)
-          events = tracer_span.send(:events)
-
-          events.after_stop.subscribe do |span|
-            on_after_test_span_finished(span)
-          end
-        end
-
         def set_codeowners(span)
           source = span.source_file
           owners = @codeowners.list_owners(source) if source

data/lib/datadog/ci/version.rb

@@ -4,8 +4,8 @@ module Datadog
   module CI
     module VERSION
       MAJOR = 1
-      MINOR = 23
-      PATCH = 3
+      MINOR = 25
+      PATCH = 0
       PRE = nil
       BUILD = nil
       # PRE and BUILD above are modified for dev gems during gem build GHA workflow
@@ -22,7 +22,7 @@ module Datadog
       # To allow testing with the next unreleased version of Ruby, the version check is performed
       # as `< #{MAXIMUM_RUBY_VERSION}`, meaning prereleases of MAXIMUM_RUBY_VERSION are allowed
       # but not stable MAXIMUM_RUBY_VERSION releases.
-      MAXIMUM_RUBY_VERSION = "4.0"
+      MAXIMUM_RUBY_VERSION = "4.1"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog-ci
 version: !ruby/object:Gem::Version
-  version: 1.23.3
+  version: 1.25.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -127,9 +127,11 @@ files:
 - lib/datadog/ci/contrib/minitest/ext.rb
 - lib/datadog/ci/contrib/minitest/helpers.rb
 - lib/datadog/ci/contrib/minitest/integration.rb
+- lib/datadog/ci/contrib/minitest/parallel_executor_minitest_6.rb
 - lib/datadog/ci/contrib/minitest/patcher.rb
 - lib/datadog/ci/contrib/minitest/reporter.rb
 - lib/datadog/ci/contrib/minitest/runnable.rb
+- lib/datadog/ci/contrib/minitest/runnable_minitest_6.rb
 - lib/datadog/ci/contrib/minitest/runner.rb
 - lib/datadog/ci/contrib/minitest/test.rb
 - lib/datadog/ci/contrib/parallel_tests/cli.rb
@@ -315,7 +317,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0
   - - "<"
     - !ruby/object:Gem::Version
-      version: '4.0'
+      version: '4.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="