Wait for solution to be loaded before initializing remote telemetry

src/VisualStudio/Core/Def/ProjectSystem/VisualStudioWorkspaceImpl.cs

@@ -209,21 +209,18 @@ public async Task InitializeUIAffinitizedServicesAsync(IAsyncServiceProvider asy
             _memoryListener = memoryListener;
         }
 
-        await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
-
-        // This must be called after the _openFileTracker was assigned; this way we know that a file added from the project system either got checked
-        // in CheckForAddedFileBeingOpenMaybeAsync, or we catch it here.
-        openFileTracker.CheckForOpenFilesThatWeMissed();
-
-        // Switch to a background thread to avoid loading option providers on UI thread (telemetry is reading options).
-        await TaskScheduler.Default;
-
         var logDelta = _globalOptions.GetOption(DiagnosticOptionsStorage.LogTelemetryForBackgroundAnalyzerExecution);
         var telemetryService = (VisualStudioWorkspaceTelemetryService)Services.GetRequiredService<IWorkspaceTelemetryService>();
         telemetryService.InitializeTelemetrySession(telemetrySession, logDelta);
 
         Logger.Log(FunctionId.Run_Environment,
             KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
+
+        await _threadingContext.JoinableTaskFactory.SwitchToMainThreadAsync(_threadingContext.DisposalToken);
+
+        // This must be called after the _openFileTracker was assigned; this way we know that a file added from the project system either got checked
+        // in CheckForAddedFileBeingOpenMaybeAsync, or we catch it here.
+        openFileTracker.CheckForOpenFilesThatWeMissed();
     }
 
     public Task CheckForAddedFileBeingOpenMaybeAsync(bool useAsync, ImmutableArray<string> newFileNames)

src/VisualStudio/Core/Def/Telemetry/AbstractWorkspaceTelemetryService.cs

@@ -4,6 +4,8 @@
 
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Telemetry;
@@ -18,7 +20,8 @@ internal abstract class AbstractWorkspaceTelemetryService : IWorkspaceTelemetryS
 
     protected abstract ILogger CreateLogger(TelemetrySession telemetrySession, bool logDelta);
 
-    public void InitializeTelemetrySession(TelemetrySession telemetrySession, bool logDelta)
+    public void InitializeTelemetrySession(
+        TelemetrySession telemetrySession, bool logDelta)
     {
         Contract.ThrowIfFalse(CurrentSession is null);
 

src/VisualStudio/Core/Def/Telemetry/VisualStudioWorkspaceTelemetryService.cs

@@ -5,9 +5,10 @@
 using System;
 using System.Composition;
 using System.Diagnostics;
-using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Options;
@@ -19,20 +20,16 @@
 namespace Microsoft.VisualStudio.LanguageServices.Telemetry;
 
 [ExportWorkspaceService(typeof(IWorkspaceTelemetryService)), Shared]
-internal sealed class VisualStudioWorkspaceTelemetryService : AbstractWorkspaceTelemetryService
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class VisualStudioWorkspaceTelemetryService(
+    IThreadingContext threadingContext,
+    VisualStudioWorkspace workspace,
+    IGlobalOptionService globalOptions) : AbstractWorkspaceTelemetryService
 {
-    private readonly VisualStudioWorkspace _workspace;
-    private readonly IGlobalOptionService _globalOptions;
-
-    [ImportingConstructor]
-    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-    public VisualStudioWorkspaceTelemetryService(
-        VisualStudioWorkspace workspace,
-        IGlobalOptionService globalOptions)
-    {
-        _workspace = workspace;
-        _globalOptions = globalOptions;
-    }
+    private readonly IThreadingContext _threadingContext = threadingContext;
+    private readonly VisualStudioWorkspace _workspace = workspace;
+    private readonly IGlobalOptionService _globalOptions = globalOptions;
 
     protected override ILogger CreateLogger(TelemetrySession telemetrySession, bool logDelta)
         => AggregateLogger.Create(
@@ -44,24 +41,26 @@ protected override ILogger CreateLogger(TelemetrySession telemetrySession, bool
 
     protected override void TelemetrySessionInitialized()
     {
+        var cancellationToken = _threadingContext.DisposalToken;
         _ = Task.Run(async () =>
         {
-            var client = await RemoteHostClient.TryGetClientAsync(_workspace, CancellationToken.None).ConfigureAwait(false);
+            var client = await RemoteHostClient.TryGetClientAsync(_workspace, cancellationToken).ConfigureAwait(false);
             if (client == null)
-            {
                 return;
-            }
 
             var settings = SerializeCurrentSessionSettings();
             Contract.ThrowIfNull(settings);
 
             // Only log "delta" property for block end events if feature flag is enabled.
             var logDelta = _globalOptions.GetOption(DiagnosticOptionsStorage.LogTelemetryForBackgroundAnalyzerExecution);
 
+            var statusService = _workspace.Services.GetRequiredService<IWorkspaceStatusService>();
+            await statusService.WaitUntilFullyLoadedAsync(cancellationToken).ConfigureAwait(false);
+
             // initialize session in the remote service
             _ = await client.TryInvokeAsync<IRemoteProcessTelemetryService>(
                 (service, cancellationToken) => service.InitializeTelemetrySessionAsync(Process.GetCurrentProcess().Id, settings, logDelta, cancellationToken),
-                CancellationToken.None).ConfigureAwait(false);
-        });
+                cancellationToken).ConfigureAwait(false);
+        }, cancellationToken);
     }
 }

src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteProcessTelemetryService.cs

@@ -21,7 +21,9 @@
 
 namespace Microsoft.CodeAnalysis.Remote;
 
-internal sealed partial class RemoteProcessTelemetryService : BrokeredServiceBase, IRemoteProcessTelemetryService
+internal sealed partial class RemoteProcessTelemetryService(
+    BrokeredServiceBase.ServiceConstructionArguments arguments)
+    : BrokeredServiceBase(arguments), IRemoteProcessTelemetryService
 {
     internal sealed class Factory : FactoryBase<IRemoteProcessTelemetryService>
     {
@@ -33,12 +35,6 @@ protected override IRemoteProcessTelemetryService CreateService(in ServiceConstr
 
 #pragma warning disable IDE0052 // Remove unread private members
     private PerformanceReporter? _performanceReporter;
-#pragma warning restore
-
-    public RemoteProcessTelemetryService(ServiceConstructionArguments arguments)
-        : base(arguments)
-    {
-    }
 
     /// <summary>
     /// Remote API. Initializes ServiceHub process global state.

src/Workspaces/Remote/ServiceHub/Services/ProcessTelemetry/RemoteWorkspaceTelemetryService.cs

@@ -12,14 +12,10 @@
 namespace Microsoft.VisualStudio.LanguageServices.Telemetry;
 
 [ExportWorkspaceService(typeof(IWorkspaceTelemetryService)), Shared]
-internal sealed class RemoteWorkspaceTelemetryService : AbstractWorkspaceTelemetryService
+[method: ImportingConstructor]
+[method: Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
+internal sealed class RemoteWorkspaceTelemetryService() : AbstractWorkspaceTelemetryService
 {
-    [ImportingConstructor]
-    [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-    public RemoteWorkspaceTelemetryService()
-    {
-    }
-
     protected override ILogger CreateLogger(TelemetrySession telemetrySession, bool logDelta)
         => AggregateLogger.Create(
             TelemetryLogger.Create(telemetrySession, logDelta),