Make fetching of logging stuff cheaper

We were previously realizing the workspace and then reading in all the
FunctionIds to see if we should log each of those. We can do that from
the global option service directory (avoiding having to touch the
Workspace) and also not doing that until we actually need to. In most
cases ETW is off so we shouldn't even be looking at all.

src/Test/Diagnostics/DiagnosticOnly_Logger.cs

@@ -42,7 +42,7 @@ public static void ResetLogger()
         /// <summary>
         /// let one such as ETA to set logger for the service layer
         /// </summary>
-        internal static void SetLogger(IOptionService optionsService, string loggerName)
+        internal static void SetLogger(IGlobalOptionService optionsService, string loggerName)
         {
             if (loggerName == null)
             {
@@ -90,12 +90,12 @@ private static FunctionId GetFunctionId(string functionId)
             return (FunctionId)Enum.Parse(typeof(FunctionId), functionId);
         }
 
-        private static ILogger GetLogger(IOptionService optionsService, string loggerName)
+        private static ILogger GetLogger(IGlobalOptionService optionsService, string loggerName)
         {
             switch (loggerName)
             {
                 case "EtwLogger":
-                    return new EtwLogger(Logger.GetLoggingChecker(optionsService));
+                    return new EtwLogger(optionsService);
                 case "TraceLogger":
                     return new TraceLogger(Logger.GetLoggingChecker(optionsService));
                 default:

src/Test/Diagnostics/TraceLogger.cs

@@ -22,7 +22,7 @@ public TraceLogger()
         {
         }
 
-        public TraceLogger(IOptionService optionService)
+        public TraceLogger(IGlobalOptionService optionService)
             : this(Logger.GetLoggingChecker(optionService))
         {
         }

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

@@ -17,17 +17,13 @@ internal class RoslynTelemetrySetup : IRoslynTelemetrySetup
         public void Initialize(IServiceProvider serviceProvider)
         {
             var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
-            var workspace = componentModel.GetService<VisualStudioWorkspace>();
-
-            // set initial logger
-            var optionService = workspace.Services.GetService<IOptionService>();
-            var loggingChecker = Logger.GetLoggingChecker(optionService);
+            var optionService = componentModel.GetService<IGlobalOptionService>();
 
             var telemetryService = serviceProvider.GetService(typeof(SVsTelemetryService)) as IVsTelemetryService;
             Logger.SetLogger(
                 AggregateLogger.Create(
                     CodeMarkerLogger.Instance,
-                    new EtwLogger(loggingChecker),
+                    new EtwLogger(optionService),
                     new VSTelemetryLogger(telemetryService),
                     new VSTelemetryActivityLogger(telemetryService),
                     Logger.GetLogger()));

src/VisualStudio/VisualStudioDiagnosticsToolWindow/OptionPages/PerformanceLoggersPage.cs

@@ -14,7 +14,7 @@ namespace Roslyn.VisualStudio.DiagnosticsWindow.OptionsPages
     [Guid(Guids.RoslynOptionPagePerformanceLoggersIdString)]
     internal class PerformanceLoggersPage : AbstractOptionPage
     {
-        private IOptionService _optionService;
+        private IGlobalOptionService _optionService;
 
         protected override AbstractOptionPageControl CreateOptionPage(IServiceProvider serviceProvider)
         {
@@ -22,8 +22,7 @@ protected override AbstractOptionPageControl CreateOptionPage(IServiceProvider s
             {
                 var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
 
-                var workspace = componentModel.GetService<VisualStudioWorkspace>();
-                _optionService = workspace.Services.GetService<IOptionService>();
+                _optionService = componentModel.GetService<IGlobalOptionService>();
             }
 
             return new InternalOptionsControl(nameof(LoggerOptions), serviceProvider);

src/Workspaces/Core/Desktop/Log/EtwLogger.cs

@@ -12,25 +12,25 @@ namespace Microsoft.CodeAnalysis.Internal.Log
     /// </summary>
     internal sealed class EtwLogger : ILogger
     {
-        private readonly Func<FunctionId, bool> _loggingChecker;
+        private readonly Lazy<Func<FunctionId, bool>> _loggingChecker;
 
         // Due to ETW specifics, RoslynEventSource.Instance needs to be initialized during EtwLogger construction 
         // so that we can enable the listeners synchronously before any events are logged.
         private readonly RoslynEventSource _source = RoslynEventSource.Instance;
 
-        public EtwLogger(IOptionService optionService)
-            : this(Logger.GetLoggingChecker(optionService))
+        public EtwLogger(IGlobalOptionService optionService)
         {
+            _loggingChecker = new Lazy<Func<FunctionId, bool>>(() => Logger.GetLoggingChecker(optionService));
         }
 
         public EtwLogger(Func<FunctionId, bool> loggingChecker)
         {
-            _loggingChecker = loggingChecker;
+            _loggingChecker = new Lazy<Func<FunctionId, bool>>(() => loggingChecker);
         }
 
         public bool IsEnabled(FunctionId functionId)
         {
-            return _source.IsEnabled() && (_loggingChecker == null || _loggingChecker(functionId));
+            return _source.IsEnabled() && _loggingChecker.Value(functionId);
         }
 
         public void Log(FunctionId functionId, LogMessage logMessage)

src/Workspaces/Core/Portable/Log/Logger.cs

@@ -340,7 +340,7 @@ public static IDisposable LogBlock(FunctionId functionId, LogMessage logMessage,
             return CreateLogBlock(functionId, logMessage, GetNextUniqueBlockId(), token);
         }
 
-        public static Func<FunctionId, bool> GetLoggingChecker(IOptionService optionService)
+        public static Func<FunctionId, bool> GetLoggingChecker(IGlobalOptionService optionService)
         {
             var functionIds = Enum.GetValues(typeof(FunctionId)).Cast<FunctionId>();
             var functionIdOptions = functionIds.ToDictionary(id => id, id => optionService.GetOption(FunctionIdOptions.GetOption(id)));