Improve error handling when invoking IFeatureProvider implementations

This change introduces the FeatureComponentBase class which provides
some helpful behavior for dealing with errors when invoking feature
providers.  The default behavior is to catch and log all exceptions, but
this may be changed later.

Author: daviwil

src/PowerShellEditorServices.Host/CodeLens/CodeLensFeature.cs

@@ -17,21 +17,21 @@
 
 namespace Microsoft.PowerShell.EditorServices.CodeLenses
 {
-    internal class CodeLensFeature : ICodeLenses
+    internal class CodeLensFeature :
+        FeatureComponentBase<ICodeLensProvider>,
+        ICodeLenses
     {
         private EditorSession editorSession;
 
         private JsonSerializer jsonSerializer =
              JsonSerializer.Create(
                  Constants.JsonSerializerSettings);
 
-        public IFeatureProviderCollection<ICodeLensProvider> Providers { get; } =
-            new FeatureProviderCollection<ICodeLensProvider>();
-
         public CodeLensFeature(
             EditorSession editorSession,
             IMessageHandlers messageHandlers,
             ILogger logger)
+                : base(logger)
         {
             this.editorSession = editorSession;
 
@@ -70,8 +70,8 @@ public static CodeLensFeature Create(
         public CodeLens[] ProvideCodeLenses(ScriptFile scriptFile)
         {
             return
-                this.Providers
-                    .SelectMany(p => p.ProvideCodeLenses(scriptFile))
+                this.InvokeProviders(p => p.ProvideCodeLenses(scriptFile))
+                    .SelectMany(r => r)
                     .ToArray();
         }
 
@@ -88,7 +88,7 @@ private async Task HandleCodeLensRequest(
                     codeLensParams.TextDocument.Uri);
 
             var codeLenses =
-               this.ProvideCodeLenses(scriptFile)
+                this.ProvideCodeLenses(scriptFile)
                     .Select(
                         codeLens =>
                             codeLens.ToProtocolCodeLens(

src/PowerShellEditorServices.Host/Symbols/DocumentSymbolFeature.cs

@@ -17,17 +17,17 @@
 
 namespace Microsoft.PowerShell.EditorServices.Symbols
 {
-    internal class DocumentSymbolFeature : IDocumentSymbols
+    internal class DocumentSymbolFeature :
+        FeatureComponentBase<IDocumentSymbolProvider>,
+        IDocumentSymbols
     {
         private EditorSession editorSession;
 
-        public IFeatureProviderCollection<IDocumentSymbolProvider> Providers { get; } =
-            new FeatureProviderCollection<IDocumentSymbolProvider>();
-
         public DocumentSymbolFeature(
             EditorSession editorSession,
             IMessageHandlers messageHandlers,
             ILogger logger)
+                : base(logger)
         {
             this.editorSession = editorSession;
 
@@ -61,9 +61,12 @@ public static DocumentSymbolFeature Create(
             return documentSymbols;
         }
 
-        public IEnumerable<SymbolReference> ProvideDocumentSymbols(ScriptFile scriptFile)
+        public IEnumerable<SymbolReference> ProvideDocumentSymbols(
+            ScriptFile scriptFile)
         {
-            throw new NotImplementedException();
+            return
+                this.InvokeProviders(p => p.ProvideDocumentSymbols(scriptFile))
+                    .SelectMany(r => r);
         }
 
         protected async Task HandleDocumentSymbolRequest(
@@ -75,9 +78,7 @@ protected async Task HandleDocumentSymbolRequest(
                     documentSymbolParams.TextDocument.Uri);
 
             IEnumerable<SymbolReference> foundSymbols =
-                this.Providers
-                    .SelectMany(
-                        provider => provider.ProvideDocumentSymbols(scriptFile));
+                this.ProvideDocumentSymbols(scriptFile);
 
             SymbolInformation[] symbols = null;
 

src/PowerShellEditorServices/Components/FeatureComponentBase.cs

@@ -0,0 +1,127 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.PowerShell.EditorServices.Utility;
+
+namespace Microsoft.PowerShell.EditorServices.Components
+{
+    /// <summary>
+    /// Provides common functionality needed to implement a feature
+    /// component which uses IFeatureProviders to provide further
+    /// extensibility.
+    /// </summary>
+    public abstract class FeatureComponentBase<TProvider>
+        where TProvider : IFeatureProvider
+    {
+        /// <summary>
+        /// Gets the collection of IFeatureProviders registered with
+        /// this feature component.
+        /// </summary>
+        public IFeatureProviderCollection<TProvider> Providers { get; private set; }
+
+        /// <summary>
+        /// Gets the ILogger implementation to use for writing log
+        /// messages.
+        /// </summary>
+        protected ILogger Logger { get; private set; }
+
+        /// <summary>
+        /// Creates an instance of the FeatureComponentBase class with
+        /// the specified ILoggger.
+        /// </summary>
+        /// <param name="logger">The ILogger to use for this instance.</param>
+        public FeatureComponentBase(ILogger logger)
+        {
+            this.Providers = new FeatureProviderCollection<TProvider>();
+            this.Logger = logger;
+        }
+
+        /// <summary>
+        /// Invokes the given function synchronously against all
+        /// registered providers.
+        /// </summary>
+        /// <param name="invokeFunc">The function to be invoked.</param>
+        /// <returns>
+        /// An IEnumerable containing the results of all providers
+        /// that were invoked successfully.
+        /// </returns>
+        protected IEnumerable<TResult> InvokeProviders<TResult>(
+            Func<TProvider, TResult> invokeFunc)
+        {
+            Stopwatch invokeTimer = new Stopwatch();
+            List<TResult> providerResults = new List<TResult>();
+
+            foreach (var provider in this.Providers)
+            {
+                try
+                {
+                    invokeTimer.Restart();
+
+                    providerResults.Add(invokeFunc(provider));
+
+                    invokeTimer.Stop();
+
+                    this.Logger.Write(
+                        LogLevel.Verbose,
+                        $"Invocation of provider '{provider.ProviderId}' completed in {invokeTimer.ElapsedMilliseconds}ms.");
+                }
+                catch (Exception e)
+                {
+                    this.Logger.WriteException(
+                        $"Exception caught while invoking provider {provider.ProviderId}:",
+                        e);
+                }
+            }
+
+            return providerResults;
+        }
+
+        /// <summary>
+        /// Invokes the given function asynchronously against all
+        /// registered providers.
+        /// </summary>
+        /// <param name="invokeFunc">The function to be invoked.</param>
+        /// <returns>
+        /// A Task that, when completed, returns an IEnumerable containing
+        /// the results of all providers that were invoked successfully.
+        /// </returns>
+        protected async Task<IEnumerable<TResult>> InvokeProvidersAsync<TResult>(
+            Func<TProvider, Task<TResult>> invokeFunc)
+        {
+            Stopwatch invokeTimer = new Stopwatch();
+            List<TResult> providerResults = new List<TResult>();
+
+            foreach (var provider in this.Providers)
+            {
+                try
+                {
+                    invokeTimer.Restart();
+
+                    providerResults.Add(
+                        await invokeFunc(provider));
+
+                    invokeTimer.Stop();
+
+                    this.Logger.Write(
+                        LogLevel.Verbose,
+                        $"Invocation of provider '{provider.ProviderId}' completed in {invokeTimer.ElapsedMilliseconds}ms.");
+                }
+                catch (Exception e)
+                {
+                    this.Logger.WriteException(
+                        $"Exception caught while invoking provider {provider.ProviderId}:",
+                        e);
+                }
+            }
+
+            return providerResults;
+        }
+    }
+}