datadog-ci 1.31.0 → 1.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de36af96e9eef5f7bffcfe3a3cb8e80ff08461b8f10795bff6a54e53d340a1c6
-  data.tar.gz: 5bdf32ef644ecaac3c57b55f94338359db56e18bea76fec6c40c76fbd1a907bd
+  metadata.gz: 9525584d2c9951d35efe82ecfead3c45e104ced47bddaa5c11146147dfab1ed8
+  data.tar.gz: 438719f7fb308e58196321706bf03beeda21c717875e9a23d88027a485d5dfba
 SHA512:
-  metadata.gz: 702a1219da6c81acc12d6eca8743de08ff97dd5cdf728ff02556bb282673ac913502f49dd4db02bb4ddd119e8102a9ceacc4a081624a48fe256d3f402efa1887
-  data.tar.gz: 2470ec968a63e625234fe7cb70e9faadf7ce1ccc5a9cf9f04c668c271b693f6b3a3b38f3b5821e27908f299bf58773122b268decbbf3e65596a63cc39509be04
+  metadata.gz: d1537eb0f893513d6ba2b2ccfacecfd2ff424c8f0d1f84ef27045d03d0d4963046b8c1df0611c7360cfbdd6a6a893e74804377b725b6439a559e27fe8e9ce57b
+  data.tar.gz: 31d30f06434ec6305d17000499879d1133a7f472ba01c3300d30effe2abf770b0f7bb002390a984baf9b77febbc3e4dc9b9390f249a2c81a66aa68ecd37bf344

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [1.32.0] - 2026-06-08
+
+### Changed
+
+* Truncate CI Visibility meta tag values ([#515][])
+
+### Fixed
+
+* Fix Minitest TIA skipped hooks ([#516][])
+* Fix: use Gem::Version for Ruby allocation tracing check ([#522][])
+* Fix symbol collision with a debug gem ([#521][])
+
 ## [1.31.0] - 2026-05-20
 
 ### Added
@@ -641,7 +653,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.31.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.32.0...main
+[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
 [1.30.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.29.0...v1.30.0
 [1.29.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.28.0...v1.29.0
@@ -909,3 +922,7 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#506]: https://github.com/DataDog/datadog-ci-rb/issues/506
 [#509]: https://github.com/DataDog/datadog-ci-rb/issues/509
 [#511]: https://github.com/DataDog/datadog-ci-rb/issues/511
+[#515]: https://github.com/DataDog/datadog-ci-rb/issues/515
+[#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

data/ext/datadog_ci_native/ci.c

@@ -8,5 +8,5 @@ void Init_datadog_ci_native(void) {
 
   // SourceCode
   Init_datadog_method_inspect();
-  Init_iseq_collector();
+  Init_dd_ci_iseq_collector();
 }

data/ext/datadog_ci_native/iseq_collector.c

@@ -54,7 +54,7 @@ static VALUE iseq_collector_collect(VALUE self) {
 
 /* ---- Module initialization ---------------------------------------------- */
 
-void Init_iseq_collector(void) {
+void Init_dd_ci_iseq_collector(void) {
   VALUE mDatadog = rb_define_module("Datadog");
   VALUE mCI = rb_define_module_under(mDatadog, "CI");
   VALUE mSourceCode = rb_define_module_under(mCI, "SourceCode");

data/ext/datadog_ci_native/iseq_collector.h

@@ -1,6 +1,6 @@
 #ifndef ISEQ_COLLECTOR_H
 #define ISEQ_COLLECTOR_H
 
-void Init_iseq_collector(void);
+void Init_dd_ci_iseq_collector(void);
 
 #endif /* ISEQ_COLLECTOR_H */

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

@@ -192,7 +192,8 @@ module Datadog
             settings.ci.itr_test_impact_analysis_use_allocation_tracing = false
           end
 
-          if RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3" &&
+          if RUBY_VERSION.start_with?("3.2.") &&
+              Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.2.3") &&
               settings.ci.itr_test_impact_analysis_use_allocation_tracing
             Datadog.logger.warn(
               "Test Impact Analysis: Allocation tracing is not supported in Ruby versions 3.2.0, 3.2.1 and 3.2.2 and will be forcibly " \

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

@@ -61,8 +61,11 @@ module Datadog
           end
 
           def self.parallel?(klass)
-            klass.ancestors.include?(::Minitest::Parallel::Test) ||
-              (defined?(::Minitest::Queue) && ::Minitest.singleton_class.ancestors.include?(::Minitest::Queue))
+            klass.ancestors.include?(::Minitest::Parallel::Test) || ci_queue?
+          end
+
+          def self.ci_queue?
+            !!(defined?(::Minitest::Queue) && ::Minitest.singleton_class.ancestors.include?(::Minitest::Queue))
           end
 
           def self.extract_source_location_from_class(klass)

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Contrib
+      module Minitest
+        # Captures the concrete Minitest::Test#run implementation below Datadog.
+        #
+        # This exists because ci-queue loads minitest-reporters, and minitest-reporters
+        # aliases the current Minitest::Test#run as run_without_hooks before replacing it
+        # with its own wrapper. If Datadog has already prepended its run method, that alias
+        # points back to Datadog and re-enters the same active test span.
+        #
+        # Auto-instrumentation makes this trickier: it patches from a script_compiled
+        # TracePoint, so it can observe Minitest::Test while `require "minitest"` is still
+        # evaluating the class body. In that window Minitest::Test exists, but its concrete
+        # #run has not been defined yet, so instance_method(:run) resolves to the abstract
+        # Minitest::Runnable#run. The one-shot method_added path below replaces that early
+        # abstract capture with the concrete Minitest::Test#run, before later plugin wrappers
+        # like minitest-reporters can alias Datadog's wrapper.
+        module RunMethodCapture
+          class << self
+            def capture_concrete_pre_datadog_run!(storage, owner, datadog_run_owner)
+              saved_run = storage._dd_pre_datadog_minitest_run
+              return if concrete_pre_datadog_run?(saved_run, datadog_run_owner)
+              return if !defined?(::Minitest::Test) || !owner.equal?(::Minitest::Test)
+
+              datadog_run = owner.instance_method(:run)
+              return unless datadog_run.owner == datadog_run_owner
+
+              candidate_run = datadog_run.super_method
+              if concrete_pre_datadog_run?(candidate_run, datadog_run_owner)
+                storage._dd_pre_datadog_minitest_run = candidate_run
+              end
+            end
+
+            def concrete_pre_datadog_run?(method, datadog_run_owner)
+              method &&
+                method.owner != datadog_run_owner &&
+                (!defined?(::Minitest::Runnable) || method.owner != ::Minitest::Runnable)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ require_relative "../../source_code/method_inspect"
 require_relative "../instrumentation"
 require_relative "ext"
 require_relative "helpers"
+require_relative "run_method_capture"
 
 module Datadog
   module CI
@@ -13,16 +14,68 @@ module Datadog
       module Minitest
         # Lifecycle hooks to instrument Minitest::Test
         module Test
+          class << self
+            attr_accessor :_dd_pre_datadog_minitest_run
+          end
+
           def self.included(base)
-            base.prepend(InstanceMethods)
-            base.singleton_class.prepend(ClassMethods)
+            unless base < InstanceMethods
+              # Preserve the run implementation that existed before Datadog was prepended.
+              # RunMethodCapture repairs this if auto-instrumentation observes Minitest::Test
+              # before Minitest defines its concrete #run. See that helper for the ci-queue
+              # and minitest-reporters load-order details.
+              self._dd_pre_datadog_minitest_run = base.instance_method(:run)
+              base.prepend(InstanceMethods)
+            end
+
+            base.singleton_class.prepend(ClassMethods) unless base.singleton_class < ClassMethods
           end
 
           module InstanceMethods
-            def before_setup
+            def run
+              return super unless datadog_configuration[:enabled]
+
+              return run_without_datadog_reentry if datadog_run_reentered?
+
+              test_span = start_datadog_test
+              return skip_datadog_test(test_span) if test_span&.should_skip?
+
+              super
+            end
+
+            def after_teardown
+              test_span = _dd_test_tracing_component.active_test
+              return super unless test_span
+
+              finish_with_result(test_span, result_code)
+
+              # remove failures if failure can be ignored because of retries
+              self.failures = [] if test_span.should_ignore_failures?
+
               super
-              return unless datadog_configuration[:enabled]
+            end
+
+            private
 
+            def datadog_run_reentered?
+              !!_dd_test_tracing_component.active_test
+            end
+
+            def run_without_datadog_reentry
+              Datadog.logger.debug do
+                "Datadog Minitest instrumentation re-entered for #{self.class}##{name}; running pre-Datadog Minitest run without starting another test span"
+              end
+
+              pre_datadog_minitest_run = Test._dd_pre_datadog_minitest_run
+              if RunMethodCapture.concrete_pre_datadog_run?(pre_datadog_minitest_run, InstanceMethods)
+                return pre_datadog_minitest_run.bind_call(self)
+              end
+
+              raise "Datadog Minitest instrumentation re-entered for #{self.class}##{name}, " \
+                "but the concrete pre-Datadog Minitest::Test#run method was not captured"
+            end
+
+            def start_datadog_test
               if Helpers.parallel?(self.class)
                 Helpers.start_test_suite(self.class)
               end
@@ -55,23 +108,22 @@ module Datadog
               # steep:ignore:start
               test_span&.itr_unskippable! if self.class.dd_suite_unskippable? || self.class.dd_test_unskippable?(name)
               # steep:ignore:end
-              skip(test_span&.datadog_skip_reason) if test_span&.should_skip?
+
+              test_span
             end
 
-            def after_teardown
-              test_span = _dd_test_tracing_component.active_test
-              return super unless test_span
+            def skip_datadog_test(test_span)
+              time_it do
+                capture_exceptions do
+                  skip(test_span.datadog_skip_reason)
+                end
+              end
 
               finish_with_result(test_span, result_code)
 
-              # remove failures if failure can be ignored because of retries
-              self.failures = [] if test_span.should_ignore_failures?
-
-              super
+              ::Minitest::Result.from(self)
             end
 
-            private
-
             def finish_with_result(span, result_code)
               return unless span
 
@@ -101,6 +153,12 @@ module Datadog
           end
 
           module ClassMethods
+            def method_added(method_name)
+              RunMethodCapture.capture_concrete_pre_datadog_run!(Test, self, InstanceMethods) if method_name == :run
+            ensure
+              super
+            end
+
             def datadog_itr_unskippable(*args)
               if args.nil? || args.empty?
                 @datadog_itr_unskippable_suite = true

data/lib/datadog/ci/test_tracing/serializers/base.rb

@@ -3,6 +3,7 @@
 require "set"
 
 require_relative "../../ext/test"
+require_relative "meta_truncation"
 
 module Datadog
   module CI
@@ -29,7 +30,9 @@ module Datadog
             @span = span
             @options = options
 
-            @meta = @span.meta.reject { |key, _| Ext::Test::TRANSIENT_TAGS.include?(key) }
+            @meta = MetaTruncation.truncate_string_values(
+              @span.meta.reject { |key, _| Ext::Test::TRANSIENT_TAGS.include?(key) }
+            )
 
             @errors = {}
             @validated = false

data/lib/datadog/ci/test_tracing/serializers/meta_truncation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module TestTracing
+      module Serializers
+        module MetaTruncation
+          MAX_META_STRING_LENGTH = 5000
+
+          def self.truncate_value(value)
+            return value unless value.is_a?(String) && value.length > MAX_META_STRING_LENGTH
+
+            value[0, MAX_META_STRING_LENGTH]
+          end
+
+          def self.truncate_string_values(tags)
+            tags.transform_values { |value| truncate_value(value) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ require "datadog/core/telemetry/logging"
 require "datadog/core/utils/only_once"
 
 require_relative "serializers/factories/test_level"
+require_relative "serializers/meta_truncation"
 
 require_relative "../ext/app_types"
 require_relative "../ext/telemetry"
@@ -105,17 +106,17 @@ module Datadog
 
           if dd_env
             packer.write("env")
-            packer.write(dd_env)
+            packer.write(Serializers::MetaTruncation.truncate_value(dd_env))
           end
 
           packer.write("runtime-id")
-          packer.write(Datadog::Core::Environment::Identity.id)
+          packer.write(Serializers::MetaTruncation.truncate_value(Datadog::Core::Environment::Identity.id))
 
           packer.write("language")
-          packer.write(Datadog::Core::Environment::Identity.lang)
+          packer.write(Serializers::MetaTruncation.truncate_value(Datadog::Core::Environment::Identity.lang))
 
           packer.write("library_version")
-          packer.write(Datadog::CI::VERSION::STRING)
+          packer.write(Serializers::MetaTruncation.truncate_value(Datadog::CI::VERSION::STRING))
 
           library_capabilities_tags = Ext::Test::LibraryCapabilities::CAPABILITY_VERSIONS
 
@@ -124,14 +125,16 @@ module Datadog
             packer.write_map_header(2 + library_capabilities_tags.count)
 
             packer.write(Ext::Test::TAG_TEST_SESSION_NAME)
-            packer.write(test_tracing&.logical_test_session_name)
+            packer.write(Serializers::MetaTruncation.truncate_value(test_tracing&.logical_test_session_name))
 
             packer.write(Ext::Test::TAG_USER_PROVIDED_TEST_SERVICE)
-            packer.write(Utils::Configuration.service_name_provided_by_user?.to_s)
+            packer.write(
+              Serializers::MetaTruncation.truncate_value(Utils::Configuration.service_name_provided_by_user?.to_s)
+            )
 
             library_capabilities_tags.each do |tag, value|
               packer.write(tag)
-              packer.write(value)
+              packer.write(Serializers::MetaTruncation.truncate_value(value))
             end
           end
 

data/lib/datadog/ci/version.rb

@@ -4,7 +4,7 @@ module Datadog
   module CI
     module VERSION
       MAJOR = 1
-      MINOR = 31
+      MINOR = 32
       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.31.0
+  version: 1.32.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -140,6 +140,7 @@ files:
 - 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/run_method_capture.rb
 - lib/datadog/ci/contrib/minitest/runnable.rb
 - lib/datadog/ci/contrib/minitest/runnable_minitest_6.rb
 - lib/datadog/ci/contrib/minitest/runner.rb
@@ -288,6 +289,7 @@ files:
 - lib/datadog/ci/test_tracing/serializers/base.rb
 - lib/datadog/ci/test_tracing/serializers/factories/test_level.rb
 - lib/datadog/ci/test_tracing/serializers/factories/test_suite_level.rb
+- lib/datadog/ci/test_tracing/serializers/meta_truncation.rb
 - lib/datadog/ci/test_tracing/serializers/span.rb
 - lib/datadog/ci/test_tracing/serializers/test_module.rb
 - lib/datadog/ci/test_tracing/serializers/test_session.rb