datadog-ci 1.13.0 → 1.15.0

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../worker"
+require_relative "../utils/stateful"
 
 module Datadog
   module CI
@@ -8,33 +9,44 @@ module Datadog
       # Remote configuration component.
       # Responsible for fetching library settings and configuring the library accordingly.
       class Component
+        include Datadog::CI::Utils::Stateful
+
+        FILE_STORAGE_KEY = "remote_component_state"
+
         def initialize(library_settings_client:)
           @library_settings_client = library_settings_client
+          @library_configuration = nil
         end
 
         # called on test session start, uses test session info to send configuration request to the backend
         def configure(test_session)
-          library_configuration = @library_settings_client.fetch(test_session)
-          # sometimes we can skip code coverage for default branch if there are no changes in the repository
-          # backend needs git metadata uploaded for this test session to check if we can skip code coverage
-          if library_configuration.require_git?
-            Datadog.logger.debug { "Library configuration endpoint requires git upload to be finished, waiting..." }
-            git_tree_upload_worker.wait_until_done
-
-            Datadog.logger.debug { "Requesting library configuration again..." }
-            library_configuration = @library_settings_client.fetch(test_session)
-
-            if library_configuration.require_git?
-              Datadog.logger.debug { "git metadata upload did not complete in time when configuring library" }
+          # If component state is loaded successfully, skip fetching library configuration
+          unless load_component_state
+            @library_configuration = @library_settings_client.fetch(test_session)
+            # sometimes we can skip code coverage for default branch if there are no changes in the repository
+            # backend needs git metadata uploaded for this test session to check if we can skip code coverage
+            if @library_configuration.require_git?
+              Datadog.logger.debug { "Library configuration endpoint requires git upload to be finished, waiting..." }
+              git_tree_upload_worker.wait_until_done
+
+              Datadog.logger.debug { "Requesting library configuration again..." }
+              @library_configuration = @library_settings_client.fetch(test_session)
+
+              if @library_configuration.require_git?
+                Datadog.logger.debug { "git metadata upload did not complete in time when configuring library" }
+              end
             end
+
+            # Store component state for distributed test runs
+            store_component_state if test_session.distributed
           end
 
           # configure different components in parallel because they might block on HTTP requests
           configuration_workers = [
-            Worker.new { test_optimisation.configure(library_configuration, test_session) },
-            Worker.new { test_retries.configure(library_configuration, test_session) },
-            Worker.new { test_visibility.configure(library_configuration, test_session) },
-            Worker.new { test_management.configure(library_configuration, test_session) }
+            Worker.new { test_optimisation.configure(@library_configuration, test_session) },
+            Worker.new { test_retries.configure(@library_configuration, test_session) },
+            Worker.new { test_visibility.configure(@library_configuration, test_session) },
+            Worker.new { test_management.configure(@library_configuration, test_session) }
           ]
 
           # launch configuration workers
@@ -44,6 +56,21 @@ module Datadog
           configuration_workers.each(&:wait_until_done)
         end
 
+        # Implementation of Stateful interface
+        def serialize_state
+          {
+            library_configuration: @library_configuration
+          }
+        end
+
+        def restore_state(state)
+          @library_configuration = state[:library_configuration]
+        end
+
+        def storage_key
+          FILE_STORAGE_KEY
+        end
+
         private
 
         def test_management

data/lib/datadog/ci/span.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "drb"
+
 require "datadog/core/environment/platform"
 
 require_relative "ext/test"
@@ -12,6 +14,8 @@ module Datadog
     #
     # @public_api
     class Span
+      include DRb::DRbUndumped
+
       attr_reader :tracer_span
 
       def initialize(tracer_span)

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

@@ -2,6 +2,7 @@
 
 require_relative "../ext/telemetry"
 require_relative "../ext/test"
+require_relative "../utils/stateful"
 require_relative "../utils/telemetry"
 require_relative "../utils/test_run"
 
@@ -14,6 +15,10 @@ module Datadog
       # - marking test as disabled causes test to be skipped
       # - marking test as "attempted to fix" causes test to be retried many times to confirm that fix worked
       class Component
+        include Datadog::CI::Utils::Stateful
+
+        FILE_STORAGE_KEY = "test_management_component_state"
+
         attr_reader :enabled, :tests_properties
 
         def initialize(enabled:, tests_properties_client:)
@@ -30,7 +35,11 @@ module Datadog
 
           test_session.set_tag(Ext::Test::TAG_TEST_MANAGEMENT_ENABLED, "true")
 
