datadog-ci 1.0.1 → 1.2.0

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

@@ -2,12 +2,12 @@
 
 require_relative "../ext/settings"
 require_relative "../git/tree_uploader"
-require_relative "../itr/runner"
-require_relative "../itr/coverage/transport"
-require_relative "../itr/coverage/writer"
+require_relative "../test_optimisation/component"
+require_relative "../test_optimisation/coverage/transport"
+require_relative "../test_optimisation/coverage/writer"
+require_relative "../test_visibility/component"
 require_relative "../test_visibility/flush"
-require_relative "../test_visibility/recorder"
-require_relative "../test_visibility/null_recorder"
+require_relative "../test_visibility/null_component"
 require_relative "../test_visibility/serializers/factories/test_level"
 require_relative "../test_visibility/serializers/factories/test_suite_level"
 require_relative "../test_visibility/transport"
@@ -21,15 +21,15 @@ module Datadog
     module Configuration
       # Adds CI behavior to Datadog trace components
       module Components
-        attr_reader :ci_recorder, :itr
+        attr_reader :test_visibility, :test_optimisation
 
         def initialize(settings)
+          @test_optimisation = nil
+          @test_visibility = TestVisibility::NullComponent.new
+
           # Activate CI mode if enabled
           if settings.ci.enabled
             activate_ci!(settings)
-          else
-            @itr = nil
-            @ci_recorder = TestVisibility::NullRecorder.new
           end
 
           super
@@ -38,8 +38,8 @@ module Datadog
         def shutdown!(replacement = nil)
           super
 
-          @ci_recorder&.shutdown!
-          @itr&.shutdown!
+          @test_visibility&.shutdown!
+          @test_optimisation&.shutdown!
         end
 
         def activate_ci!(settings)
@@ -53,22 +53,21 @@ module Datadog
             return
           end
 
-          # Configure ddtrace library for CI visibility mode
+          # Builds test visibility API layer in agentless or EvP proxy mode
+          test_visibility_api = build_test_visibility_api(settings)
+          # bail out early if api is misconfigured
+          return unless settings.ci.enabled
+
+          # Configure datadog gem for test visibility mode
+
           # Deactivate telemetry
           settings.telemetry.enabled = false
 
-          # Deactivate remote configuration
+          # Test visibility uses its own remote settings
           settings.remote.enabled = false
 
-          # do not use 128-bit trace ids for CI visibility
-          # they are used for OTEL compatibility in Datadog tracer
-          settings.tracing.trace_id_128_bit_generation_enabled = false
-
-          # Activate underlying tracing test mode
-          settings.tracing.test_mode.enabled = true
-
-          # Choose user defined TraceFlush or default to CI TraceFlush
-          settings.tracing.test_mode.trace_flush = settings.ci.trace_flush || CI::TestVisibility::Flush::Partial.new
+          # startup logs are useless for test visibility and create noise
+          settings.diagnostics.startup_logs.enabled = false
 
           # When timecop is present, Time.now is mocked and .now_without_mock_time is added on Time to
           # get the current time without the mock.
@@ -81,76 +80,70 @@ module Datadog
             end
           end
 
-          # startup logs are useless for CI visibility and create noise
-          settings.diagnostics.startup_logs.enabled = false
+          # Configure Datadog::Tracing module
 
-          # transport creation
-          writer_options = settings.ci.writer_options
-          coverage_writer = nil
-          test_visibility_api = build_test_visibility_api(settings)
+          # No need not use 128-bit trace ids for test visibility,
+          # they are used for OTEL compatibility in Datadog tracer
+          settings.tracing.trace_id_128_bit_generation_enabled = false
 
-          if test_visibility_api
-            # setup writer for code coverage payloads
-            coverage_writer = ITR::Coverage::Writer.new(
-              transport: ITR::Coverage::Transport.new(api: test_visibility_api)
-            )
+          # Activate underlying tracing test mode with async worker
+          settings.tracing.test_mode.enabled = true
+          settings.tracing.test_mode.async = true
+          settings.tracing.test_mode.trace_flush = settings.ci.trace_flush || CI::TestVisibility::Flush::Partial.new
 
-            # configure tracing writer to send traces to CI visibility backend
-            writer_options[:transport] = TestVisibility::Transport.new(
-              api: test_visibility_api,
-              serializers_factory: serializers_factory(settings),
-              dd_env: settings.env
-            )
-            writer_options[:shutdown_timeout] = 60
-            writer_options[:buffer_size] = 10_000
+          trace_writer_options = settings.ci.writer_options
+          trace_writer_options[:shutdown_timeout] = 60
+          trace_writer_options[:buffer_size] = 10_000
+          tracing_transport = build_tracing_transport(settings, test_visibility_api)
+          trace_writer_options[:transport] = tracing_transport if tracing_transport
 
