Allow writing to different sourcekit output channels (#883)

Issue: #833

IFF sourcekit logMessage notification includes a logName property, we'll use a different output channel to not polute the langauge server's main log. For a known list of logs we'll set them up on startup so we can control if the log level and/or timestamp is included in the log message. For the current known indexing log, for example, all messages will be "Info" so we'll just add timestamp. If new logs are introduced, we'll show log level and timestamp by default

Author: award999

src/sourcekit-lsp/LSPOutputChannel.ts

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the VS Code Swift open source project
+//
+// Copyright (c) 2024 the VS Code Swift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of VS Code Swift project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import * as vscode from "vscode";
+
+export interface LSPLogger {
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+
+export class LSPOutputChannel implements LSPLogger {
+    private _channel: vscode.OutputChannel | undefined;
+
+    constructor(
+        private name: string,
+        private includeLogLevel: boolean = true,
+        private includeTimestamp: boolean = true
+    ) {}
+
+    private get channel(): vscode.OutputChannel {
+        if (!this._channel) {
+            this._channel = vscode.window.createOutputChannel(this.name);
+        }
+        return this._channel;
+    }
+
+    dispose() {
+        this._channel?.dispose();
+        this._channel = undefined;
+    }
+
+    debug(message: string) {
+        this.logOutputMessage("Debug", message);
+    }
+
+    info(message: string) {
+        this.logOutputMessage("Info", message);
+    }
+
+    warn(message: string) {
+        this.logOutputMessage("Warn", message);
+    }
+
+    error(message: string) {
+        this.logOutputMessage("Error", message);
+    }
+
+    logOutputMessage(logLevel: string, message: string) {
+        let formatted = "";
+        if (this.includeLogLevel) {
+            formatted = (formatted || "[") + logLevel.padEnd(5);
+        }
+        if (this.includeTimestamp) {
+            formatted += formatted ? " - " : "[";
+            formatted += new Date().toLocaleTimeString();
+        }
+        formatted += formatted ? "] " : " ";
+        formatted += message;
+        this.channel.appendLine(formatted);
+    }
+}

src/sourcekit-lsp/LanguageClientManager.ts

@@ -24,11 +24,19 @@ import { FolderContext } from "../FolderContext";
 import { LanguageClient } from "vscode-languageclient/node";
 import { ArgumentFilter, BuildFlags } from "../toolchain/BuildFlags";
 import { DiagnosticsManager } from "../DiagnosticsManager";
+import { LSPLogger, LSPOutputChannel } from "./LSPOutputChannel";
+
+interface SourceKitLogMessageParams extends langclient.LogMessageParams {
+    logName?: string;
+}
 
 /** Manages the creation and destruction of Language clients as we move between
  * workspace folders
  */
 export class LanguageClientManager {
+    // known log names
+    static indexingLogName = "SourceKit-LSP: Indexing";
+
     // document selector used by language client
     static appleLangDocumentSelector = [
         { scheme: "file", language: "swift" },
@@ -112,6 +120,7 @@ export class LanguageClientManager {
     // used by single server support to keep a record of the project folders
     // that are not at the root of their workspace
     public subFolderWorkspaces: vscode.Uri[];
+    private namedOutputChannels: Map<string, LSPOutputChannel> = new Map();
     /** Get the current state of the underlying LanguageClient */
     public get state(): langclient.State {
         if (!this.languageClient) {
@@ -121,6 +130,10 @@ export class LanguageClientManager {
     }
 
     constructor(public workspaceContext: WorkspaceContext) {
+        this.namedOutputChannels.set(
+            LanguageClientManager.indexingLogName,
+            new LSPOutputChannel(LanguageClientManager.indexingLogName, false, true)
+        );
         this.singleServerSupport = workspaceContext.swiftVersion.isGreaterThanOrEqual(
             new Version(5, 7, 0)
         );
@@ -232,6 +245,7 @@ export class LanguageClientManager {
         this.legacyInlayHints?.dispose();
         this.subscriptions.forEach(item => item.dispose());
         this.languageClient?.stop();
+        this.namedOutputChannels.forEach(channel => channel.dispose());
     }
 
     /**
@@ -556,6 +570,10 @@ export class LanguageClientManager {
             this.workspaceContext.outputChannel.log(`SourceKit-LSP setup`);
         }
 
+        client.onNotification(langclient.LogMessageNotification.type, params => {
+            this.logMessage(client, params as SourceKitLogMessageParams);
+        });
+
         // start client
         this.clientReadyPromise = client
             .start()
@@ -578,6 +596,34 @@ export class LanguageClientManager {
 
         return this.clientReadyPromise;
     }
+
+    private logMessage(client: langclient.LanguageClient, params: SourceKitLogMessageParams) {
+        let logger: LSPLogger = client;
+        if (params.logName) {
+            const outputChannel =
+                this.namedOutputChannels.get(params.logName) ??
+                new LSPOutputChannel(params.logName);
+            this.namedOutputChannels.set(params.logName, outputChannel);
+            logger = outputChannel;
+        }
+        switch (params.type) {
+            case langclient.MessageType.Info:
+                logger.info(params.message);
+                break;
+            case langclient.MessageType.Debug:
+                logger.debug(params.message);
+                break;
+            case langclient.MessageType.Warning:
+                logger.warn(params.message);
+                break;
+            case langclient.MessageType.Error:
+                logger.error(params.message);
+                break;
+            case langclient.MessageType.Log:
+                logger.info(params.message);
+                break;
+        }
+    }
 }
 
 /**