-          @tests_properties = @tests_properties_client.fetch(test_session)
+          # Load component state first, and if successful, skip fetching tests properties
+          if !load_component_state
+            @tests_properties = @tests_properties_client.fetch(test_session)
+            store_component_state if test_session.distributed
+          end
 
           Utils::Telemetry.distribution(
             Ext::Telemetry::METRIC_TEST_MANAGEMENT_TESTS_RESPONSE_TESTS,
@@ -55,6 +64,30 @@ module Datadog
           test_span.set_tag(Ext::Test::TAG_IS_TEST_DISABLED, "true") if test_properties["disabled"]
           test_span.set_tag(Ext::Test::TAG_IS_ATTEMPT_TO_FIX, "true") if test_properties["attempt_to_fix"]
         end
+
+        def attempt_to_fix?(datadog_fqn_test_id)
+          return false unless @enabled
+
+          test_properties = @tests_properties[datadog_fqn_test_id]
+          return false if test_properties.nil?
+
+          test_properties.fetch("attempt_to_fix", false)
+        end
+
+        # Implementation of Stateful interface
+        def serialize_state
+          {
+            tests_properties: @tests_properties
+          }
+        end
+
+        def restore_state(state)
+          @tests_properties = state[:tests_properties]
+        end
+
+        def storage_key
+          FILE_STORAGE_KEY
+        end
       end
     end
   end

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

@@ -117,7 +117,8 @@ module Datadog
               "id" => Datadog::Core::Environment::Identity.id,
               "type" => Ext::Transport::DD_API_TEST_MANAGEMENT_TESTS_TYPE,
               "attributes" => {
-                "repository_url" => test_session.git_repository_url
+                "repository_url" => test_session.git_repository_url,
+                "commit_message" => test_session.git_commit_message
               }
             }
           }.to_json

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

@@ -3,7 +3,6 @@
 require "pp"
 
 require "datadog/core/telemetry/logging"
-require "datadog/core/utils/forking"
 
 require_relative "../ext/test"
 require_relative "../ext/telemetry"
@@ -11,6 +10,7 @@ require_relative "../ext/telemetry"
 require_relative "../git/local_repository"
 
 require_relative "../utils/parsing"
+require_relative "../utils/stateful"
 require_relative "../utils/telemetry"
 
 require_relative "coverage/event"
@@ -24,10 +24,11 @@ module Datadog
       # Integrates with backend to provide test impact analysis data and
       # skip tests that are not impacted by the changes
       class Component
-        include Core::Utils::Forking
+        include Datadog::CI::Utils::Stateful
+
+        FILE_STORAGE_KEY = "test_optimisation_component_state"
 
         attr_reader :correlation_id, :skippable_tests, :skippable_tests_fetch_error,
-          :skipped_tests_count, :total_tests_count,
           :enabled, :test_skipping_enabled, :code_coverage_enabled
 
         def initialize(
@@ -61,9 +62,6 @@ module Datadog
           @correlation_id = nil
           @skippable_tests = Set.new
 
-          @total_tests_count = 0
-          @skipped_tests_count = 0
-
           @mutex = Mutex.new
 
           Datadog.logger.debug("TestOptimisation initialized with enabled: #{@enabled}")
@@ -85,9 +83,13 @@ module Datadog
 
           load_datadog_cov! if @code_coverage_enabled
 
-          Datadog.logger.debug("Configured TestOptimisation with enabled: #{@enabled}, skipping_tests: #{@test_skipping_enabled}, code_coverage: #{@code_coverage_enabled}")
+          # Load component state first, and if successful, skip fetching skippable tests
+          if skipping_tests? && !load_component_state
+            fetch_skippable_tests(test_session)
+            store_component_state if test_session.distributed
+          end
 
-          fetch_skippable_tests(test_session)
+          Datadog.logger.debug("Configured TestOptimisation with enabled: #{@enabled}, skipping_tests: #{@test_skipping_enabled}, code_coverage: #{@code_coverage_enabled}")
         end
 
         def enabled?
@@ -145,21 +147,16 @@ module Datadog
           event
         end
 
-        def skippable?(test)
+        def skippable?(datadog_test_id)
           return false if !enabled? || !skipping_tests?
 
-          @skippable_tests.include?(test.datadog_test_id)
+          @skippable_tests.include?(datadog_test_id)
         end
 
         def mark_if_skippable(test)
           return if !enabled? || !skipping_tests?
 
-          if skippable?(test)
-            if forked?
-              Datadog.logger.warn { "Test Impact Analysis is not supported for forking test runners yet" }
-              return
-            end
-
+          if skippable?(test.datadog_test_id) && !test.attempt_to_fix?
             test.set_tag(Ext::Test::TAG_ITR_SKIPPED_BY_ITR, "true")
 
             Datadog.logger.debug { "Marked test as skippable: #{test.datadog_test_id}" }
@@ -168,31 +165,22 @@ module Datadog
           end
         end
 
-        def count_skipped_test(test)
-          @mutex.synchronize do
-            @total_tests_count += 1
-
-            return if !test.skipped? || !test.skipped_by_test_impact_analysis?
-
-            if forked?
-              Datadog.logger.warn { "ITR is not supported for forking test runners yet" }
-              return
-            end
+        def on_test_finished(test, context)
+          return if !test.skipped? || !test.skipped_by_test_impact_analysis?
 
-            Telemetry.itr_skipped
+          Telemetry.itr_skipped
 
-            @skipped_tests_count += 1
-          end
+          context.incr_tests_skipped_by_tia_count
         end
 
-        def write_test_session_tags(test_session)
+        def write_test_session_tags(test_session, skipped_tests_count)
           return if !enabled?
 
           Datadog.logger.debug { "Finished optimised session with test skipping enabled: #{@test_skipping_enabled}" }
-          Datadog.logger.debug { "#{@skipped_tests_count} tests were skipped" }
+          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)
-          test_session.set_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_COUNT, @skipped_tests_count)
+          test_session.set_tag(Ext::Test::TAG_ITR_TESTS_SKIPPED, skipped_tests_count.positive?.to_s)
+          test_session.set_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_COUNT, skipped_tests_count)
         end
 
         def skippable_tests_count
