Add intervallic buffering of OutputEvent messages

This change introduces a new AsyncDebouncer class which is able to gate
invocation requests to only occur after a specified interval.  This class
is used to implement an OutputDebouncer which takes all output messages
written from the PowerShell host and buffers them.  This causes many lines
of output written in a short time window to be sent as one OutputEvent
rather than writing individual events for each line.

Resolves #113.

Author: daviwil

src/PowerShellEditorServices.Protocol/PowerShellEditorServices.Protocol.csproj

@@ -124,6 +124,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="LanguageServer\References.cs" />
     <Compile Include="Server\LanguageServerSettings.cs" />
+    <Compile Include="Server\OutputDebouncer.cs" />
     <Compile Include="Server\PromptHandlers.cs" />
   </ItemGroup>
   <ItemGroup>

src/PowerShellEditorServices.Protocol/Properties/AssemblyInfo.cs

@@ -41,3 +41,4 @@
 [assembly: AssemblyFileVersion("0.0.0.0")]
 [assembly: AssemblyInformationalVersion("0.0.0.0")]
 
+[assembly: InternalsVisibleTo("Microsoft.PowerShell.EditorServices.Test.Protocol")]

src/PowerShellEditorServices.Protocol/Server/DebugAdapter.cs

@@ -6,7 +6,6 @@
 using Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
 using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol.Channel;
-using Microsoft.PowerShell.EditorServices.Protocol.Server;
 using Microsoft.PowerShell.EditorServices.Utility;
 using System;
 using System.Collections.Generic;
