datadog-ci 1.23.3 → 1.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a911ce98b1577d684374a00e8efd9ecbcf34fac28f24bb543411dbb762163d8c
-  data.tar.gz: 93c277bf2fc40ccdede20e48102eb6b1c1721336d80b62e60c9a191b807f8754
+  metadata.gz: 30bc86afa5d05d656f9abfa7ffb5ff21d6f9a8fc5edeb5924651de4cdc6df10d
+  data.tar.gz: c846a97a47a74120d9926350360cefa4ca3fcdadea6819337ad2990f7856e267
 SHA512:
-  metadata.gz: eb8fef68d0b4e9e6dc02aa76c603b98e854b09ef47913c30c986d4e397e9b48c79ec14d5ebb9dd1e48db0737def7d73f7e33aefbb35039441e65b4005884051a
-  data.tar.gz: 072aa07eb4af30102c588a54c75398634e1b409cd1698a087b8e0cb030bc6bb6c5bd8b98ba2c57716e8d819b61ace6ed9ed4ea39a5eda0e1accedc0e232a1eaf
+  metadata.gz: 2e2a5b3efa12f1c64176e1751e86ebf803f8c894aba7c53453abb22732e0ed16a6087292538b2e03f0657dc9433ceba9e452f5899a95ace325a004ee12c37fbc
+  data.tar.gz: 461912b9cb9f406c4fd1cb9975ece506df7e979ed7b373b46c9e0060977f397b2da63095be353351d74b4273ea3cc1a354c12a4ef9dc7bf75a0a5ed065a16fa3

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [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 +565,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.23.3...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.24.0...main
+[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 +798,7 @@ 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

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/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_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 = 24
+      PATCH = 0
       PRE = nil
       BUILD = nil
       # PRE and BUILD above are modified for dev gems during gem build GHA workflow

metadata

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