-            settings.tracing.test_mode.async = true
-          else
-            # only legacy APM protocol is supported, so no test suite level visibility
-            settings.ci.force_test_level_visibility = true
+          settings.tracing.test_mode.writer_options = trace_writer_options
 
-            # ITR is not supported with APM protocol
-            settings.ci.itr_enabled = false
-          end
+          # @type ivar @test_optimisation: Datadog::CI::TestOptimisation::Component
+          @test_optimisation = build_test_optimisation(settings, test_visibility_api)
 
-          settings.tracing.test_mode.writer_options = writer_options
+          @test_visibility = TestVisibility::Component.new(
+            test_optimisation: @test_optimisation,
+            test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility,
+            remote_settings_api: build_remote_settings_client(settings, test_visibility_api),
+            git_tree_upload_worker: build_git_upload_worker(settings, test_visibility_api)
+          )
+        end
 
-          custom_configuration_tags = Utils::TestRun.custom_configuration(settings.tags)
+        def build_test_optimisation(settings, test_visibility_api)
+          if settings.ci.itr_code_coverage_use_single_threaded_mode &&
+              settings.ci.itr_test_impact_analysis_use_allocation_tracing
+            Datadog.logger.warn(
+              "Intelligent test runner: Single threaded coverage mode is incompatible with allocation tracing. " \
+              "Allocation tracing will be disabled. It means that test impact analysis will not be able to detect " \
+              "instantiations of objects in your code, which is important for ActiveRecord models. " \
+              "Please add your app/model folder to the list of tracked files or disable single threaded coverage mode."
+            )
 
-          remote_settings_api = Transport::RemoteSettingsApi.new(
-            api: test_visibility_api,
-            dd_env: settings.env,
-            config_tags: custom_configuration_tags
-          )
+            settings.ci.itr_test_impact_analysis_use_allocation_tracing = false
+          end
 