@@ -19,6 +18,7 @@ namespace Microsoft.PowerShell.EditorServices.Protocol.Server
     public class DebugAdapter : DebugAdapterBase
     {
         private EditorSession editorSession;
+        private OutputDebouncer outputDebouncer;
 
         public DebugAdapter() : this(new StdioServerChannel())
         {
@@ -30,6 +30,9 @@ public DebugAdapter(ChannelBase serverChannel) : base(serverChannel)
             this.editorSession.StartSession();
             this.editorSession.DebugService.DebuggerStopped += this.DebugService_DebuggerStopped;
             this.editorSession.ConsoleService.OutputWritten += this.powerShellContext_OutputWritten;
+
+            // Set up the output debouncer to throttle output event writes
+            this.outputDebouncer = new OutputDebouncer(this);
         }
 
         protected override void Initialize()
@@ -59,6 +62,9 @@ protected override void Initialize()
 
         protected override void Shutdown()
         {
+            // Make sure remaining output is flushed before exiting
+            this.outputDebouncer.Flush().Wait();
+
             Logger.Write(LogLevel.Normal, "Debug adapter is shutting down...");
 
             if (this.editorSession != null)
@@ -359,6 +365,9 @@ await requestContext.SendResult(
 
         async void DebugService_DebuggerStopped(object sender, DebuggerStopEventArgs e)
         {
+            // Flush pending output before sending the event
+            await this.outputDebouncer.Flush();
+
             await this.SendEvent(
                 StoppedEvent.Type,
                 new StoppedEventBody
@@ -376,13 +385,8 @@ await this.SendEvent(
 
         async void powerShellContext_OutputWritten(object sender, OutputWrittenEventArgs e)
         {
-            await this.SendEvent(
-                OutputEvent.Type,
-                new OutputEventBody
-                {
-                    Output = e.OutputText + (e.IncludeNewLine ? "\r\n" : string.Empty),
-                    Category = (e.OutputType == OutputType.Error) ? "stderr" : "stdout"
-                });
+            // Queue the output for writing
+            await this.outputDebouncer.Invoke(e);
         }
 
         #endregion

src/PowerShellEditorServices.Protocol/Server/LanguageServer.cs

@@ -25,6 +25,7 @@ public class LanguageServer : LanguageServerBase
         private static CancellationTokenSource existingRequestCancellation;
 
         private EditorSession editorSession;
+        private OutputDebouncer outputDebouncer;
         private LanguageServerSettings currentSettings = new LanguageServerSettings();
 
         public LanguageServer() : this(new StdioServerChannel())
@@ -44,6 +45,9 @@ public LanguageServer(ChannelBase serverChannel) : base(serverChannel)
                 new ProtocolPromptHandlerContext(
                     this,
                     this.editorSession.ConsoleService));
+
+            // Set up the output debouncer to throttle output event writes
+            this.outputDebouncer = new OutputDebouncer(this);
         }
 
         protected override void Initialize()
@@ -78,6 +82,9 @@ protected override void Initialize()
 
         protected override void Shutdown()
         {
+            // Make sure remaining output is flushed before exiting
+            this.outputDebouncer.Flush().Wait();
+
             Logger.Write(LogLevel.Normal, "Language service is shutting down...");
 
             if (this.editorSession != null)
@@ -757,13 +764,8 @@ protected Task HandleEvaluateRequest(
 
         async void powerShellContext_OutputWritten(object sender, OutputWrittenEventArgs e)
         {
-            await this.SendEvent(
-                DebugAdapterMessages.OutputEvent.Type,
-                new DebugAdapterMessages.OutputEventBody
-                {
-                    Output = e.OutputText + (e.IncludeNewLine ? "\r\n" : string.Empty),
-                    Category = (e.OutputType == OutputType.Error) ? "stderr" : "stdout"
-                });
+            // Queue the output for writing
+            await this.outputDebouncer.Invoke(e);
         }
 
         #endregion

src/PowerShellEditorServices.Protocol/Server/OutputDebouncer.cs

@@ -0,0 +1,102 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.PowerShell.EditorServices.Protocol.DebugAdapter;
+using Microsoft.PowerShell.EditorServices.Protocol.MessageProtocol;
+using Microsoft.PowerShell.EditorServices.Utility;
+using System.Threading.Tasks;
+
+namespace Microsoft.PowerShell.EditorServices.Protocol.Server
+{
+    /// <summary>
+    /// Throttles output written via OutputEvents by batching all output
+    /// written within a short time window and writing it all out at once.
+    /// </summary>
+    internal class OutputDebouncer : AsyncDebouncer<OutputWrittenEventArgs>
+    {
+        #region Private Fields
+
+        private IMessageSender messageSender;
+        private bool currentOutputIsError = false;
+        private string currentOutputString = null;
+
+        #endregion
+
+        #region Constants
+
+        // Set a really short window for output flushes.  This
+        // gives the appearance of fast output without the crushing
+        // overhead of sending an OutputEvent for every single line
+        // written.  At this point it seems that around 10-20 lines get
+        // batched for each flush when Get-Process is called.
+        public const int OutputFlushInterval = 200;
+
+        #endregion
+
+        #region Constructors
+
+        public OutputDebouncer(IMessageSender messageSender)
+            : base(OutputFlushInterval, false)
+        {
+            this.messageSender = messageSender;
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        protected override async Task OnInvoke(OutputWrittenEventArgs output)
+        {
+            bool outputIsError = output.OutputType == OutputType.Error;
+
+            if (this.currentOutputIsError != outputIsError)
+            {
+                if (this.currentOutputString != null)
+                {
+                    // Flush the output
+                    await this.OnFlush();
+                }
+
+                this.currentOutputString = string.Empty;
+                this.currentOutputIsError = outputIsError;
+            }
+
+            // Output string could be null if the last output was already flushed
+            if (this.currentOutputString == null)
+            {
+                this.currentOutputString = string.Empty;
+            }
+
+            // Add to string (and include newline)
+            this.currentOutputString +=
+                output.OutputText +
+                (output.IncludeNewLine ? 
+                    System.Environment.NewLine :
+                    string.Empty);
+        }
+
+        protected override async Task OnFlush()
+        {
+            // Only flush output if there is some to flush
+            if (this.currentOutputString != null)
+            {
+                // Send an event for the current output
+                await this.messageSender.SendEvent(
+                    OutputEvent.Type,
+                    new OutputEventBody
+                    {
+                        Output = this.currentOutputString,
+                        Category = (this.currentOutputIsError) ? "stderr" : "stdout"
+                    });
+
+                // Clear the output string for the next batch
+                this.currentOutputString = null;
+            }
+        }
+
+        #endregion
+    }
+}
+

src/PowerShellEditorServices/PowerShellEditorServices.csproj

@@ -101,6 +101,7 @@
     <Compile Include="Session\SessionPSHostUserInterface.cs" />
     <Compile Include="Session\SessionStateChangedEventArgs.cs" />
     <Compile Include="Utility\AsyncContextThread.cs" />
+    <Compile Include="Utility\AsyncDebouncer.cs" />
     <Compile Include="Utility\AsyncLock.cs" />
     <Compile Include="Utility\AsyncQueue.cs" />
     <Compile Include="Utility\AsyncContext.cs" />