datadog-ci 1.30.0 → 1.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 129bc549b30318587b435c3836517faa058dac0860f07eca408fc5562186e52f
-  data.tar.gz: 4a8c2756b9c846a4b5b225c51e0d1b3910e24c550f60adce4b47f968981a2b8d
+  metadata.gz: 9525584d2c9951d35efe82ecfead3c45e104ced47bddaa5c11146147dfab1ed8
+  data.tar.gz: 438719f7fb308e58196321706bf03beeda21c717875e9a23d88027a485d5dfba
 SHA512:
-  metadata.gz: ee1ceadbb2c83d09c780bfe517d52dd4a55b5a4a4dc6802fea1e653fe06b308e7eda9a90a420c1ff855b59b27a7ada8253f319f55664ade19cceb5cab79e3c60
-  data.tar.gz: f297af41a17c77ef5c123ad71a79e92a489218bea1b081d802f414a8496fe7e7ca4da50cde169c290ea3a6c0b189a3987f88f07cdf54bb4c822958527ac26117
+  metadata.gz: d1537eb0f893513d6ba2b2ccfacecfd2ff424c8f0d1f84ef27045d03d0d4963046b8c1df0611c7360cfbdd6a6a893e74804377b725b6439a559e27fe8e9ce57b
+  data.tar.gz: 31d30f06434ec6305d17000499879d1133a7f472ba01c3300d30effe2abf770b0f7bb002390a984baf9b77febbc3e4dc9b9390f249a2c81a66aa68ecd37bf344

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## [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
+
+* Add Test Optimization cache readers for Bazel support and DDTest (test parallelization) ([#511][])
+* Add Jenkins custom parent id env var ([#509][])
+
 ## [1.30.0] - 2026-05-12
 
 ### Changed
@@ -634,7 +653,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.30.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
 [1.28.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.27.0...v1.28.0
@@ -898,4 +919,10 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#499]: https://github.com/DataDog/datadog-ci-rb/issues/499
 [#500]: https://github.com/DataDog/datadog-ci-rb/issues/500
 [#501]: https://github.com/DataDog/datadog-ci-rb/issues/501
-[#506]: https://github.com/DataDog/datadog-ci-rb/issues/506
+[#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

@@ -17,6 +17,8 @@ require_relative "../remote/library_settings_client"
 require_relative "../test_management/component"
 require_relative "../test_management/null_component"
 require_relative "../test_management/tests_properties"
+require_relative "../test_optimization_cache/component"
+require_relative "../test_optimization_cache/null_component"
 require_relative "../test_impact_analysis/null_component"
 require_relative "../test_impact_analysis/component"
 require_relative "../test_impact_analysis/coverage/transport"
@@ -45,7 +47,8 @@ module Datadog
       # Adds CI behavior to Datadog trace components
       module Components
         attr_reader :test_tracing, :test_impact_analysis, :git_tree_upload_worker, :ci_remote, :test_retries,
-          :test_management, :agentless_logs_submission, :impacted_tests_detection, :test_discovery, :code_coverage
+          :test_management, :agentless_logs_submission, :impacted_tests_detection, :test_discovery, :code_coverage,
+          :test_optimization_cache
 
         def initialize(settings)
           @test_impact_analysis = TestImpactAnalysis::NullComponent.new
@@ -57,6 +60,7 @@ module Datadog
           @impacted_tests_detection = ImpactedTestsDetection::NullComponent.new
           @test_discovery = TestDiscovery::NullComponent.new
           @code_coverage = CodeCoverage::NullComponent.new
+          @test_optimization_cache = TestOptimizationCache::NullComponent.new
 
           # Activate CI mode if enabled
           if settings.ci.enabled
@@ -69,6 +73,7 @@ module Datadog
         def shutdown!(replacement = nil)
           super
 
+          @test_optimization_cache&.shutdown!
           @test_tracing&.shutdown!
           @test_impact_analysis&.shutdown!
           @agentless_logs_submission&.shutdown!
@@ -113,6 +118,13 @@ module Datadog
           )
           @test_discovery.disable_features_for_test_discovery!(settings)
 
+          @test_optimization_cache = TestOptimizationCache::Component.new(
+            manifest_file: settings.ci.test_optimization_cache_manifest_file,
+            runfiles_dir: settings.ci.test_optimization_cache_runfiles_dir,
+            runfiles_manifest_file: settings.ci.test_optimization_cache_runfiles_manifest_file,
+            test_srcdir: settings.ci.test_optimization_cache_test_srcdir
+          )
+
           # Configure Datadog::Tracing module
 
           # No need not use 128-bit trace ids for test visibility,
@@ -180,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/configuration/settings.rb

@@ -2,6 +2,7 @@
 
 require_relative "../contrib/instrumentation"
 require_relative "../ext/settings"
+require_relative "../ext/test_optimization_cache"
 require_relative "../utils/bundle"
 require_relative "../utils/parsing"
 
@@ -180,6 +181,26 @@ module Datadog
                 o.env CI::Ext::Settings::ENV_TEST_DISCOVERY_OUTPUT_PATH
               end
 
+              option :test_optimization_cache_manifest_file do |o|
+                o.type :string, nilable: true
+                o.env CI::Ext::TestOptimizationCache::ENV_MANIFEST_FILE
+              end
+
+              option :test_optimization_cache_runfiles_dir do |o|
+                o.type :string, nilable: true
+                o.env CI::Ext::TestOptimizationCache::ENV_RUNFILES_DIR
+              end
+
+              option :test_optimization_cache_runfiles_manifest_file do |o|
+                o.type :string, nilable: true
+                o.env CI::Ext::TestOptimizationCache::ENV_RUNFILES_MANIFEST_FILE
+              end
+
+              option :test_optimization_cache_test_srcdir do |o|
+                o.type :string, nilable: true
+                o.env CI::Ext::TestOptimizationCache::ENV_TEST_SRCDIR
+              end
+
               option :tia_static_dependencies_tracking_enabled do |o|
                 o.type :bool
                 o.env CI::Ext::Settings::ENV_TIA_STATIC_DEPENDENCIES_TRACKING_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/environment/providers/jenkins.rb

@@ -75,7 +75,8 @@ module Datadog
 
             def ci_env_vars
               {
-                "DD_CUSTOM_TRACE_ID" => env["DD_CUSTOM_TRACE_ID"]
+                "DD_CUSTOM_TRACE_ID" => env["DD_CUSTOM_TRACE_ID"],
+                "DD_CUSTOM_PARENT_ID" => env["DD_CUSTOM_PARENT_ID"]
               }.to_json
             end
           end

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

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "test_optimization_cache"
+
 module Datadog
   module CI
     module Ext
       # Defines constants for test discovery mode
       module TestDiscovery
         # Default output path for test discovery mode
-        DEFAULT_OUTPUT_PATH = "./#{DDTest::PLAN_FOLDER}/test_discovery/tests.json"
+        DEFAULT_OUTPUT_PATH = "./#{TestOptimizationCache::PLAN_FOLDER}/test_discovery/tests.json"
 
         # Maximum buffer size before writing to file
         MAX_BUFFER_SIZE = 10_000

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Datadog
+  module CI
+    module Ext
+      # Constants for Test Optimization cache generated by ddtest or Bazel.
+      module TestOptimizationCache
+        ENV_MANIFEST_FILE = "TEST_OPTIMIZATION_MANIFEST_FILE"
+        ENV_RUNFILES_DIR = "RUNFILES_DIR"
+        ENV_RUNFILES_MANIFEST_FILE = "RUNFILES_MANIFEST_FILE"
+        ENV_TEST_SRCDIR = "TEST_SRCDIR"
+
+        PLAN_FOLDER = ".testoptimization"
+        MANIFEST_FILE_NAME = "manifest.txt"
+        SUPPORTED_MANIFEST_VERSION = "1"
+
+        CACHE_FOLDER_NAME = "cache"
+        HTTP_CACHE_FOLDER_NAME = "http"
+
+        TESTOPTIMIZATION_CACHE_PATH = "#{PLAN_FOLDER}/#{CACHE_FOLDER_NAME}"
+        TESTOPTIMIZATION_HTTP_CACHE_PATH = "#{TESTOPTIMIZATION_CACHE_PATH}/#{HTTP_CACHE_FOLDER_NAME}"
+
+        SETTINGS_FILE_NAME = "settings.json"
+        KNOWN_TESTS_FILE_NAME = "known_tests.json"
+        TEST_MANAGEMENT_FILE_NAME = "test_management.json"
+        LEGACY_TEST_MANAGEMENT_TESTS_FILE_NAME = "test_management_tests.json"
+        SKIPPABLE_TESTS_FILE_NAME = "skippable_tests.json"
+      end
+    end
+  end
+end

data/lib/datadog/ci/git/tree_uploader.rb

@@ -10,7 +10,6 @@ require_relative "packfiles"
 
 require_relative "../ext/telemetry"
 require_relative "../utils/telemetry"
-require_relative "../utils/test_run"
 
 module Datadog
   module CI
@@ -34,8 +33,8 @@ module Datadog
             return
           end
 
-          if Utils::TestRun.test_optimization_data_cached?
-            Datadog.logger.debug("DDTest cache found, git upload already done by DDTest tool, skipping git upload")
+          if test_optimization_cache.cache_available?
+            Datadog.logger.debug("Test Optimization cache found, git upload already done, skipping git upload")
             return
           end
 
@@ -113,6 +112,10 @@ module Datadog
         def test_tracing_component
           Datadog.send(:components).test_tracing
         end
+
+        def test_optimization_cache
+          Datadog.send(:components).test_optimization_cache
+        end
       end
     end
   end

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

@@ -56,15 +56,15 @@ module Datadog
         end
 
         def restore_state_from_datadog_test_runner
-          Datadog.logger.debug { "Restoring library configuration from DDTest cache" }
+          Datadog.logger.debug { "Restoring library configuration from Test Optimization cache" }
 
-          settings = load_json(Ext::DDTest::SETTINGS_FILE_NAME)
+          settings = load_cached_settings
           if settings.nil?
             Datadog.logger.debug { "Restoring library configuration failed, will request again" }
             return false
           end
 
-          Datadog.logger.debug { "Restored library configuration from DDTest: #{settings}" }
+          Datadog.logger.debug { "Restored library configuration from Test Optimization: #{settings}" }
           @library_configuration = LibrarySettings.from_json(settings)
           true
         end
@@ -75,7 +75,7 @@ module Datadog
           # In test discovery mode, skip backend fetching and use default settings (everything is disabled)
           return @library_configuration = LibrarySettings.from_http_response(nil) if @test_discovery_enabled
 
-          # skip backend request if library configuration was loaded by a different process and stored on disk
+          # skip backend request if library configuration was loaded from external cache or stored on disk
           library_configuration_loaded = load_component_state
           return @library_configuration if library_configuration_loaded
 

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

@@ -19,7 +19,13 @@ module Datadog
         end
 
         def self.from_json(json)
-          new(nil, json)
+          new(nil, normalize_json(json))
+        end
+
+        def self.normalize_json(json)
+          return nil if json.nil?
+
+          json.dig(*Ext::Transport::DD_API_SETTINGS_RESPONSE_DIG_KEYS) || json
         end
 
         def ok?

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

@@ -6,7 +6,6 @@ require "datadog/core/telemetry/logging"
 
 require_relative "../ext/test"
 require_relative "../ext/telemetry"
-require_relative "../ext/dd_test"
 
 require_relative "../git/local_repository"
 
@@ -102,11 +101,9 @@ module Datadog
             populate_static_dependencies_map!
           end
 
-          # Load component state first, and if successful, skip fetching skippable tests
-          # Also try to restore from DDTest cache if available
+          # Load external cache or component state first, and if successful, skip fetching skippable tests
           if skipping_tests?
             return if load_component_state
-            return if restore_state_from_datadog_test_runner
 
             fetch_skippable_tests(test_session)
             store_component_state if test_session.distributed
@@ -333,22 +330,17 @@ module Datadog
         end
 
         def restore_state_from_datadog_test_runner
-          Datadog.logger.debug { "Restoring skippable tests from DDTest cache" }
+          Datadog.logger.debug { "Restoring skippable tests from Test Optimization cache" }
 
-          skippable_tests_data = load_json(Ext::DDTest::SKIPPABLE_TESTS_FILE_NAME)
+          skippable_tests_data = load_cached_skippable_tests
           if skippable_tests_data.nil?
             Datadog.logger.debug { "Restoring skippable tests failed, will request again" }
             return false
           end
 
-          Datadog.logger.debug { "Restored skippable tests from DDTest: #{skippable_tests_data}" }
+          Datadog.logger.debug { "Restored skippable tests from Test Optimization: #{skippable_tests_data}" }
 
-          transformed_data = transform_test_runner_data(skippable_tests_data)
-
-          Datadog.logger.debug { "Skippable tests after transformation: #{transformed_data}" }
-
-          # Use the Skippable::Response class to parse the transformed data
-          skippable_response = Skippable::Response.from_json(transformed_data)
+          skippable_response = Skippable::Response.from_json(skippable_tests_data)
 
           @mutex.synchronize do
             @correlation_id = skippable_response.correlation_id
@@ -363,58 +355,6 @@ module Datadog
 
         private
 
-        # Transforms Test Runner skippable tests data format to the format expected by Skippable::Response
-        #
-        # Test Runner format:
-        # {
-        #   "correlationId": "abc123",
-        #   "skippableTests": {
-        #     "suite_name": {
-        #       "test_name": [{"suite": "suite_name", "name": "test_name", "parameters": "{...}", "configurations": {}}]
-        #     }
-        #   }
-        # }
-        #
-        # Expected format:
-        # {
-        #   "meta": {"correlation_id": "abc123"},
-        #   "data": [{"type": "test", "attributes": {"suite": "suite_name", "name": "test_name", "parameters": "{...}"}}]
-        # }
-        def transform_test_runner_data(skippable_tests_data)
-          skippable_tests = skippable_tests_data.fetch("skippableTests", {}) || {}
-
-          # Pre-calculate array size for better memory allocation
-          total_test_configs = skippable_tests.sum do |_, tests_hash|
-            tests_hash.sum { |_, test_configs| test_configs.size }
-          end
-
-          data_array = Array.new(total_test_configs)
-          index = 0
-
-          skippable_tests.each_value do |tests_hash|
-            tests_hash.each_value do |test_configs|
-              test_configs.each do |test_config|
-                data_array[index] = {
-                  "type" => Ext::Test::ITR_TEST_SKIPPING_MODE,
-                  "attributes" => {
-                    "suite" => test_config["suite"],
-                    "name" => test_config["name"],
-                    "parameters" => test_config["parameters"]
-                  }
-                }
-                index += 1
-              end
-            end
-          end
-
-          {
-            "meta" => {
-              "correlation_id" => skippable_tests_data["correlationId"]
-            },
-            "data" => data_array
-          }
-        end
-
         def write(event)
           # skip sending events if writer is not configured
           @coverage_writer&.write(event)

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

@@ -2,7 +2,6 @@
 
 require_relative "../ext/telemetry"
 require_relative "../ext/test"
-require_relative "../ext/dd_test"
 require_relative "../utils/stateful"
 require_relative "../utils/telemetry"
 require_relative "../utils/test_run"
@@ -36,7 +35,6 @@ module Datadog
 
           test_session.set_tag(Ext::Test::TAG_TEST_MANAGEMENT_ENABLED, "true")
 
-          return if restore_state_from_datadog_test_runner
           return if load_component_state
 
           @tests_properties = @tests_properties_client.fetch(test_session)
@@ -85,25 +83,17 @@ module Datadog
         end
 
         def restore_state_from_datadog_test_runner
-          Datadog.logger.debug { "Restoring test management tests from DDTest cache" }
+          Datadog.logger.debug { "Restoring test management tests from Test Optimization cache" }
 
-          test_management_data = load_json(Ext::DDTest::TEST_MANAGEMENT_TESTS_FILE_NAME)
+          test_management_data = load_cached_test_management
           if test_management_data.nil?
             Datadog.logger.debug { "Restoring test management tests failed, will request again" }
             return false
           end
 
-          Datadog.logger.debug { "Restored test management tests from DDTest: #{test_management_data}" }
+          Datadog.logger.debug { "Restored test management tests from Test Optimization: #{test_management_data}" }
 
-          # Use the TestsProperties::Response class method to parse the JSON data
-          # Wrap the data in the expected backend API format
-          wrapped_data = {
-            "data" => {
-              "attributes" => test_management_data
-            }
-          }
-
-          tests_properties_response = TestsProperties::Response.from_json(wrapped_data)
+          tests_properties_response = TestsProperties::Response.from_json(test_management_data)
           @tests_properties = tests_properties_response.tests
 
           Datadog.logger.debug { "Found [#{@tests_properties.size}] test management tests from context" }