@@ -203,6 +191,23 @@ module Datadog
           @coverage_writer&.stop
         end
 
+        # Implementation of Stateful interface
+        def serialize_state
+          {
+            correlation_id: @correlation_id,
+            skippable_tests: @skippable_tests
+          }
+        end
+
+        def restore_state(state)
+          @correlation_id = state[:correlation_id]
+          @skippable_tests = state[:skippable_tests]
+        end
+
+        def storage_key
+          FILE_STORAGE_KEY
+        end
+
         private
 
         def write(event)

data/lib/datadog/ci/test_optimisation/skippable_percentage/base.rb

@@ -44,6 +44,10 @@ module Datadog
           def test_optimisation
             Datadog.send(:components).test_optimisation
           end
+
+          def test_visibility
+            Datadog.send(:components).test_visibility
+          end
         end
       end
     end

data/lib/datadog/ci/test_optimisation/skippable_percentage/calculator.rb

@@ -34,11 +34,11 @@ module Datadog
               return 0.0
             end
 
-            log("Total tests count: #{test_optimisation.total_tests_count}")
-            log("Skipped tests count: #{test_optimisation.skipped_tests_count}")
+            log("Total tests count: #{test_visibility.total_tests_count}")
+            log("Skipped tests count: #{test_visibility.tests_skipped_by_tia_count}")
             validate_test_optimisation_state!
 
-            (test_optimisation.skipped_tests_count.to_f / test_optimisation.total_tests_count.to_f).floor(2)
+            (test_visibility.tests_skipped_by_tia_count.to_f / test_visibility.total_tests_count.to_f).floor(2)
           end
 
           private

data/lib/datadog/ci/test_retries/strategy/retry_new.rb

@@ -70,7 +70,7 @@ module Datadog
 
           def calculate_total_retries_limit(library_settings, test_session)
             percentage_limit = library_settings.faulty_session_threshold
-            tests_count = test_session.total_tests_count.to_i
+            tests_count = test_session.estimated_total_tests_count.to_i
             if tests_count.zero?
               Datadog.logger.debug do
                 "Total tests count is zero, using default value for the total number of tests: [#{DEFAULT_TOTAL_TESTS_COUNT}]"

data/lib/datadog/ci/test_session.rb

@@ -12,7 +12,7 @@ module Datadog
     #
     # @public_api
     class TestSession < ConcurrentSpan
-      attr_accessor :total_tests_count
+      attr_accessor :estimated_total_tests_count, :distributed
 
       # Finishes the current test session.
       # @return [void]
@@ -46,6 +46,12 @@ module Datadog
         get_tag(Ext::Environment::TAG_JOB_NAME)
       end
 
+      # Returns the git commit message extracted from the environment.
+      # @return [String] the commit message.
+      def git_commit_message
+        get_tag(Ext::Git::TAG_COMMIT_MESSAGE)
+      end
+
       def skipping_tests?
         get_tag(Ext::Test::TAG_ITR_TEST_SKIPPING_ENABLED) == "true"
       end

data/lib/datadog/ci/test_suite.rb

@@ -84,6 +84,24 @@ module Datadog
         end
       end
 
+      # @internal
+      def set_expected_tests!(expected_tests)
+        synchronize do
+          return if @expected_tests_set
+
+          @expected_tests_set = Set.new(expected_tests)
+        end
+      end
+
+      # @internal
+      def expected_test_done!(test_name)
+        synchronize do
+          @expected_tests_set.delete(test_name)
+
+          finish if @expected_tests_set.empty?
+        end
+      end
+
       private
 
       def set_status_from_stats!