Add telemetry collection for MSTest usage analytics

src/Adapter/MSTest.TestAdapter/MSTest.TestAdapter.csproj

@@ -51,6 +51,11 @@
     <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
   </PropertyGroup>
 
+  <!-- Properties specific to WinUI -->
+  <PropertyGroup Condition=" '$(TargetFramework)' == '$(WinUiMinimum)' ">
+    <DefineConstants>$(DefineConstants);WIN_UI</DefineConstants>
+  </PropertyGroup>
+
   <ItemGroup>
     <ProjectReference Include="$(RepoRoot)src\Adapter\MSTestAdapter.PlatformServices\MSTestAdapter.PlatformServices.csproj" />
     <ProjectReference Include="$(RepoRoot)src\Platform\Microsoft.Testing.Extensions.VSTestBridge\Microsoft.Testing.Extensions.VSTestBridge.csproj" Condition=" '$(TargetFramework)' != '$(UwpMinimum)' " />

src/Adapter/MSTest.TestAdapter/TestingPlatformAdapter/MSTestBridgedTestFramework.cs

@@ -9,8 +9,10 @@
 using Microsoft.Testing.Platform.Logging;
 using Microsoft.Testing.Platform.Messages;
 using Microsoft.Testing.Platform.Services;
+using Microsoft.Testing.Platform.Telemetry;
 using Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter;
 using Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.Extensions;
+using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices;
 using Microsoft.VisualStudio.TestPlatform.MSTestAdapter.PlatformServices.Helpers;
 using Microsoft.VisualStudio.TestPlatform.ObjectModel;
 
@@ -41,8 +43,7 @@ protected override Task SynchronizedDiscoverTestsAsync(VSTestDiscoverTestExecuti
             Debugger.Launch();
         }
 
-        new MSTestDiscoverer().DiscoverTests(request.AssemblyPaths, request.DiscoveryContext, request.MessageLogger, request.DiscoverySink, _configuration, isMTP: true);
-        return Task.CompletedTask;
+        return new MSTestDiscoverer(new TestSourceHandler(), CreateTelemetrySender()).DiscoverTestsAsync(request.AssemblyPaths, request.DiscoveryContext, request.MessageLogger, request.DiscoverySink, _configuration, isMTP: true);
     }
 
     /// <inheritdoc />
@@ -55,7 +56,7 @@ protected override async Task SynchronizedRunTestsAsync(VSTestRunTestExecutionRe
             Debugger.Launch();
         }
 
-        MSTestExecutor testExecutor = new(cancellationToken);
+        MSTestExecutor testExecutor = new(cancellationToken, CreateTelemetrySender());
         await testExecutor.RunTestsAsync(request.AssemblyPaths, request.RunContext, request.FrameworkHandle, _configuration, isMTP: true).ConfigureAwait(false);
     }
 
@@ -103,5 +104,19 @@ private static TestMethodIdentifierProperty GetMethodIdentifierPropertyFromManag
         // Or alternatively, does VSTest object model expose the assembly full name somewhere?
         return new TestMethodIdentifierProperty(assemblyFullName: string.Empty, @namespace, typeName, methodName, arity, parameterTypes, returnTypeFullName: string.Empty);
     }
+
+    [SuppressMessage("ApiDesign", "RS0030:Do not use banned APIs", Justification = "We can use MTP from this folder")]
+    private Func<string, IDictionary<string, object>, Task>? CreateTelemetrySender()
+    {
+        ITelemetryInformation telemetryInformation = ServiceProvider.GetTelemetryInformation();
+        if (!telemetryInformation.IsEnabled)
+        {
+            return null;
+        }
+
+        ITelemetryCollector telemetryCollector = ServiceProvider.GetTelemetryCollector();
+
+        return (eventName, metrics) => telemetryCollector.LogEventAsync(eventName, metrics, CancellationToken.None);
+    }
 }
 #endif

