Improve the logging error handling in our ServiceHub MEF creation (#80124)

This improves some logging and handling in error situations for our
ServiceHub MEF creation. **Review commit-at-a-time.**

Author: jasonmalinowski

src/Deployment/Properties/launchSettings.json

@@ -10,7 +10,7 @@
       "executablePath": "$(DevEnvDir)devenv.exe",
       "commandLineArgs": "/rootsuffix $(VSSDKTargetPlatformRegRootSuffix) /log",
       "environmentVariables": {
-        "SERVICEHUBDEBUGHOSTONSTARTUP": "All"
+        "SERVICEHUBDEBUGHOSTONSTARTUP": "ServiceHub.RoslynCodeAnalysisService.exe"
       }
     },
     "Visual Studio Extension (with Native Debugging)": {

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/LanguageServerExportProviderBuilder.cs

@@ -74,8 +74,8 @@ public static async Task<ExportProvider> CreateExportProviderAsync(
         return exportProvider;
     }
 
-    protected override void LogError(string message)
-        => _logger.LogError(message);
+    protected override void LogError(string message, Exception exception)
+        => _logger.LogError(exception, message);
 
     protected override void LogTrace(string message)
         => _logger.LogTrace(message);

src/VisualStudio/Core/Def/ErrorReporting/VisualStudioErrorReportingService.cs

@@ -49,11 +49,17 @@ public void ShowGlobalErrorInfo(string message, TelemetryFeatureName featureName
         LogGlobalErrorToActivityLog(message, stackTrace);
         _infoBar.ShowInfoBarMessageFromAnyThread(message, items);
 
-        Logger.Log(FunctionId.VS_ErrorReportingService_ShowGlobalErrorInfo, KeyValueLogMessage.Create(LogType.UserAction, static (m, args) =>
+        Logger.Log(FunctionId.VS_ErrorReportingService_ShowGlobalErrorInfo, KeyValueLogMessage.Create(LogType.UserAction, (m, args) =>
         {
             var (message, featureName) = args;
             m["Message"] = message;
             m["FeatureName"] = featureName.ToString();
+
+            if (exception is not null)
+            {
+                m["ExceptionType"] = exception.GetType().Name;
+                m["ExceptionStackTrace"] = stackTrace;
+            }
         }, (message, featureName)));
     }
 

src/Workspaces/Remote/Core/ExportProviderBuilder.cs

@@ -32,7 +32,7 @@ internal abstract class ExportProviderBuilder(
     protected string CacheDirectory { get; } = cacheDirectory;
     protected string CatalogPrefix { get; } = catalogPrefix;
 
-    protected abstract void LogError(string message);
+    protected abstract void LogError(string message, Exception exception);
     protected abstract void LogTrace(string message);
 
     protected virtual async Task<ExportProvider> CreateExportProviderAsync(CancellationToken cancellationToken)
@@ -69,7 +69,7 @@ private async Task<IExportProviderFactory> GetCompositionConfigurationAsync(Canc
         catch (Exception ex)
         {
             // Log the error, and move on to recover by recreating the MEF composition.
-            LogError($"Loading cached MEF composition failed: {ex}");
+            LogError("Loading cached MEF composition failed", ex);
         }
 
         LogTrace($"Composing MEF catalog using:{Environment.NewLine}{string.Join($"    {Environment.NewLine}", AssemblyPaths)}.");
@@ -165,7 +165,7 @@ protected virtual async Task WriteCompositionCacheAsync(string compositionCacheF
         }
         catch (Exception ex)
         {
-            LogError($"Failed to save MEF cache: {ex}");
+            LogError("Failed to save MEF cache", ex);
         }
     }
 
@@ -191,11 +191,11 @@ private bool CheckForAndReportCompositionErrors(CompositionConfiguration configu
         foreach (var exception in catalog.DiscoveredParts.DiscoveryErrors)
         {
             hasErrors = true;
-            LogError($"Encountered exception in the MEF composition: {exception.Message}");
+            LogError("Encountered exception in the MEF composition", exception);
         }
 
         // Verify that we have exactly the MEF errors that we expect.  If we have less or more this needs to be updated to assert the expected behavior.
-        var erroredParts = configuration.CompositionErrors.FirstOrDefault()?.SelectMany(error => error.Parts).Select(part => part.Definition.Type.Name) ?? [];
+        var erroredParts = configuration.CompositionErrors.SelectMany(c => c).SelectMany(error => error.Parts).Select(part => part.Definition.Type.Name);
 
         if (ContainsUnexpectedErrors(erroredParts))
         {
@@ -208,7 +208,7 @@ private bool CheckForAndReportCompositionErrors(CompositionConfiguration configu
             catch (CompositionFailedException ex)
             {
                 // The ToString for the composition failed exception doesn't output a nice set of errors by default, so log it separately
-                LogError($"Encountered errors in the MEF composition: {ex.Message}{Environment.NewLine}{ex.ErrorsAsString}");
+                LogError($"Encountered errors in the MEF composition:{Environment.NewLine}{ex.ErrorsAsString}", ex);
             }
         }
 

src/Workspaces/Remote/ServiceHub/Host/RemoteExportProviderBuilder.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -35,42 +36,61 @@ internal static ExportProvider ExportProvider
         => s_instance ?? throw new InvalidOperationException($"Default export provider not initialized. Call {nameof(InitializeAsync)} first.");
 
     private StringBuilder? _errorMessages;
+    private readonly TraceSource _traceLogger;
 
     private RemoteExportProviderBuilder(
         ImmutableArray<string> assemblyPaths,
         Resolver resolver,
         string cacheDirectory,
-        string catalogPrefix)
+        string catalogPrefix,
+        TraceSource traceLogger)
         : base(assemblyPaths, resolver, cacheDirectory, catalogPrefix)
     {
+        _traceLogger = traceLogger;
     }
 
-    public static async Task<string?> InitializeAsync(string localSettingsDirectory, CancellationToken cancellationToken)
+    public static async Task<string?> InitializeAsync(string localSettingsDirectory, TraceSource traceLogger, CancellationToken cancellationToken)
     {
-        var assemblyPaths = RemoteHostAssemblyNames
-            .Select(static assemblyName => MefHostServicesHelpers.TryFindNearbyAssemblyLocation(assemblyName))
-            .WhereNotNull()
-            .AsImmutable();
+        var assemblyPaths = ImmutableArray.CreateBuilder<string>(initialCapacity: RemoteHostAssemblyNames.Length);
+
+        foreach (var assemblyName in RemoteHostAssemblyNames)
+        {
+            var assemblyPath = MefHostServicesHelpers.TryFindNearbyAssemblyLocation(assemblyName);
+            if (assemblyPath != null)
+            {
+                assemblyPaths.Add(assemblyPath);
+                traceLogger.TraceInformation($"Located {assemblyPath} for the MEF composition.");
+            }
+            else
+            {
+                traceLogger.TraceEvent(TraceEventType.Warning, 0, $"Could not find assembly '{assemblyName}' near '{typeof(MefHostServicesHelpers).Assembly.Location}'");
+            }
+        }
 
         var builder = new RemoteExportProviderBuilder(
-            assemblyPaths: assemblyPaths,
+            assemblyPaths: assemblyPaths.ToImmutable(),
             resolver: new Resolver(SimpleAssemblyLoader.Instance),
             cacheDirectory: Path.Combine(localSettingsDirectory, "Roslyn", "RemoteHost", "Cache"),
-            catalogPrefix: "RoslynRemoteHost");
+            catalogPrefix: "RoslynRemoteHost",
+            traceLogger);
 
         s_instance = await builder.CreateExportProviderAsync(cancellationToken).ConfigureAwait(false);
 
         return builder._errorMessages?.ToString();
     }
 
-    protected override void LogError(string message)
+    protected override void LogError(string message, Exception exception)
     {
+        // We'll log just the message to _errorMessages (since that gets displayed to the user in a gold bar), but we'll log the
+        // full exception to the logger.
         _errorMessages ??= new StringBuilder();
-        _errorMessages.AppendLine(message);
+        _errorMessages.AppendLine($"{message}: {exception.Message}");
+        _traceLogger.TraceEvent(TraceEventType.Error, 0, $"{message}: {exception}");
     }
 
     protected override void LogTrace(string message)
     {
+        _traceLogger.TraceEvent(TraceEventType.Information, 0, message);
     }
 
     protected override bool ContainsUnexpectedErrors(IEnumerable<string> erroredParts)

src/Workspaces/Remote/ServiceHub/Services/Initialization/RemoteInitializationService.cs

@@ -2,11 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.Remote;
 
@@ -24,16 +24,26 @@ protected override IRemoteInitializationService CreateService(in ServiceConstruc
     {
         // Performed before RunServiceAsync to ensure that the export provider is initialized before the RemoteWorkspaceManager is created
         // as part of the RunServiceAsync call.
-        var errorMessage = await RemoteExportProviderBuilder.InitializeAsync(localSettingsDirectory, cancellationToken).ConfigureAwait(false);
+        var errorMessage = await RemoteExportProviderBuilder.InitializeAsync(localSettingsDirectory, TraceLogger, cancellationToken).ConfigureAwait(false);
 
-        var processId = await RunServiceAsync(cancellationToken =>
+        try
         {
-            var service = (RemoteWorkspaceConfigurationService)GetWorkspaceServices().GetRequiredService<IWorkspaceConfigurationService>();
-            service.InitializeOptions(options);
+            var processId = await RunServiceAsync(cancellationToken =>
+            {
+                var service = (RemoteWorkspaceConfigurationService)GetWorkspaceServices().GetRequiredService<IWorkspaceConfigurationService>();
+                service.InitializeOptions(options);
 
-            return ValueTask.FromResult(Process.GetCurrentProcess().Id);
-        }, cancellationToken).ConfigureAwait(false);
+                return ValueTask.FromResult(Process.GetCurrentProcess().Id);
+            }, cancellationToken).ConfigureAwait(false);
 
-        return (processId, errorMessage);
+            return (processId, errorMessage);
+        }
+        catch (Exception ex) when (errorMessage != null)
+        {
+            // We want to throw the exception but also include the message from the MEF creation
+            throw new AggregateException(
+                $"Error from {nameof(RemoteExportProviderBuilder)}: {errorMessage}",
+                ex);
+        }
     }
 }