datadog-ci 1.26.0 → 1.27.0

data/lib/datadog/ci/ext/environment/providers/github_actions.rb

@@ -15,6 +15,13 @@ module Datadog
           # Github Actions: https://github.com/features/actions
           # Environment variables docs: https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
           class GithubActions < Base
+            # Paths to GitHub Actions runner diagnostics folder
+            # GitHub-hosted (SaaS) runners use the cached path, self-hosted runners use the non-cached path
+            GITHUB_RUNNER_DIAG_PATHS = [
+              "/home/runner/actions-runner/cached/_diag", # GitHub-hosted (SaaS) runners
+              "/home/runner/actions-runner/_diag"         # Self-hosted runners
+            ].freeze
+
             def self.handles?(env)
               env.key?("GITHUB_SHA")
             end
@@ -28,11 +35,16 @@ module Datadog
             end
 
             def job_url
-              "#{github_server_url}/#{env["GITHUB_REPOSITORY"]}/commit/#{env["GITHUB_SHA"]}/checks"
+              numeric_id = numeric_job_id
+              if numeric_id
+                "#{github_server_url}/#{env["GITHUB_REPOSITORY"]}/actions/runs/#{env["GITHUB_RUN_ID"]}/job/#{numeric_id}"
+              else
+                "#{github_server_url}/#{env["GITHUB_REPOSITORY"]}/commit/#{env["GITHUB_SHA"]}/checks"
+              end
             end
 
             def job_id
-              env["GITHUB_JOB"]
+              numeric_job_id || env["GITHUB_JOB"]
             end
 
             def pipeline_id
@@ -141,6 +153,57 @@ module Datadog
 
               @github_server_url ||= Datadog::Core::Utils::Url.filter_basic_auth(env["GITHUB_SERVER_URL"])
             end
+
+            # Returns numeric job ID from environment variable or runner diagnostics.
+            # Priority:
+            # 1. JOB_CHECK_RUN_ID environment variable (GitHub Actions feature pending)
+            # 2. Worker_*.log files in the runner's _diag folder (fallback)
+            def numeric_job_id
+              return @numeric_job_id if defined?(@numeric_job_id)
+
+              @numeric_job_id = env["JOB_CHECK_RUN_ID"] || extract_numeric_job_id_from_diag_files
+            end
+
+            def extract_numeric_job_id_from_diag_files
+              GITHUB_RUNNER_DIAG_PATHS.each do |diag_path|
+                next unless Dir.exist?(diag_path)
+
+                worker_files = Dir.glob(File.join(diag_path, "Worker_*.log")).sort
+                next if worker_files.empty?
+
+                # Use the most recent worker file (last in sorted order)
+                worker_file = worker_files.last
+                check_run_id = extract_check_run_id_from_worker_file(worker_file)
+                return check_run_id if check_run_id
+              end
+
+              nil
+            rescue => e
+              Datadog.logger.debug("Failed to extract numeric job ID from GitHub Actions runner diagnostics: #{e}")
+              nil
+            end
+
+            # Regex to extract check_run_id value from Worker log files.
+            # The log format varies between GitHub-hosted and self-hosted runners,
+            # so we use regex instead of JSON parsing for robustness.
+            # Matches patterns like: "k": "check_run_id" ... "v": 12345 or "v": 12345.0
+            CHECK_RUN_ID_REGEX = /"k":\s*"check_run_id"[^}]*"v":\s*(\d+)(?:\.\d+)?/
+
+            def extract_check_run_id_from_worker_file(file_path)
+              return nil unless File.exist?(file_path)
+
+              content = File.read(file_path)
+
+              # Find all check_run_id values in the file.
+              # On self-hosted runners, Worker_*.log files can be appended across multiple jobs,
+              # so we use the last match to get the current job's ID.
+              # flatten because scan with capture groups returns Array[Array[String]]
+              matches = content.scan(CHECK_RUN_ID_REGEX).flatten
+              matches.last
+            rescue => e
+              Datadog.logger.debug("Failed to parse Worker log file #{file_path}: #{e}")
+              nil
+            end
           end
         end
       end

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

@@ -53,6 +53,14 @@ module Datadog
         module_function
 
         def tags(env)