src/Adapter/MSTest.TestAdapter/VSTestAdapter/MSTestDiscoverer.cs

@@ -20,14 +20,27 @@ namespace Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter;
 internal sealed class MSTestDiscoverer : ITestDiscoverer
 {
     private readonly ITestSourceHandler _testSourceHandler;
+#if !WINDOWS_UWP && !WIN_UI
+    private readonly Func<string, IDictionary<string, object>, Task>? _telemetrySender;
+#endif
 
+    // The parameterless constructor is required by VSTest, which instantiates the
+    // discoverer via reflection. The internal constructor exists for tests and for the
+    // MTP bridge (MSTestBridgedTestFramework) which injects a telemetry sender.
     public MSTestDiscoverer()
         : this(new TestSourceHandler())
     {
     }
 
-    internal /* for testing purposes */ MSTestDiscoverer(ITestSourceHandler testSourceHandler)
-        => _testSourceHandler = testSourceHandler;
+    internal MSTestDiscoverer(ITestSourceHandler testSourceHandler, Func<string, IDictionary<string, object>, Task>? telemetrySender = null)
+    {
+        _testSourceHandler = testSourceHandler;
+#if !WINDOWS_UWP && !WIN_UI
+        _telemetrySender = telemetrySender;
+#else
+        _ = telemetrySender;
+#endif
+    }
 
     /// <summary>
     /// Discovers the tests available from the provided source. Not supported for .xap source.
@@ -39,9 +52,12 @@ public MSTestDiscoverer()
     [System.Security.SecurityCritical]
     [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Discovery context can be null.")]
     public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
-        => DiscoverTests(sources, discoveryContext, logger, discoverySink, null, isMTP: false);
+        // VSTest's ITestDiscoverer is a synchronous interface. The telemetry sender is null in
+        // this code path (only the MTP bridge supplies one), so the awaited send below completes
+        // synchronously and GetAwaiter().GetResult() does not actually block on I/O.
+        => DiscoverTestsAsync(sources, discoveryContext, logger, discoverySink, configuration: null, isMTP: false).GetAwaiter().GetResult();
 
-    internal void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink, IConfiguration? configuration, bool isMTP)
+    internal async Task DiscoverTestsAsync(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink, IConfiguration? configuration, bool isMTP)
     {
         if (sources is null)
         {
@@ -58,9 +74,31 @@ internal void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext disco
             throw new ArgumentNullException(nameof(discoverySink));
         }
 
-        if (MSTestDiscovererHelpers.InitializeDiscovery(sources, discoveryContext, logger, configuration, _testSourceHandler))
+        // Initialize telemetry collection if not already set (e.g. first call in the session).
+#if !WINDOWS_UWP && !WIN_UI
+        if (!MSTestTelemetryDataCollector.IsTelemetryOptedOut())
+        {
+            _ = MSTestTelemetryDataCollector.EnsureInitialized();
+        }
+#endif
+
+        try
+        {
+            if (MSTestDiscovererHelpers.InitializeDiscovery(sources, discoveryContext, logger, configuration, _testSourceHandler))
+            {
+                new UnitTestDiscoverer(_testSourceHandler).DiscoverTests(sources, logger, discoverySink, discoveryContext, isMTP);
+            }
+        }
+        finally
         {
-            new UnitTestDiscoverer(_testSourceHandler).DiscoverTests(sources, logger, discoverySink, discoveryContext, isMTP);
+#if !WINDOWS_UWP && !WIN_UI
+            // Send the discovery telemetry event ('mstest/discovery'). This always runs at the
+            // end of discovery — for discover-only sessions it is the only event; for sessions
+            // where a run follows, MSTestExecutor will send a separate 'mstest/sessionexit' event
+            // carrying assertion usage. Keeping the two events distinct avoids settings/attribute
+            // duplication and lets each event be self-contained.
+            await MSTestTelemetryDataCollector.SendDiscoveryTelemetryAndResetAsync(_telemetrySender).ConfigureAwait(false);
+#endif
         }
     }
 }

