DataDog · tonyredondo · May 12, 2026 · May 12, 2026 · May 12, 2026 · May 12, 2026
@@ -16,6 +16,7 @@
 using Datadog.Trace.Ci;
 using Datadog.Trace.Ci.CiEnvironment;
 using Datadog.Trace.Ci.Configuration;
+using Datadog.Trace.Ci.Coverage.Backfill;
 using Datadog.Trace.Ci.Net;
 using Datadog.Trace.Logging;
 using Datadog.Trace.Util;
@@ -58,6 +59,8 @@ public static async Task<InitResults> InitializeCiCommandsAsync(
 
         // We force Test optimization mode on child process
         profilerEnvironmentVariables[Configuration.ConfigurationKeys.CIVisibility.Enabled] = "1";
+        profilerEnvironmentVariables[Configuration.ConfigurationKeys.CIVisibility.TestOptimizationRunId] = testOptimization.RunId;
+        profilerEnvironmentVariables[Configuration.ConfigurationKeys.CIVisibilityItrCoverageBackfillRunFolder] = CoverageBackfillDataStore.GetOrCreateRunFolder(testOptimization);
 
         // We check the settings and merge with the command settings options
         var agentless = testOptimizationSettings.Agentless;
@@ -113,6 +116,7 @@ public static async Task<InitResults> InitializeCiCommandsAsync(
         }
 
         // Initialize flags to enable code coverage and test skipping
+        var internalCodeCoverageReportingEnabled = testOptimizationSettings.CodeCoverageEnabled == true;
         var codeCoverageEnabled = testOptimizationSettings.CodeCoverageEnabled == true || testOptimizationSettings.TestsSkippingEnabled == true;
         var testSkippingEnabled = testOptimizationSettings.TestsSkippingEnabled == true;
         var knownTestsEnabled = testOptimizationSettings.KnownTestsEnabled == true;
@@ -204,6 +208,7 @@ async Task UploadRepositoryChangesAsync()
                         itrSettings = await client.GetSettingsAsync(skipFrameworkInfo: true).ConfigureAwait(false);
                     }
 
+                    internalCodeCoverageReportingEnabled = internalCodeCoverageReportingEnabled || itrSettings.CodeCoverage == true;
                     codeCoverageEnabled = codeCoverageEnabled || itrSettings.CodeCoverage == true || itrSettings.TestsSkipping == true;
                     testSkippingEnabled = itrSettings.TestsSkipping == true;
                     knownTestsEnabled = knownTestsEnabled || itrSettings.KnownTestsEnabled == true;
@@ -363,8 +368,8 @@ async Task UploadRepositoryChangesAsync()
                     Log.Warning("RunCiCommand: Code coverage is enabled but the command is not a 'dotnet test' nor 'dotnet vstest' nor 'vstest.console' command. Code coverage will not be collected.");
                 }
 
-                // Sets the code coverage path to store the json files for each module in case we are not skipping test (global coverage is reliable).
-                if (!testSkippingEnabled)
+                // Store Datadog global coverage when it is complete by construction, or when explicit reporting can be corrected by ITR backfill.
+                if (!testSkippingEnabled || internalCodeCoverageReportingEnabled)
                 {
                     var outputFolders = new[] { Environment.CurrentDirectory, Path.GetTempPath(), };
                     foreach (var folder in outputFolders)

@@ -807,6 +807,7 @@
       <type fullname="System.OperatingSystem" />
       <type fullname="System.OperationCanceledException" />
       <type fullname="System.OutOfMemoryException" />
+      <type fullname="System.OverflowException" />
       <type fullname="System.ParamArrayAttribute" />
       <type fullname="System.PlatformID" />
       <type fullname="System.PlatformNotSupportedException" />

@@ -0,0 +1,97 @@
+// <copyright file="CoverageBackfillApplicator.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+#nullable enable
+
+using System;
+using Datadog.Trace.Ci.CiEnvironment;
+using Datadog.Trace.Ci.Coverage.Models.Global;
+using Datadog.Trace.Ci.Coverage.Util;
+
+namespace Datadog.Trace.Ci.Coverage.Backfill;
+
+/// <summary>
+/// Applies backend skipped-test coverage to local coverage models while keeping local executable lines as the denominator.
+/// </summary>
+internal static class CoverageBackfillApplicator
+{
+    /// <summary>
+    /// Applies backend skipped-test coverage to Datadog's internal global coverage model.
+    /// </summary>
+    /// <param name="globalCoverage">Local global coverage data collected from tests that actually ran.</param>
+    /// <param name="backfillData">Backend coverage data returned by the skippable-tests endpoint.</param>
+    /// <returns>Summary of the backfill operation.</returns>
+    public static CoverageBackfillResult ApplyToGlobalCoverage(GlobalCoverageInfo? globalCoverage, CoverageBackfillData? backfillData)
+    {
+        if (globalCoverage is null ||
+            backfillData is not { IsPresent: true, IsValid: true })
+        {
+            return new CoverageBackfillResult(applied: false, matchedFiles: 0, updatedFiles: 0);
+        }
+
+        var matchedFiles = 0;
+        var updatedFiles = 0;
+        foreach (var component in globalCoverage.Components)
+        {
+            foreach (var file in component.Files)
+            {
+                if (file.Path is null ||
+                    file.ExecutableBitmap is null ||
+                    !backfillData.ExecutedLinesByRelativePath.TryGetValue(NormalizeLocalPath(file.Path), out var backendExecutedBitmap))
+                {
+                    continue;
+                }
+
+                matchedFiles++;
+                if (ApplyBackendBitmap(file, backendExecutedBitmap))
+                {
+                    updatedFiles++;
+                }
+            }
+        }
+
+        return new CoverageBackfillResult(applied: true, matchedFiles, updatedFiles);
+    }
+
+    private static bool ApplyBackendBitmap(FileCoverageInfo file, byte[] backendExecutedBitmap)
+    {
+        if (file.ExecutableBitmap is null)
+        {
+            return false;
+        }
+
+        using var backendBitmap = new FileBitmap(backendExecutedBitmap);
+        using var executableBitmap = new FileBitmap(file.ExecutableBitmap);
+        using var maskedBackendBitmap = backendBitmap & executableBitmap;
+        if (!maskedBackendBitmap.HasActiveBits())
+        {
+            return false;
+        }
+
+        var before = file.ExecutedBitmap;
+        if (before is null)
+        {
+            file.AggregateExecutedBitmap(maskedBackendBitmap.GetInternalArrayOrToArrayAndDispose());
+            return true;
+        }
+
+        using var beforeBitmap = new FileBitmap(before);
+        using var mergedBitmap = maskedBackendBitmap | beforeBitmap;
+        var merged = mergedBitmap.GetInternalArrayOrToArrayAndDispose();
+        if (before.AsSpan().SequenceEqual(merged))
+        {
+            return false;
+        }
+
+        file.ExecutedBitmap = merged;
+        return true;
+    }
+
+    private static string NormalizeLocalPath(string path)
+    {
+        var relativePath = CIEnvironmentValues.Instance.MakeRelativePathFromSourceRoot(path, false);
+        return CoverageBackfillData.NormalizePath(relativePath);
+    }
+}