+          @tags ||= extract_tags(env).freeze
+        end
+
+        def reset!
+          @tags = nil
+        end
+
+        def extract_tags(env)
           # Extract metadata from CI provider environment variables
           tags = Environment::Extractor.new(env).tags
 
@@ -91,6 +99,8 @@ module Datadog
           tags
         end
 
+        private_class_method :extract_tags
+
         def ensure_post_conditions(tags)
           validate_repository_url(tags[Git::TAG_REPOSITORY_URL])
           validate_git_sha(tags[Git::TAG_COMMIT_SHA])

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

@@ -6,6 +6,7 @@ module Datadog
       # Defines constants for test tags
       module Settings
         ENV_MODE_ENABLED = "DD_TRACE_CI_ENABLED"
+        ENV_ENABLED = "DD_CIVISIBILITY_ENABLED"
         ENV_AGENTLESS_MODE_ENABLED = "DD_CIVISIBILITY_AGENTLESS_ENABLED"
         ENV_AGENTLESS_URL = "DD_CIVISIBILITY_AGENTLESS_URL"
         ENV_EXPERIMENTAL_TEST_SUITE_LEVEL_VISIBILITY_ENABLED = "DD_CIVISIBILITY_EXPERIMENTAL_TEST_SUITE_LEVEL_VISIBILITY_ENABLED"