src/Adapter/MSTest.TestAdapter/VSTestAdapter/MSTestExecutor.cs

@@ -20,6 +20,9 @@ namespace Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter;
 internal sealed class MSTestExecutor : ITestExecutor
 {
     private readonly CancellationToken _cancellationToken;
+#if !WINDOWS_UWP && !WIN_UI
+    private readonly Func<string, IDictionary<string, object>, Task>? _telemetrySender;
+#endif
 
     /// <summary>
     /// Token for canceling the test run.
@@ -35,10 +38,15 @@ public MSTestExecutor()
         _cancellationToken = CancellationToken.None;
     }
 
-    internal MSTestExecutor(CancellationToken cancellationToken)
+    internal MSTestExecutor(CancellationToken cancellationToken, Func<string, IDictionary<string, object>, Task>? telemetrySender = null)
     {
         TestExecutionManager = new TestExecutionManager();
         _cancellationToken = cancellationToken;
+#if !WINDOWS_UWP && !WIN_UI
+        _telemetrySender = telemetrySender;
+#else
+        _ = telemetrySender;
+#endif
     }
 
     /// <summary>
@@ -119,12 +127,27 @@ internal async Task RunTestsAsync(IEnumerable<TestCase>? tests, IRunContext? run
 
         Ensure.NotEmpty(tests);
 
-        if (!MSTestDiscovererHelpers.InitializeDiscovery(from test in tests select test.Source, runContext, frameworkHandle, configuration, new TestSourceHandler()))
+        // Initialize telemetry collection if not already set
+#if !WINDOWS_UWP && !WIN_UI
+        if (!MSTestTelemetryDataCollector.IsTelemetryOptedOut())
         {
-            return;
+            _ = MSTestTelemetryDataCollector.EnsureInitialized();
         }
+#endif
+
+        try
+        {
+            if (!MSTestDiscovererHelpers.InitializeDiscovery(from test in tests select test.Source, runContext, frameworkHandle, configuration, new TestSourceHandler()))
+            {
+                return;
+            }
 
-        await RunTestsFromRightContextAsync(frameworkHandle, async testRunToken => await TestExecutionManager.RunTestsAsync(tests, runContext, frameworkHandle, testRunToken).ConfigureAwait(false)).ConfigureAwait(false);
+            await RunTestsFromRightContextAsync(frameworkHandle, async testRunToken => await TestExecutionManager.RunTestsAsync(tests, runContext, frameworkHandle, testRunToken).ConfigureAwait(false)).ConfigureAwait(false);
+        }
+        finally
+        {
+            await SendTelemetryAsync().ConfigureAwait(false);
+        }
     }
 
     internal async Task RunTestsAsync(IEnumerable<string>? sources, IRunContext? runContext, IFrameworkHandle? frameworkHandle, IConfiguration? configuration, bool isMTP)
@@ -147,14 +170,29 @@ internal async Task RunTestsAsync(IEnumerable<string>? sources, IRunContext? run
 
         Ensure.NotEmpty(sources);
 
-        TestSourceHandler testSourceHandler = new();
-        if (!MSTestDiscovererHelpers.InitializeDiscovery(sources, runContext, frameworkHandle, configuration, testSourceHandler))
+        // Initialize telemetry collection if not already set
+#if !WINDOWS_UWP && !WIN_UI
+        if (!MSTestTelemetryDataCollector.IsTelemetryOptedOut())
         {
-            return;
+            _ = MSTestTelemetryDataCollector.EnsureInitialized();
         }
+#endif
+
+        try
+        {
+            TestSourceHandler testSourceHandler = new();
+            if (!MSTestDiscovererHelpers.InitializeDiscovery(sources, runContext, frameworkHandle, configuration, testSourceHandler))
+            {
+                return;
+            }
 
-        sources = testSourceHandler.GetTestSources(sources);
-        await RunTestsFromRightContextAsync(frameworkHandle, async testRunToken => await TestExecutionManager.RunTestsAsync(sources, runContext, frameworkHandle, testSourceHandler, isMTP, testRunToken).ConfigureAwait(false)).ConfigureAwait(false);
+            sources = testSourceHandler.GetTestSources(sources);
+            await RunTestsFromRightContextAsync(frameworkHandle, async testRunToken => await TestExecutionManager.RunTestsAsync(sources, runContext, frameworkHandle, testSourceHandler, isMTP, testRunToken).ConfigureAwait(false)).ConfigureAwait(false);
+        }
+        finally
+        {
+            await SendTelemetryAsync().ConfigureAwait(false);
+        }
     }
 
     /// <summary>
