update telemetry logic

YuliiaKovalova · YuliiaKovalova · commit 924c0a373c51 · 2026-01-02T18:26:03.000+01:00
diff --git a/eng/Signing.props b/eng/Signing.props
@@ -11,6 +11,9 @@
     <ItemsToSign Include="$(ArtifactsDir)\xsd\Update-MSBuildXsds.ps1" />
 
     <FileSignInfo Include="RuntimeContracts.dll" CertificateName="3PartySHA2" />
+
+    <!-- For Telemetry in VS.-->
+    <FileSignInfo Include="Newtonsoft.Json.dll" CertificateName="3PartySHA2" />
   </ItemGroup>
 
   <!-- Remove existing .nupkg signing info and set to None for testing to workaround the existing issue in arcade. -->
diff --git a/src/Build.UnitTests/BackEnd/BuildManager_Tests.cs b/src/Build.UnitTests/BackEnd/BuildManager_Tests.cs
@@ -1801,7 +1801,7 @@ public void OverlappingBuildsOfTheSameProjectDifferentTargetsAreAllowed()
  </Target>
 </Project>
 ");
-
+            _env.SetEnvironmentVariable("MSBUILDNOINPROCNODE", "1");
             Project project = CreateProject(contents, MSBuildDefaultToolsVersion, _projectCollection, true);
             ProjectInstance instance = _buildManager.GetProjectInstanceForBuild(project);
             _buildManager.BeginBuild(_parameters);