@@ -30,6 +31,7 @@ module Datadog
         ENV_TEST_DISCOVERY_OUTPUT_PATH = "DD_TEST_OPTIMIZATION_DISCOVERY_FILE"
         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"
 
         # Source: https://docs.datadoghq.com/getting_started/site/
         DD_SITE_ALLOWLIST = %w[

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

@@ -54,6 +54,11 @@ module Datadog
         METRIC_CODE_COVERAGE_IS_EMPTY = "code_coverage.is_empty"
         METRIC_CODE_COVERAGE_FILES = "code_coverage.files"
 
+        METRIC_COVERAGE_UPLOAD_REQUEST = "coverage_upload.request"
+        METRIC_COVERAGE_UPLOAD_REQUEST_ERRORS = "coverage_upload.request_errors"
+        METRIC_COVERAGE_UPLOAD_REQUEST_MS = "coverage_upload.request_ms"
+        METRIC_COVERAGE_UPLOAD_REQUEST_BYTES = "coverage_upload.request_bytes"
+
         METRIC_KNOWN_TESTS_REQUEST = "known_tests.request"
         METRIC_KNOWN_TESTS_REQUEST_MS = "known_tests.request_ms"
         METRIC_KNOWN_TESTS_REQUEST_ERRORS = "known_tests.request_errors"

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

@@ -155,11 +155,6 @@ module Datadog
           SKIP = "skip"
         end
 
-        # test statuses that we use for execution stats but don't report to Datadog (e.g. fail_ignored)
-        module ExecutionStatsStatus
-          FAIL_IGNORED = "fail_ignored"
-        end
-
         # test types (e.g. test, benchmark, browser)
         module Type
           TEST = "test"

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

@@ -28,6 +28,9 @@ module Datadog
         TEST_COVERAGE_INTAKE_HOST_PREFIX = "citestcov-intake"
         TEST_COVERAGE_INTAKE_PATH = "/api/v2/citestcov"
 
+        CODE_COVERAGE_REPORT_INTAKE_HOST_PREFIX = "ci-intake"
+        CODE_COVERAGE_REPORT_INTAKE_PATH = "/api/v2/cicovreprt"
+
         LOGS_INTAKE_HOST_PREFIX = "http-intake.logs"
 
         DD_API_HOST_PREFIX = "api"
@@ -49,6 +52,7 @@ module Datadog
         DD_API_SETTINGS_RESPONSE_ATTEMPT_TO_FIX_RETRIES_KEY = "attempt_to_fix_retries"
         DD_API_SETTINGS_RESPONSE_DEFAULT = {DD_API_SETTINGS_RESPONSE_ITR_ENABLED_KEY => false}.freeze
         DD_API_SETTINGS_RESPONSE_IMPACTED_TESTS_ENABLED_KEY = "impacted_tests_enabled"
+        DD_API_SETTINGS_RESPONSE_COVERAGE_REPORT_UPLOAD_KEY = "coverage_report_upload_enabled"
 
         DD_API_GIT_SEARCH_COMMITS_PATH = "/api/v2/git/repository/search_commits"
 

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

@@ -25,6 +25,10 @@ module Datadog
 
         # Execute a git command with optional stdin input and timeout
         #
+        # All git commands are executed with the `-c safe.directory` option
+        # to handle cases where the repository is owned by a different user
+        # (common in CI environments with containerized builds).
+        #
         # @param cmd [Array<String>] The git command as an array of strings
         # @param stdin [String, nil] Optional stdin data to pass to the command
         # @param timeout [Integer] Timeout in seconds for the command execution
@@ -33,7 +37,11 @@ module Datadog
         def self.exec_git_command(cmd, stdin: nil, timeout: SHORT_TIMEOUT)
           # @type var out: String
           # @type var status: Process::Status?
-          out, status = Utils::Command.exec_command(["git"] + cmd, stdin_data: stdin, timeout: timeout)
+          out, status = Utils::Command.exec_command(
+            ["git", "-c", "safe.directory=#{safe_directory}"] + cmd,
+            stdin_data: stdin,
+            timeout: timeout
+          )
 
           if status.nil? || !status.success?
             # Convert command to string representation for error message
@@ -50,6 +58,56 @@ module Datadog
 
           out
         end
+
+        # Returns the directory to use for git's safe.directory config.
+        # This is cached to avoid repeated filesystem lookups.
+        #
+        # Traverses up from current directory to find the nearest .git folder
+        # and returns its parent (the repository root). Falls back to current
+        # working directory if no .git folder is found.
+        #
+        # @return [String] The safe directory path
+        def self.safe_directory
+          return @safe_directory if defined?(@safe_directory)
+
+          @safe_directory = find_git_directory(Dir.pwd)
+          Datadog.logger.debug { "Git safe.directory configured to: #{@safe_directory}" }
+          @safe_directory
+        end
+
+        # Traverses up from the given directory to find the nearest .git folder or file.
+        # Returns the repository root (parent of .git) if found, otherwise the original directory.
+        #
+        # Note: .git can be either a directory (regular repos) or a file (worktrees/submodules).
+        # In worktrees and submodules, .git is a file containing a pointer to the actual git directory.
+        #
+        # @param start_dir [String] The directory to start searching from
+        # @return [String] The repository root path or the start directory if not found
+        def self.find_git_directory(start_dir)
+          Datadog.logger.debug { "Searching for .git starting from: #{start_dir}" }
+          current_dir = File.expand_path(start_dir)
+
+          loop do
+            git_path = File.join(current_dir, ".git")
+
+            # Check for both directory (.git in regular repos) and file (.git in worktrees/submodules)
+            if File.exist?(git_path)
+              Datadog.logger.debug { "Found .git at: #{git_path} (#{File.directory?(git_path) ? "directory" : "file"})" }
+              return current_dir
+            end
+
+            parent_dir = File.dirname(current_dir)
+
+            # Reached the root directory
+            break if parent_dir == current_dir
+
+            current_dir = parent_dir
+          end
+
+          # Fallback to original directory if no .git found
+          Datadog.logger.debug { "No .git found, using fallback: #{start_dir}" }
+          start_dir
+        end
       end
     end
   end

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

@@ -29,7 +29,8 @@ module Datadog
             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 { impacted_tests_detection.configure(@library_configuration, test_session) }
+            Worker.new { impacted_tests_detection.configure(@library_configuration, test_session) },
+            Worker.new { code_coverage.configure(@library_configuration) }
           ]
 
           # launch configuration workers
@@ -123,6 +124,10 @@ module Datadog
         def git_tree_upload_worker
           Datadog.send(:components).git_tree_upload_worker
         end
+
+        def code_coverage
+          Datadog.send(:components).code_coverage
+        end
       end
     end
   end

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

@@ -117,6 +117,14 @@ module Datadog
           )
         end
 