@@ -163,6 +201,14 @@ internal async Task RunTestsAsync(IEnumerable<string>? sources, IRunContext? run
     public void Cancel()
         => _testRunCancellationToken?.Cancel();
 
+#if !WINDOWS_UWP && !WIN_UI
+    private Task SendTelemetryAsync()
+        => MSTestTelemetryDataCollector.SendExecutionTelemetryAndResetAsync(_telemetrySender);
+#else
+    private static Task SendTelemetryAsync()
+        => Task.CompletedTask;
+#endif
+
     private async Task RunTestsFromRightContextAsync(IFrameworkHandle frameworkHandle, Func<TestRunCancellationToken, Task> runTestsAction)
     {
         ApartmentState? requestedApartmentState = MSTestSettings.RunConfigurationSettings.ExecutionApartmentState;

src/Adapter/MSTestAdapter.PlatformServices/Discovery/TypeEnumerator.cs

@@ -50,6 +50,17 @@ internal TypeEnumerator(Type type, string assemblyFilePath, ReflectHelper reflec
             return null;
         }
 
+        // Track class-level attributes for telemetry (read Current per call so a session reset
+        // between TypeEnumerator construction and use cannot cause writes to land on an
+        // orphaned collector).
+#if !WINDOWS_UWP && !WIN_UI
+        if (Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.MSTestTelemetryDataCollector.Current is { } telemetryDataCollector)
+        {
+            Attribute[] classAttributes = ReflectHelper.GetCustomAttributesCached(_type);
+            telemetryDataCollector.TrackDiscoveredClass(classAttributes);
+        }
+#endif
+
         // If test class is valid, then get the tests
         return GetTests(warnings);
     }
@@ -151,6 +162,9 @@ internal UnitTestElement GetTestFromMethod(MethodInfo method, bool classDisables
         };
 
         Attribute[] attributes = reflectionOperations.GetCustomAttributesCached(method);
+#if !WINDOWS_UWP && !WIN_UI
+        Microsoft.VisualStudio.TestPlatform.MSTest.TestAdapter.MSTestTelemetryDataCollector.Current?.TrackDiscoveredMethod(attributes);
+#endif
         TestMethodAttribute? testMethodAttribute = null;
         List<string>? workItemIds = null;
 

src/Adapter/MSTestAdapter.PlatformServices/MSTestSettings.Configuration.cs

@@ -59,6 +59,18 @@ internal static void PopulateSettings(IDiscoveryContext? context, IMessageLogger
 
         CurrentSettings = settings;
         RunConfigurationSettings = runConfigurationSettings;
+
+        // Track configuration source for telemetry.
+#if !WINDOWS_UWP && !WIN_UI
+        if (MSTestTelemetryDataCollector.Current is { } telemetry)
+        {
+            telemetry.ConfigurationSource = configuration?["mstest"] is not null
+                ? "testconfig.json"
+                : !StringEx.IsNullOrEmpty(context?.RunSettings?.SettingsXml)
+                    ? "runsettings"
+                    : "none";
+        }
+#endif
     }
 
     private static void SetGlobalSettings(string runsettingsXml, MSTestSettings settings, IMessageLogger? logger)