datadog-ci 1.31.0 → 1.33.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de36af96e9eef5f7bffcfe3a3cb8e80ff08461b8f10795bff6a54e53d340a1c6
-  data.tar.gz: 5bdf32ef644ecaac3c57b55f94338359db56e18bea76fec6c40c76fbd1a907bd
+  metadata.gz: 6e5dd4e5fdf647baf9134e9fdcc5eb6d1215c48b08bf1905dd69e731a8ebe18e
+  data.tar.gz: 851eadff7367e69480490eea9fb7e5e074c2099008de2537c07efba2de9366bf
 SHA512:
-  metadata.gz: 702a1219da6c81acc12d6eca8743de08ff97dd5cdf728ff02556bb282673ac913502f49dd4db02bb4ddd119e8102a9ceacc4a081624a48fe256d3f402efa1887
-  data.tar.gz: 2470ec968a63e625234fe7cb70e9faadf7ce1ccc5a9cf9f04c668c271b693f6b3a3b38f3b5821e27908f299bf58773122b268decbbf3e65596a63cc39509be04
+  metadata.gz: 22bedcab49da1df468ae63d217b160d7e3a976a5b722aaa012622564629d8760afc39165b47dc8be7454b406db8e073be46524d0de02fa2b6fd13a4e685713c8
+  data.tar.gz: 9affe9fe044871139755c3fbbb0b28146bc07c2b36ed79627ad0db67ee254764fbca12bebafc9a317224bd275f9c60e5a978a3c526b8a11c0a4a92150152f104

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [1.33.0] - 2026-06-19
+
+### Added
+
+* Allow overriding runtime tags ([#527][])
+
+## [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 +659,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.31.0...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.33.0...main
+[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
 [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 +929,8 @@ 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
+[#527]: https://github.com/DataDog/datadog-ci-rb/issues/527

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

@@ -37,6 +37,7 @@ require_relative "../test_tracing/transport"
 require_relative "../transport/adapters/telemetry_webmock_safe_adapter"
 require_relative "../transport/api/builder"
 require_relative "../utils/parsing"
+require_relative "../utils/runtime_tags_overrides"
 require_relative "../utils/test_run"
 require_relative "../async_writer"
 require_relative "../worker"
@@ -169,6 +170,7 @@ module Datadog
             test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility,
             logical_test_session_name: settings.ci.test_session_name,
             known_tests_client: build_known_tests_client(settings, test_visibility_api),
+            runtime_tags_overrides: Utils::RuntimeTagsOverrides.parse(settings.ci.runtime_tags_overrides),
             context_service_uri: settings.ci.test_visibility_drb_server_uri
           )
 
@@ -192,7 +194,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/configuration/settings.rb

@@ -213,6 +213,11 @@ module Datadog
                 o.default true
               end
 
+              option :runtime_tags_overrides do |o|
+                o.type :string, nilable: true
+                o.env CI::Ext::Settings::ENV_RUNTIME_TAGS
+              end
+
               define_method(:instrument) do |integration_name, options = {}, &block|
                 return unless enabled
 

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/ext/settings.rb

@@ -32,6 +32,7 @@ module Datadog
         ENV_AUTO_INSTRUMENTATION_PROVIDER = "DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER"
         ENV_TIA_STATIC_DEPENDENCIES_TRACKING_ENABLED = "DD_TEST_OPTIMIZATION_TIA_STATIC_DEPS_COVERAGE_ENABLED"
         ENV_CODE_COVERAGE_REPORT_UPLOAD_ENABLED = "DD_CIVISIBILITY_CODE_COVERAGE_REPORT_UPLOAD_ENABLED"
+        ENV_RUNTIME_TAGS = "DD_TEST_OPTIMIZATION_RUNTIME_TAGS"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = %w[

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

@@ -51,7 +51,6 @@ module Datadog
           def build_constant_path(symbol_array)
             symbol_array
               .select { |part| part.is_a?(Symbol) }
-              .map(&:to_s)
               .join("::")
           end
 

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

@@ -37,11 +37,12 @@ module Datadog
           test_suite_level_visibility_enabled: false,
           codeowners: Codeowners::Parser.new(Git::LocalRepository.root).parse,
           logical_test_session_name: nil,
+          runtime_tags_overrides: {},
           context_service_uri: nil
         )
           @test_suite_level_visibility_enabled = test_suite_level_visibility_enabled
 
-          @context = Context.new(test_tracing_component: self)
+          @context = Context.new(test_tracing_component: self, runtime_tags_overrides: runtime_tags_overrides)
 
           @codeowners = codeowners
           @logical_test_session_name = logical_test_session_name

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

@@ -30,8 +30,9 @@ module Datadog
       class Context
         attr_reader :total_tests_count, :tests_skipped_by_tia_count
 
-        def initialize(test_tracing_component:)
+        def initialize(test_tracing_component:, runtime_tags_overrides: {})
           @test_tracing_component = test_tracing_component
+          @runtime_tags_overrides = runtime_tags_overrides
 
           @fiber_local_context = Store::FiberLocal.new
           @process_context = Store::Process.new
@@ -239,6 +240,7 @@ module Datadog
           ci_span.set_default_tags
           ci_span.set_environment_runtime_tags
 
+          ci_span.set_tags(@runtime_tags_overrides) unless @runtime_tags_overrides.empty?
           ci_span.set_tags(tags)
           ci_span.set_tags(@environment_tags)
 

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/utils/runtime_tags_overrides.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "../ext/test"
+
+module Datadog
+  module CI
+    module Utils
+      module RuntimeTagsOverrides
+        TAGS = [
+          Ext::Test::TAG_OS_PLATFORM,
+          Ext::Test::TAG_OS_ARCHITECTURE,
+          Ext::Test::TAG_OS_VERSION,
+          Ext::Test::TAG_RUNTIME_NAME,
+          Ext::Test::TAG_RUNTIME_VERSION
+        ].freeze
+
+        def self.parse(value)
+          return {} if value.nil? || value.to_s.strip.empty?
+
+          parsed = JSON.parse(value.to_s)
+          unless parsed.is_a?(Hash)
+            Datadog.logger.warn("Invalid runtime tag overrides configuration: expected JSON object")
+            return {}
+          end
+
+          parsed.each_with_object({}) do |(key, tag_value), tags|
+            next unless TAGS.include?(key)
+            next if tag_value.nil?
+
+            normalized_value = tag_value.to_s.strip
+            next if normalized_value.empty?
+
+            tags[key] = normalized_value
+          end
+        rescue JSON::ParserError => e
+          Datadog.logger.warn("Invalid runtime tag overrides configuration: #{e.message}")
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/version.rb

@@ -4,7 +4,7 @@ module Datadog
   module CI
     module VERSION
       MAJOR = 1
-      MINOR = 31
+      MINOR = 33
       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.33.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
@@ -317,6 +319,7 @@ files:
 - lib/datadog/ci/utils/json.rb
 - lib/datadog/ci/utils/parsing.rb
 - lib/datadog/ci/utils/rum.rb
+- lib/datadog/ci/utils/runtime_tags_overrides.rb
 - lib/datadog/ci/utils/stateful.rb
 - lib/datadog/ci/utils/telemetry.rb
 - lib/datadog/ci/utils/test_run.rb