+        def coverage_report_upload_enabled?
+          return @coverage_report_upload_enabled if defined?(@coverage_report_upload_enabled)
+
+          @coverage_report_upload_enabled = Utils::Parsing.convert_to_bool(
+            payload.fetch(Ext::Transport::DD_API_SETTINGS_RESPONSE_COVERAGE_REPORT_UPLOAD_KEY, false)
+          )
+        end
+
         def slow_test_retries
           return @slow_test_retries if defined?(@slow_test_retries)
 

data/lib/datadog/ci/test.rb

@@ -12,6 +12,11 @@ module Datadog
     #
     # @public_api
     class Test < Span
+      # Context IDs for this test (used for TIA context coverage merging).
+      # Contains list of context identifiers from outermost to innermost.
+      # @return [Array<String>] list of context IDs
+      attr_accessor :context_ids
+
       # @return [String] the name of the test.
       def name
         get_tag(Ext::Test::TAG_NAME)
@@ -166,13 +171,7 @@ module Datadog
       def failed!(exception: nil)
         super
 
-        # if we should ignore failures, we consider this test to be passed
-        if should_ignore_failures?
-          # use a special "fail_ignored" status to mark this test as failed but ignored
-          record_test_result(Ext::Test::ExecutionStatsStatus::FAIL_IGNORED)
-        else
-          record_test_result(Ext::Test::Status::FAIL)
-        end
+        record_test_result(Ext::Test::Status::FAIL)
       end
 
       # Sets the status of the span to "skip".
@@ -236,7 +235,10 @@ module Datadog
 
       # @internal
       def should_ignore_failures?
-        quarantined? || disabled? || any_retry_passed?
+        return true if quarantined? || disabled?
+        return false if attempt_to_fix?
+
+        any_retry_passed?
       end
 
       # @internal
@@ -249,16 +251,9 @@ module Datadog
         status = get_tag(Ext::Test::TAG_STATUS)
         return if status.nil?
 
-        if [Ext::Test::Status::PASS, Ext::Test::Status::SKIP].include?(status)
-          set_tag(Ext::Test::TAG_FINAL_STATUS, status)
-          return
-        end
-
-        if should_ignore_failures?
-          set_tag(Ext::Test::TAG_FINAL_STATUS, Ext::Test::Status::PASS)
-        else
-          set_tag(Ext::Test::TAG_FINAL_STATUS, Ext::Test::Status::FAIL)
-        end
+        final_status = compute_final_status(status)
+        set_tag(Ext::Test::TAG_FINAL_STATUS, final_status)
+        test_suite&.record_test_final_status(datadog_test_id, final_status)
       end
 
       # @internal
@@ -272,6 +267,20 @@ module Datadog
 
       private
 
+      def compute_final_status(status)
+        # Skip status is always preserved
+        return status if status == Ext::Test::Status::SKIP
+
+        # For attempt_to_fix tests (not quarantined/disabled), any failure means the fix didn't work
+        if attempt_to_fix? && !quarantined? && !disabled?
+          return all_executions_passed? ? Ext::Test::Status::PASS : Ext::Test::Status::FAIL
+        end
+
+        return status if status == Ext::Test::Status::PASS
+
+        should_ignore_failures? ? Ext::Test::Status::PASS : Ext::Test::Status::FAIL
+      end
+
       def record_test_result(datadog_status)
         # if this test was already executed in this test suite, mark it as retried
         if test_suite&.test_executed?(datadog_test_id)

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

@@ -75,6 +75,15 @@ module Datadog
           test_properties.fetch("attempt_to_fix", false)
         end
 