diff --git a/src/Build/BackEnd/BuildManager/BuildManager.cs b/src/Build/BackEnd/BuildManager/BuildManager.cs
@@ -295,6 +295,7 @@ public BuildManager()
         public BuildManager(string hostName)
         {
             ErrorUtilities.VerifyThrowArgumentNull(hostName);
+
             _hostName = hostName;
             _buildManagerState = BuildManagerState.Idle;
             _buildSubmissions = new Dictionary<int, BuildSubmissionBase>();
@@ -459,8 +460,11 @@ private void UpdatePriority(Process p, ProcessPriorityClass priority)
         /// <exception cref="InvalidOperationException">Thrown if a build is already in progress.</exception>
         public void BeginBuild(BuildParameters parameters)
         {
-            TelemetryManager.Instance.Initialize(isStandalone: false, parameters.IsTelemetryEnabled);
-
+#if NETFRAMEWORK
+            // Collect telemetry unless explicitly opted out via environment variable.
+            // The decision to send telemetry is made at EndBuild to avoid eager loading of telemetry assemblies.
+            parameters.IsTelemetryEnabled |= !TelemetryManager.IsOptOut();
+#endif
             if (_previousLowPriority != null)
             {
                 if (parameters.LowPriority != _previousLowPriority)
@@ -586,7 +590,6 @@ public void BeginBuild(BuildParameters parameters)
                 // Initialize components.
                 _nodeManager = ((IBuildComponentHost)this).GetComponent(BuildComponentType.NodeManager) as INodeManager;
 
-                _buildParameters.IsTelemetryEnabled |= TelemetryManager.Instance?.DefaultActivitySource?.IsTelemetryEnabled ?? false;
                 var loggingService = InitializeLoggingService();
 
                 // Log deferred messages and response files
@@ -1113,10 +1116,7 @@ public void EndBuild()
 
                             loggingService.LogTelemetry(buildEventContext: null, _buildTelemetry.EventName, _buildTelemetry.GetProperties());
 
-                            if (_buildParameters.IsTelemetryEnabled)
-                            {
-                                EndBuildTelemetry();
-                            }
+                            EndBuildTelemetry();
 
                             // Clean telemetry to make it ready for next build submission.
                             _buildTelemetry = null;
@@ -1160,9 +1160,11 @@ void SerializeCaches()
             }
         }
 
-        [MethodImpl(MethodImplOptions.NoInlining)] // avoid early assembly load of Microsoft.VisualStudio.Telemetry
+        [MethodImpl(MethodImplOptions.NoInlining)]
         private void EndBuildTelemetry()
         {
+            TelemetryManager.Instance.Initialize(isStandalone: false);
+
             using IActivity? activity = TelemetryManager.Instance
                 ?.DefaultActivitySource
                 ?.StartActivity(TelemetryConstants.Build)
diff --git a/src/Framework/Telemetry/MSBuildActivitySource.cs b/src/Framework/Telemetry/MSBuildActivitySource.cs
@@ -21,25 +21,16 @@ internal class MSBuildActivitySource
         public MSBuildActivitySource(TelemetrySession? telemetrySession)
         {
             _telemetrySession = telemetrySession;
-            IsTelemetryEnabled = _telemetrySession?.IsOptedIn ?? false;
         }
 #else
         private readonly ActivitySource _source;
 
-        public MSBuildActivitySource(string name, bool isTelemetryExplicitlyRequested)
+        public MSBuildActivitySource(string name)
         {
             _source = new ActivitySource(name);
-            IsTelemetryEnabled = isTelemetryExplicitlyRequested;
         }
 #endif
 
-        /// <summary>
-        /// Gets a value indicating whether telemetry is enabled for this activity source.
-        /// On .NET Framework, this reflects whether the VS Telemetry session is opted in.
-        /// On .NET Core and later, this reflects whether telemetry was explicitly requested.
-        /// </summary>
-        public bool IsTelemetryEnabled { get; }
-
         /// <summary>
         /// Starts a new activity with the appropriate telemetry prefix.
         /// </summary>
diff --git a/src/Framework/Telemetry/TelemetryManager.cs b/src/Framework/Telemetry/TelemetryManager.cs
@@ -49,10 +49,8 @@ private TelemetryManager()
         /// versus integrated mode (e.g., running within Visual Studio or dotnet CLI).
         /// When <c>true</c>, creates and manages its own telemetry session on .NET Framework.
         /// </param>
-        /// <param name="isTelemetryExplicitlyRequested">
-        /// Indicates whether telemetry was explicitly requested through command line arguments.
-        /// </param>
-        public void Initialize(bool isStandalone, bool isTelemetryExplicitlyRequested)
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        public void Initialize(bool isStandalone)
         {
             lock (s_lock)
             {
@@ -68,7 +66,7 @@ public void Initialize(bool isStandalone, bool isTelemetryExplicitlyRequested)
                     return;
                 }
 
-                TryInitializeTelemetry(isStandalone, isTelemetryExplicitlyRequested);
+                TryInitializeTelemetry(isStandalone);
             }
         }
 
@@ -92,14 +90,14 @@ internal static void ResetForTest()
         /// allowing the calling code to catch assembly loading exceptions.
         /// </summary>
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private void TryInitializeTelemetry(bool isStandalone, bool isTelemetryExplicitlyRequested)
+        private void TryInitializeTelemetry(bool isStandalone)
         {
             try
             {
 #if NETFRAMEWORK
                 DefaultActivitySource = VsTelemetryInitializer.Initialize(isStandalone);
 #else
-                DefaultActivitySource = new MSBuildActivitySource(TelemetryConstants.DefaultActivitySourceNamespace, isTelemetryExplicitlyRequested);
+                DefaultActivitySource = new MSBuildActivitySource(TelemetryConstants.DefaultActivitySourceNamespace);
 #endif
             }
             catch (Exception ex) when (ex is FileNotFoundException or FileLoadException or TypeLoadException)
@@ -136,65 +134,58 @@ FileLoadException or
             }
         }
 
-#if NETFRAMEWORK
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static void DisposeVsTelemetry() => VsTelemetryInitializer.Dispose();
-#endif
-
         /// <summary>
         /// Determines if the user has explicitly opted out of telemetry.
         /// </summary>
-        private static bool IsOptOut() =>
+        internal static bool IsOptOut() =>
 #if NETFRAMEWORK
             Traits.Instance.FrameworkTelemetryOptOut;
 #else
             Traits.Instance.SdkTelemetryOptOut;
 #endif
+
+#if NETFRAMEWORK
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static void DisposeVsTelemetry() => VsTelemetryInitializer.Dispose();
+#endif
     }
 
 #if NETFRAMEWORK
