Decouple the log levels for our two output windows

Prior to moving things to LogOutputChannels, we implicitly controlled
the log level of the LSP traces by the log level of our main output
channel: as long as that was debug or trace, we'd also output the LSP
traces. Now each channel behaves independently, with the requirement
that if you want LSP tracing, you must set the trace channel to 'trace'
level. The other settings don't do anything.

Author: jasonmalinowski

src/lsptoolshost/server/roslynLanguageServer.ts

@@ -127,9 +127,10 @@ export class RoslynLanguageServer {
         private _context: vscode.ExtensionContext,
         private _telemetryReporter: TelemetryReporter,
         private _languageServerEvents: RoslynLanguageServerEvents,
-        private _channel: vscode.LogOutputChannel
+        private _channel: vscode.LogOutputChannel,
+        private _traceChannel: vscode.LogOutputChannel
     ) {
-        this.registerSetTrace();
+        this.registerOutputChannelsChangeHandlers();
         this.registerSendOpenSolution();
         this.registerProjectInitialization();
         this.registerServerStateChanged();
@@ -164,29 +165,41 @@ export class RoslynLanguageServer {
         return RoslynLanguageServer._processId;
     }
 
-    private registerSetTrace() {
-        // Set the language client trace level based on the log level option.
-        // setTrace only works after the client is already running.
+    private registerOutputChannelsChangeHandlers() {
         this._languageClient.onDidChangeState(async (state) => {
             if (state.newState === State.Running) {
-                await this.updateLogLevel();
+                await this.updateOutputChannelLogLevel();
+                await this.updateTraceChannelLogLevel();
             }
         });
         // Register for changes to the log level.
         this._channel.onDidChangeLogLevel(async () => {
-            await this.updateLogLevel();
+            await this.updateOutputChannelLogLevel();
+        });
+        this._traceChannel.onDidChangeLogLevel(async () => {
+            // The LSP client also responds to didChangeLogLevel and sets its own logic; we want to override that so do a small delay
+            setTimeout(async () => {
+                await this.updateTraceChannelLogLevel();
+            }, 1);
         });
     }
 
-    private async updateLogLevel(): Promise<void> {
+    private async updateOutputChannelLogLevel(): Promise<void> {
         if (this._languageClient.state === State.Running) {
-            const languageClientTraceLevel = RoslynLanguageServer.GetTraceLevel(this._channel.logLevel);
             // Update the server's log level.
             await this.sendNotification('roslyn/updateLogLevel', {
                 logLevel: RoslynLanguageServer.GetServerLogLevel(this._channel.logLevel),
             });
-            // Update the trace level that the client uses to log trace messages.
-            await this._languageClient.setTrace(languageClientTraceLevel);
+        }
+    }
+
+    private async updateTraceChannelLogLevel(): Promise<void> {
+        if (this._languageClient.state === State.Running) {
+            await this._languageClient.setTrace(
+                // If the logLevel is set to trace, we want to have verbose tracing. All tracing from the LSP client is done at 'trace' level,
+                // so we can't show tracing at any other output window levels, since it just gets filtered away.
+                this._traceChannel.logLevel == vscode.LogLevel.Trace ? Trace.Verbose : Trace.Off
+            );
         }
     }
 
@@ -329,7 +342,8 @@ export class RoslynLanguageServer {
             context,
             telemetryReporter,
             languageServerEvents,
-            channel
+            channel,
+            traceChannel
         );
 
         client.registerFeature(server._onAutoInsertFeature);
@@ -1102,25 +1116,6 @@ export class RoslynLanguageServer {
         }
     }
 
-    private static GetTraceLevel(logLevel: vscode.LogLevel): Trace {
-        switch (logLevel) {
-            case vscode.LogLevel.Trace:
-                return Trace.Verbose;
-            case vscode.LogLevel.Debug:
-                return Trace.Messages;
-            case vscode.LogLevel.Info:
-                return Trace.Off;
-            case vscode.LogLevel.Warning:
-                return Trace.Off;
-            case vscode.LogLevel.Error:
-                return Trace.Off;
-            case vscode.LogLevel.Off:
-                return Trace.Off;
-            default:
-                throw new Error(`Invalid log level ${logLevel}`);
-        }
-    }
-
     public async getBuildOnlyDiagnosticIds(token: vscode.CancellationToken): Promise<string[]> {
         // If the server isn't running, no build diagnostics to get
         if (!this.isRunning()) {