+        def disabled?(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("disabled", false)
+        end
+
         def restore_state_from_datadog_test_runner
           Datadog.logger.debug { "Restoring test management tests from DDTest cache" }
 

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

@@ -19,6 +19,14 @@ module Datadog
 
         def tag_test_from_properties(_)
         end
+
+        def attempt_to_fix?(_datadog_fqn_test_id)
+          false
+        end
+
+        def disabled?(_datadog_fqn_test_id)
+          false
+        end
       end
     end
   end

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

@@ -69,6 +69,16 @@ module Datadog
 
           @mutex = Mutex.new
 
+          # Context coverage: stores coverage collected during before(:context)/before(:all) hooks
+          # keyed by context_id (e.g., RSpec scoped_id for example groups)
+          # Only used when use_single_threaded_coverage is false (multi-threaded mode)
+          @context_coverages = {}
+          @context_coverages_mutex = Mutex.new
+
+          # Currently active context ID for context coverage collection
+          @current_context_id = nil
+          @current_context_id_mutex = Mutex.new
+
           Datadog.logger.debug("TestOptimisation initialized with enabled: #{@enabled}")
         end
 
@@ -117,24 +127,105 @@ module Datadog
           @code_coverage_enabled
         end
 
-        def start_coverage(test)
+        # Starts coverage collection.
+        # This is a low-level method that only starts the collector.
+        #
+        # @return [void]
+        def start_coverage
           return if !enabled? || !code_coverage?
 
-          Telemetry.code_coverage_started(test)
           coverage_collector&.start
         end
 
-        def stop_coverage(test)
+        # Stops coverage collection and returns raw coverage data.
+        # This is a low-level method that only stops the collector.
+        #
+        # @return [Hash, nil] Raw coverage data or nil
+        def stop_coverage
+          return if !enabled? || !code_coverage?
+
+          coverage_collector&.stop
+        end
+
+        # Called when a test context (e.g., RSpec example group with before(:context)) starts.
+        # Starts collecting coverage that will be merged into all tests within this context.
+        #
+        # @param context_id [String] A stable identifier for the context (e.g., RSpec scoped_id)
+        # @return [void]
+        def on_test_context_started(context_id)
+          return unless context_coverage_enabled?
+
+          # Stop and store any existing context coverage before starting new one.
+          # This ensures that outer context coverage is preserved when nested contexts start.
+          stop_context_coverage_and_store
+
+          Datadog.logger.debug { "Starting context coverage collection for context [#{context_id}]" }
+
+          # Store the context_id we're collecting for
+          @current_context_id_mutex.synchronize do
+            @current_context_id = context_id
+          end
+
+          coverage_collector&.start
+        end
+
+        # Called when a test starts within a context. This method:
+        # 1. Stops any in-progress context coverage collection and stores it
+        # 2. Starts coverage collection for the test itself
+        #
+        # @param test [Datadog::CI::Test] The test that is starting
+        # @return [void]
+        def on_test_started(test)
           return if !enabled? || !code_coverage?
 
+          # Stop any in-progress context coverage and store it
+          stop_context_coverage_and_store
+
+          Telemetry.code_coverage_started(test)
+
+          context_ids = test.context_ids || []
+
+          Datadog.logger.debug do
+            "Starting test coverage for [#{test.name}] with context chain: #{context_ids.inspect}"
+          end
+
+          coverage_collector&.start
+        end
+
+        # Called when a test finishes. This method:
+        # 1. Stops test coverage collection
+        # 2. Merges context coverage from all relevant contexts
+        # 3. Writes the combined coverage event
+        # 4. Records ITR statistics if test was skipped by TIA
+        #
+        # @param test [Datadog::CI::Test] The test that finished
+        # @param context [Datadog::CI::TestVisibility::Context] The test visibility context for ITR stats
+        # @return [Datadog::CI::TestOptimisation::Coverage::Event, nil] The coverage event or nil
+        def on_test_finished(test, context)
+          return unless enabled?
+
+          # Handle ITR statistics
+          if test.skipped_by_test_impact_analysis?
+            Telemetry.itr_skipped
+
+            context.incr_tests_skipped_by_tia_count
+          end
+
+          # Handle code coverage
+          return unless code_coverage?
           Telemetry.code_coverage_finished(test)
 
           coverage = coverage_collector&.stop
 
           # if test was skipped, we discard coverage data
           return if test.skipped?
+          coverage ||= {}
+
+          # Merge context coverage from all relevant contexts
+          context_ids = test.context_ids || []
+          merge_context_coverages_into_test(coverage, context_ids)
 
-          if coverage.nil? || coverage.empty?
+          if coverage.empty?
             Telemetry.code_coverage_is_empty
             return
           end
@@ -149,18 +240,41 @@ module Datadog
 
           Telemetry.code_coverage_files(coverage.size)
 
-          event = Coverage::Event.new(
+          coverage_event = Coverage::Event.new(
             test_id: test.id.to_s,
             test_suite_id: test.test_suite_id.to_s,
             test_session_id: test.test_session_id.to_s,
             coverage: coverage
           )
 
-          Datadog.logger.debug { "Writing coverage event \n #{event.pretty_inspect}" }
+          Datadog.logger.debug { "Writing coverage event \n #{coverage_event.pretty_inspect}" }
 
-          write(event)
+          write(coverage_event)
 
-          event
+          coverage_event
+        end
+
+        # Clears stored context coverage for a specific context.
+        # Should be called when a context finishes (e.g., after(:context) completes).
+        #
+        # @param context_id [String] The context ID to clear
+        # @return [void]
+        def clear_context_coverage(context_id)
+          return unless context_coverage_enabled?
+
+          @context_coverages_mutex.synchronize do
+            @context_coverages.delete(context_id)
+
+            Datadog.logger.debug { "Cleared context coverage for [#{context_id}]" }
+          end
+        end
+
+        # Returns whether context coverage collection is enabled.
+        # Context coverage is disabled in single-threaded mode.
+        #
+        # @return [Boolean]
+        def context_coverage_enabled?
+          enabled? && code_coverage? && !@use_single_threaded_coverage
         end
 
         def skippable?(datadog_test_id)
@@ -181,14 +295,6 @@ module Datadog
           end
         end
 
-        def on_test_finished(test, context)
-          return if !test.skipped? || !test.skipped_by_test_impact_analysis?
-
-          Telemetry.itr_skipped
-
-          context.incr_tests_skipped_by_tia_count
-        end
-
         def write_test_session_tags(test_session, skipped_tests_count)
           return if !enabled?
 
@@ -390,6 +496,52 @@ module Datadog
         def git_tree_upload_worker
           Datadog.send(:components).git_tree_upload_worker
         end
+
+        # Stops any in-progress context coverage collection and stores it.
+        # Called when a test starts to capture coverage from before(:context) hooks.
+        def stop_context_coverage_and_store
+          return unless context_coverage_enabled?
+
+          context_id = @current_context_id_mutex.synchronize do
+            id = @current_context_id
+            @current_context_id = nil
+            id
+          end
+          return if context_id.nil?
+
+          coverage = coverage_collector&.stop
+          return if coverage.nil? || coverage.empty?
+
+          @context_coverages_mutex.synchronize do
+            @context_coverages[context_id] = coverage
+          end
+
+          Datadog.logger.debug do
+            "Stored context coverage for [#{context_id}] with #{coverage.size} files"
+          end
+        end
+
+        # Merges context coverage from all relevant contexts into the test's coverage.
+        #
+        # @param coverage [Hash] The test's coverage hash to merge into
+        # @param context_ids [Array<String>] List of context IDs to merge coverage from
+        def merge_context_coverages_into_test(coverage, context_ids)
+          return if @use_single_threaded_coverage
+          return if context_ids.empty?
+
+          @context_coverages_mutex.synchronize do
+            context_ids.each do |context_id|
+              context_coverage = @context_coverages[context_id]
+              next unless context_coverage
+
+              coverage.merge!(context_coverage)
+            end
+          end
+
+          Datadog.logger.debug do
+            "Merged context coverage for contexts: #{context_ids.inspect} into test coverage"
+          end
+        end
       end
     end
   end

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

@@ -34,21 +34,35 @@ module Datadog
           false
         end
 
-        def start_coverage(_test)
+        def start_coverage
         end
 
-        def stop_coverage(_test)
+        def stop_coverage
           nil
         end
 
-        def mark_if_skippable(_test)
+        def on_test_context_started(_context_id)
         end
 
-        def skippable?(_datadog_test_id)
-          false
+        def on_test_started(_test)
         end
 
         def on_test_finished(_test, _context)
+          nil
+        end
+
+        def clear_context_coverage(_context_id)
+        end
+
+        def context_coverage_enabled?
+          false
+        end
+
+        def mark_if_skippable(_test)
+        end
+
+        def skippable?(_datadog_test_id)
+          false
         end
 
         def write_test_session_tags(_test_session, _skipped_tests_count)