-          itr = ITR::Runner.new(
+          if RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3" &&
+              settings.ci.itr_test_impact_analysis_use_allocation_tracing
+            Datadog.logger.warn(
+              "Intelligent test runner: Allocation tracing is not supported in Ruby versions 3.2.0, 3.2.1 and 3.2.2 and will be forcibly " \
+              "disabled. This is due to a VM bug that can lead to crashes (https://bugs.ruby-lang.org/issues/19482). " \
+              "Please update your Ruby version or add your app/model folder to the list of tracked files." \
+              "Set env variable DD_CIVISIBILITY_ITR_TEST_IMPACT_ANALYSIS_USE_ALLOCATION_TRACING to 0 to disable this warning."
+            )
+            settings.ci.itr_test_impact_analysis_use_allocation_tracing = false
+          end
+
+          TestOptimisation::Component.new(
             api: test_visibility_api,
             dd_env: settings.env,
-            config_tags: custom_configuration_tags,
-            coverage_writer: coverage_writer,
+            config_tags: custom_configuration(settings),
+            coverage_writer: build_coverage_writer(settings, test_visibility_api),
             enabled: settings.ci.enabled && settings.ci.itr_enabled,
             bundle_location: settings.ci.itr_code_coverage_excluded_bundle_path,
-            use_single_threaded_coverage: settings.ci.itr_code_coverage_use_single_threaded_mode
-          )
-
-          git_tree_uploader = Git::TreeUploader.new(api: test_visibility_api)
-          git_tree_upload_worker = if settings.ci.git_metadata_upload_enabled
-            Worker.new do |repository_url|
-              git_tree_uploader.call(repository_url)
-            end
-          else
-            DummyWorker.new
-          end
-
-          # CI visibility recorder global instance
-          @ci_recorder = TestVisibility::Recorder.new(
-            test_suite_level_visibility_enabled: !settings.ci.force_test_level_visibility,
-            itr: itr,
-            remote_settings_api: remote_settings_api,
-            git_tree_upload_worker: git_tree_upload_worker
+            use_single_threaded_coverage: settings.ci.itr_code_coverage_use_single_threaded_mode,
+            use_allocation_tracing: settings.ci.itr_test_impact_analysis_use_allocation_tracing
           )
-
-          @itr = itr
         end
 
         def build_test_visibility_api(settings)
@@ -179,12 +172,61 @@ module Datadog
               Datadog.logger.debug(
                 "Old agent version detected, no evp_proxy support. Forcing test level visibility mode"
               )
+
+              # only legacy APM protocol is supported, so no test suite level visibility
+              settings.ci.force_test_level_visibility = true
+
+              # ITR is not supported with APM protocol
+              settings.ci.itr_enabled = false
             end
           end
 
           api
         end
 
+        def build_tracing_transport(settings, api)
+          return nil if api.nil?
+
+          TestVisibility::Transport.new(
+            api: api,
+            serializers_factory: serializers_factory(settings),
+            dd_env: settings.env
+          )
+        end
+
+        def build_coverage_writer(settings, api)
+          return nil if api.nil?
+
+          TestOptimisation::Coverage::Writer.new(
+            transport: TestOptimisation::Coverage::Transport.new(api: api)
+          )
+        end
+
+        def build_git_upload_worker(settings, api)
+          if settings.ci.git_metadata_upload_enabled
+            git_tree_uploader = Git::TreeUploader.new(api: api)
+            Worker.new do |repository_url|
+              git_tree_uploader.call(repository_url)
+            end
+          else
+            DummyWorker.new
+          end
+        end
+
+        def build_remote_settings_client(settings, api)
+          Transport::RemoteSettingsApi.new(
+            api: api,
+            dd_env: settings.env,
+            config_tags: custom_configuration(settings)
+          )
+        end
+
+        # fetch custom tags provided by the user in DD_TAGS env var
+        # with prefix test.configuration.
+        def custom_configuration(settings)
+          @custom_configuration ||= Utils::TestRun.custom_configuration(settings.tags)
+        end
+
         def serializers_factory(settings)
           if settings.ci.force_test_level_visibility
             TestVisibility::Serializers::Factories::TestLevel
@@ -205,7 +247,7 @@ module Datadog
         end
 
         def timecop?
-          Gem.loaded_specs.key?("timecop") || defined?(Timecop)
+          Gem.loaded_specs.key?("timecop") || !!defined?(Timecop)
         end
       end
     end

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

@@ -82,6 +82,12 @@ module Datadog
                 o.default false
               end
 
+              option :itr_test_impact_analysis_use_allocation_tracing do |o|
+                o.type :bool
+                o.env CI::Ext::Settings::ENV_ITR_TEST_IMPACT_ANALYSIS_USE_ALLOCATION_TRACING
+                o.default true
+              end
+
               define_method(:instrument) do |integration_name, options = {}, &block|
                 return unless enabled
 

data/lib/datadog/ci/contrib/rspec/example.rb

@@ -100,7 +100,7 @@ module Datadog
             end
 
             def ci_queue?
-              defined?(::RSpec::Queue::ExampleExtension) &&
+              !!defined?(::RSpec::Queue::ExampleExtension) &&
                 self.class.ancestors.include?(::RSpec::Queue::ExampleExtension)
             end
           end

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

@@ -42,15 +42,15 @@ module Datadog
           end
 
           def ci_queue?
-            defined?(::RSpec::Queue::Runner)
+            !!defined?(::RSpec::Queue::Runner)
           end
 
           def knapsack_pro?
             knapsack_version = Gem.loaded_specs["knapsack_pro"]&.version
 
             # additional instrumentation is needed for KnapsackPro version 7 and later
-            defined?(::KnapsackPro) &&
-              knapsack_version && knapsack_version >= Gem::Version.new("7")
+            !!defined?(::KnapsackPro) &&
+              !knapsack_version.nil? && knapsack_version >= Gem::Version.new("7")
           end
         end
       end

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

@@ -14,6 +14,7 @@ module Datadog
         ENV_GIT_METADATA_UPLOAD_ENABLED = "DD_CIVISIBILITY_GIT_METADATA_UPLOAD_ENABLED"
         ENV_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_EXCLUDED_BUNDLE_PATH"
         ENV_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE = "DD_CIVISIBILITY_ITR_CODE_COVERAGE_USE_SINGLE_THREADED_MODE"
+        ENV_ITR_TEST_IMPACT_ANALYSIS_USE_ALLOCATION_TRACING = "DD_CIVISIBILITY_ITR_TEST_IMPACT_ANALYSIS_USE_ALLOCATION_TRACING"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = %w[

data/lib/datadog/ci/span.rb

@@ -202,9 +202,9 @@ module Datadog
 
       private
 
-      # provides access to global CI recorder for CI models to deactivate themselves
-      def recorder
-        Datadog.send(:components).ci_recorder
+      # provides access to the test visibility component for CI models to deactivate themselves
+      def test_visibility
+        Datadog.send(:components).test_visibility
       end
     end
   end

data/lib/datadog/ci/test.rb

@@ -19,7 +19,7 @@ module Datadog
       # Finishes the current test.
       # @return [void]
       def finish
-        recorder.deactivate_test
+        test_visibility.deactivate_test
 
         super
       end

data/lib/datadog/ci/test_module.rb

@@ -14,7 +14,7 @@ module Datadog
       # Finishes this test module.
       # @return [void]
       def finish
-        recorder.deactivate_test_module
+        test_visibility.deactivate_test_module
 
         super
       end

data/lib/datadog/ci/{itr/runner.rb → test_optimisation/component.rb}

@@ -16,11 +16,11 @@ require_relative "skippable"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       # Intelligent test runner implementation
       # Integrates with backend to provide test impact analysis data and
       # skip tests that are not impacted by the changes
-      class Runner
+      class Component
         include Core::Utils::Forking
 
         attr_reader :correlation_id, :skippable_tests, :skipped_tests_count
@@ -32,7 +32,8 @@ module Datadog
           coverage_writer: nil,
           enabled: false,
           bundle_location: nil,
-          use_single_threaded_coverage: false
+          use_single_threaded_coverage: false,
+          use_allocation_tracing: true
         )
           @enabled = enabled
           @api = api
@@ -45,6 +46,7 @@ module Datadog
             bundle_location
           end
           @use_single_threaded_coverage = use_single_threaded_coverage
+          @use_allocation_tracing = use_allocation_tracing
 
           @test_skipping_enabled = false
           @code_coverage_enabled = false
@@ -57,11 +59,11 @@ module Datadog
           @skipped_tests_count = 0
           @mutex = Mutex.new
 
-          Datadog.logger.debug("ITR Runner initialized with enabled: #{@enabled}")
+          Datadog.logger.debug("TestOptimisation initialized with enabled: #{@enabled}")
         end
 
         def configure(remote_configuration, test_session:, git_tree_upload_worker:)
-          Datadog.logger.debug("Configuring ITR Runner with remote configuration: #{remote_configuration}")
+          Datadog.logger.debug("Configuring TestOptimisation with remote configuration: #{remote_configuration}")
 
           @enabled = Utils::Parsing.convert_to_bool(
             remote_configuration.fetch(Ext::Transport::DD_API_SETTINGS_RESPONSE_ITR_ENABLED_KEY, false)
@@ -83,7 +85,7 @@ module Datadog
 
           load_datadog_cov! if @code_coverage_enabled
 
-          Datadog.logger.debug("Configured ITR Runner with enabled: #{@enabled}, skipping_tests: #{@test_skipping_enabled}, code_coverage: #{@code_coverage_enabled}")
+          Datadog.logger.debug("Configured TestOptimisation with enabled: #{@enabled}, skipping_tests: #{@test_skipping_enabled}, code_coverage: #{@code_coverage_enabled}")
 
           fetch_skippable_tests(test_session: test_session, git_tree_upload_worker: git_tree_upload_worker)
         end
@@ -139,7 +141,7 @@ module Datadog
           skippable_test_id = Utils::TestRun.skippable_test_id(test.name, test.test_suite_name, test.parameters)
           if @skippable_tests.include?(skippable_test_id)
             if forked?
-              Datadog.logger.warn { "ITR is not supported for forking test runners yet" }
+              Datadog.logger.warn { "Intelligent test runner is not supported for forking test runners yet" }
               return
             end
 
@@ -155,7 +157,7 @@ module Datadog
           return if !test.skipped? || !test.skipped_by_itr?
 
           if forked?
-            Datadog.logger.warn { "ITR is not supported for forking test runners yet" }
+            Datadog.logger.warn { "Intelligent test runner is not supported for forking test runners yet" }
             return
           end
 
@@ -167,7 +169,7 @@ module Datadog
         def write_test_session_tags(test_session)
           return if !enabled?
 
-          Datadog.logger.debug { "Finished ITR session with test skipping enabled: #{@test_skipping_enabled}" }
+          Datadog.logger.debug { "Finished optimised session with test skipping enabled: #{@test_skipping_enabled}" }
           Datadog.logger.debug { "#{@skipped_tests_count} tests were skipped" }
 
           test_session.set_tag(Ext::Test::TAG_ITR_TESTS_SKIPPED, @skipped_tests_count.positive?.to_s)
@@ -189,7 +191,8 @@ module Datadog
           Thread.current[:dd_coverage_collector] ||= Coverage::DDCov.new(
             root: Git::LocalRepository.root,
             ignored_path: @bundle_location,
-            threading_mode: code_coverage_mode
+            threading_mode: code_coverage_mode,
+            use_allocation_tracing: @use_allocation_tracing
           )
         end
 

data/lib/datadog/ci/{itr → test_optimisation}/coverage/ddcov.rb

@@ -2,7 +2,7 @@
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       module Coverage
         # Placeholder for code coverage collection
         # Implementation in ext/datadog_cov

data/lib/datadog/ci/{itr → test_optimisation}/coverage/event.rb

@@ -6,7 +6,7 @@ require_relative "../../git/local_repository"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       module Coverage
         class Event
           attr_reader :test_id, :test_suite_id, :test_session_id, :coverage

data/lib/datadog/ci/{itr → test_optimisation}/coverage/transport.rb

@@ -5,7 +5,7 @@ require_relative "../../transport/event_platform_transport"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       module Coverage
         class Transport < Datadog::CI::Transport::EventPlatformTransport
           private

data/lib/datadog/ci/{itr → test_optimisation}/coverage/writer.rb

@@ -11,7 +11,7 @@ require "datadog/core/environment/ext"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       module Coverage
         class Writer
           include Core::Workers::Queue

data/lib/datadog/ci/{itr → test_optimisation}/skippable.rb

@@ -8,7 +8,7 @@ require_relative "../utils/test_run"
 
 module Datadog
   module CI
-    module ITR
+    module TestOptimisation
       class Skippable
         class Response
           def initialize(http_response)

data/lib/datadog/ci/test_session.rb

@@ -15,7 +15,7 @@ module Datadog
       # Finishes the current test session.
       # @return [void]
       def finish
-        recorder.deactivate_test_session
+        test_visibility.deactivate_test_session
 
         super
       end

data/lib/datadog/ci/test_suite.rb

@@ -26,7 +26,7 @@ module Datadog
           # we try to derive test suite status from execution stats if no status was set explicitly
           set_status_from_stats! if undefined?
 
-          recorder.deactivate_test_suite(name)
+          test_visibility.deactivate_test_suite(name)
 
           super
         end

data/lib/datadog/ci/test_visibility/{recorder.rb → component.rb}

@@ -28,11 +28,11 @@ module Datadog
     module TestVisibility
       # Common behavior for CI tests
       # Note: this class has too many responsibilities and should be split into multiple classes
-      class Recorder
+      class Component
         attr_reader :environment_tags, :test_suite_level_visibility_enabled
 
         def initialize(
-          itr:,
+          test_optimisation:,
           remote_settings_api:,
           git_tree_upload_worker: DummyWorker.new,
           test_suite_level_visibility_enabled: false,
@@ -46,7 +46,7 @@ module Datadog
 
           @codeowners = codeowners
 
-          @itr = itr
+          @test_optimisation = test_optimisation
           @remote_settings_api = remote_settings_api
           @git_tree_upload_worker = git_tree_upload_worker
         end
@@ -210,7 +210,7 @@ module Datadog
         end
 
         def itr_enabled?
-          @itr.enabled?
+          @test_optimisation.enabled?
         end
 
         private
@@ -234,7 +234,7 @@ module Datadog
             end
           end
 
-          @itr.configure(
+          @test_optimisation.configure(
             remote_configuration.payload,
             test_session: test_session,
             git_tree_upload_worker: @git_tree_upload_worker
@@ -404,17 +404,17 @@ module Datadog
 
         # TODO: use kind of event system to notify about test finished?
         def on_test_finished(test)
-          @itr.stop_coverage(test)
-          @itr.count_skipped_test(test)
+          @test_optimisation.stop_coverage(test)
+          @test_optimisation.count_skipped_test(test)
         end
 
         def on_test_started(test)
-          @itr.mark_if_skippable(test)
-          @itr.start_coverage(test)
+          @test_optimisation.mark_if_skippable(test)
+          @test_optimisation.start_coverage(test)
         end
 
         def on_test_session_finished(test_session)
-          @itr.write_test_session_tags(test_session)
+          @test_optimisation.write_test_session_tags(test_session)
         end
       end
     end

data/lib/datadog/ci/test_visibility/{null_recorder.rb → null_component.rb}

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require_relative "recorder"
-
 module Datadog
   module CI
     module TestVisibility
-      # Special recorder that does not record anything
-      class NullRecorder
+      # Special test visibility component that does not record anything
+      class NullComponent
         def start_test_session(service: nil, tags: {})
           skip_tracing
         end
@@ -45,6 +43,10 @@ module Datadog
         def shutdown!
         end
 
+        def itr_enabled?
+          false
+        end
+
         private
 
         def skip_tracing(block = nil)

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

@@ -100,7 +100,7 @@ module Datadog
         end
 
         def itr
-          @itr ||= Datadog::CI.send(:itr_runner)
+          @test_optimisation ||= Datadog::CI.send(:test_optimisation)
         end
       end
     end