-    /// <summary>
-    /// Isolated class that references Microsoft.VisualStudio.Telemetry types.
-    /// This separation ensures the VS Telemetry assembly is only loaded when methods
-    /// on this class are actually invoked.
-    /// </summary>
-    /// <remarks>
-    /// Thread-safety: All public methods on this class must be called under the
-    /// <see cref="TelemetryManager"/> lock to ensure thread-safe access to static state.
-    /// Callers must not invoke <see cref="Initialize"/> or <see cref="Dispose"/> concurrently.
-    /// </remarks>
     internal static class VsTelemetryInitializer
     {
         // Telemetry API key for Visual Studio telemetry service.
         private const string CollectorApiKey = "f3e86b4023cc43f0be495508d51f588a-f70d0e59-0fb0-4473-9f19-b4024cc340be-7296";
 
-        private static TelemetrySession? s_telemetrySession;
+        // Store as object to avoid type reference at class load time
+        private static object? s_telemetrySession;
         private static bool s_ownsSession = false;
 
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static MSBuildActivitySource Initialize(bool isStandalone)
         {
+            TelemetrySession session;
             if (isStandalone)
             {
-                s_telemetrySession = TelemetryService.CreateAndGetDefaultSession(CollectorApiKey);
+                session = TelemetryService.CreateAndGetDefaultSession(CollectorApiKey);
                 TelemetryService.DefaultSession.UseVsIsOptedIn();
                 TelemetryService.DefaultSession.Start();
                 s_ownsSession = true;
             }
             else
             {
-                s_telemetrySession = TelemetryService.DefaultSession;
+                session = TelemetryService.DefaultSession;
             }
 
-            return new MSBuildActivitySource(s_telemetrySession);
+            s_telemetrySession = session;
+            return new MSBuildActivitySource(session);
         }
 
+        [MethodImpl(MethodImplOptions.NoInlining)]
         public static void Dispose()
         {
-            // Only dispose the session if we created it (standalone scenario).
-            // In VS, the session is owned by VS and should not be disposed by MSBuild.
-            if (s_ownsSession)
+            if (s_ownsSession && s_telemetrySession is TelemetrySession session)
             {
-                s_telemetrySession?.Dispose();
+                session.Dispose();
             }
 
             s_telemetrySession = null;
diff --git a/src/MSBuild/XMake.cs b/src/MSBuild/XMake.cs
@@ -250,7 +250,7 @@ string[] args
             // Initialize new build telemetry and record start of this build.
             KnownTelemetry.PartialBuildTelemetry = new BuildTelemetry { StartAt = DateTime.UtcNow, IsStandaloneExecution = true };
 
-            TelemetryManager.Instance?.Initialize(isStandalone: true, isTelemetryExplicitlyRequested: false);
+            TelemetryManager.Instance?.Initialize(isStandalone: true);
 
             using PerformanceLogEventListener eventListener = PerformanceLogEventListener.Create();
 
diff --git a/src/MSBuild/app.amd64.config b/src/MSBuild/app.amd64.config
@@ -106,6 +106,10 @@
           <bindingRedirect oldVersion="0.0.0.0-9.0.0.11" newVersion="9.0.0.11" />
           <codeBase version="9.0.0.11" href="..\System.Collections.Immutable.dll"/>
         </dependentAssembly>
+        <dependentAssembly>
+          <assemblyIdentity name="Newtonsoft.Json" publicKeyToken="30ad4fe6b2a6aeed" culture="neutral" />
+          <codeBase version="13.0.0.0" href="..\Newtonsoft.Json.dll" />
+        </dependentAssembly>
         <dependentAssembly>
           <assemblyIdentity name="System.Memory" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
           <bindingRedirect oldVersion="0.0.0.0-4.0.2.0" newVersion="4.0.2.0" />
diff --git a/src/Package/MSBuild.VSSetup/files.swr b/src/Package/MSBuild.VSSetup/files.swr
@@ -89,6 +89,7 @@ folder InstallDir:\MSBuild\Current\Bin
   file source=$(X86BinPath)Microsoft.WinFx.targets
   file source=$(X86BinPath)Microsoft.WorkflowBuildExtensions.targets
   file source=$(X86BinPath)Microsoft.VisualStudio.Utilities.Internal.dll vs.file.ngenApplications="[installDir]\MSBuild\Current\Bin\amd64\MSBuild.exe" vs.file.ngenArchitecture=all vs.file.ngenPriority=3
+  file source=$(X86BinPath)Newtonsoft.Json.dll vs.file.ngenApplications="[installDir]\MSBuild\Current\Bin\amd64\MSBuild.exe" vs.file.ngenArchitecture=all vs.file.ngenPriority=2
 
 folder InstallDir:\MSBuild\Current\Bin\MSBuild
   file source=$(X86BinPath)\MSBuild\Microsoft.Build.Core.xsd
