Implement LogOutputChannel and move settings to UI

JustinGrote · JustinGrote · commit fe5ea7f53a6b · 2024-10-18T16:27:30.000-07:00
diff --git a/src/extension.ts b/src/extension.ts
@@ -22,7 +22,7 @@ import { ShowHelpFeature } from "./features/ShowHelp";
 import { SpecifyScriptArgsFeature } from "./features/DebugSession";
 import { Logger } from "./logging";
 import { SessionManager } from "./session";
-import { LogLevel, getSettings } from "./settings";
+import { getSettings } from "./settings";
 import { PowerShellLanguageId } from "./utils";
 import { LanguageClientConsumer } from "./languageClientConsumer";
 
@@ -47,9 +47,8 @@ const documentSelector: DocumentSelector = [
 ];
 
 export async function activate(context: vscode.ExtensionContext): Promise<IPowerShellExtensionClient> {
-    const logLevel = vscode.workspace.getConfiguration(`${PowerShellLanguageId}.developer`)
-        .get<string>("editorServicesLogLevel", LogLevel.Normal);
-    logger = new Logger(logLevel, context.globalStorageUri);
+    // This is the output channel for the PowerShell extension
+    logger = new Logger(context.globalStorageUri);
 
     telemetryReporter = new TelemetryReporter(TELEMETRY_KEY);
 
diff --git a/src/logging.ts b/src/logging.ts
@@ -1,26 +1,15 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-import utils = require("./utils");
 import os = require("os");
-import vscode = require("vscode");
-
-// NOTE: This is not a string enum because the order is used for comparison.
-export enum LogLevel {
-    Diagnostic,
-    Verbose,
-    Normal,
-    Warning,
-    Error,
-    None,
-}
+import { sleep, checkIfFileExists } from "./utils";
+import { LogOutputChannel, Uri, Disposable, LogLevel, window, env, commands, workspace } from "vscode";
 
 /** Interface for logging operations. New features should use this interface for the "type" of logger.
  *  This will allow for easy mocking of the logger during unit tests.
  */
 export interface ILogger {
-    logDirectoryPath: vscode.Uri;
-    updateLogLevel(logLevelName: string): void;
+    logDirectoryPath: Uri;
     write(message: string, ...additionalMessages: string[]): void;
     writeAndShowInformation(message: string, ...additionalMessages: string[]): Promise<void>;
     writeDiagnostic(message: string, ...additionalMessages: string[]): void;
@@ -35,37 +24,36 @@ export interface ILogger {
 }
 
 export class Logger implements ILogger {
-    public logDirectoryPath: vscode.Uri; // The folder for all the logs
-    private logLevel: LogLevel;
-    private commands: vscode.Disposable[];
-    private logChannel: vscode.OutputChannel;
-    private logFilePath: vscode.Uri; // The client's logs
+    public logDirectoryPath: Uri; // The folder for all the logs
+    private commands: Disposable[];
+    // Log output channel handles all the verbosity management so we don't have to.
+    private logChannel: LogOutputChannel;
+    private logFilePath: Uri; // The client's logs
     private logDirectoryCreated = false;
     private writingLog = false;
+    public get logLevel(): LogLevel { return this.logChannel.logLevel;}
 
-    constructor(logLevelName: string, globalStorageUri: vscode.Uri) {
-        this.logLevel = Logger.logLevelNameToValue(logLevelName);
-        this.logChannel = vscode.window.createOutputChannel("PowerShell Extension Logs");
+    constructor(globalStorageUri: Uri, logChannel?: LogOutputChannel) {
+        this.logChannel = logChannel ?? window.createOutputChannel("PowerShell", {log: true});
         // We have to override the scheme because it defaults to
         // 'vscode-userdata' which breaks UNC paths.
-        this.logDirectoryPath = vscode.Uri.joinPath(
+        this.logDirectoryPath = Uri.joinPath(
             globalStorageUri.with({ scheme: "file" }),
             "logs",
-            `${Math.floor(Date.now() / 1000)}-${vscode.env.sessionId}`);
-        this.logFilePath = vscode.Uri.joinPath(this.logDirectoryPath, "vscode-powershell.log");
+            `${Math.floor(Date.now() / 1000)}-${env.sessionId}`);
+        this.logFilePath = Uri.joinPath(this.logDirectoryPath, "vscode-powershell.log");
 
         // Early logging of the log paths for debugging.
-        if (LogLevel.Diagnostic >= this.logLevel) {
-            const uriMessage = Logger.timestampMessage(`Log file path: '${this.logFilePath}'`, LogLevel.Verbose);
-            this.logChannel.appendLine(uriMessage);
+        if (this.logLevel >= LogLevel.Trace) {
+            this.logChannel.trace(`Log directory: ${this.logDirectoryPath.fsPath}`);
         }
 
         this.commands = [
-            vscode.commands.registerCommand(
+            commands.registerCommand(
                 "PowerShell.ShowLogs",
                 () => { this.showLogPanel(); }),
 
-            vscode.commands.registerCommand(
+            commands.registerCommand(
                 "PowerShell.OpenLogFolder",
                 async () => { await this.openLogFolder(); }),
         ];
@@ -89,24 +77,24 @@ export class Logger implements ILogger {
     }
 
     public write(message: string, ...additionalMessages: string[]): void {
-        this.writeAtLevel(LogLevel.Normal, message, ...additionalMessages);
+        this.writeAtLevel(LogLevel.Info, message, ...additionalMessages);
     }
 
     public async writeAndShowInformation(message: string, ...additionalMessages: string[]): Promise<void> {
         this.write(message, ...additionalMessages);
 
-        const selection = await vscode.window.showInformationMessage(message, "Show Logs", "Okay");
+        const selection = await window.showInformationMessage(message, "Show Logs", "Okay");
         if (selection === "Show Logs") {
             this.showLogPanel();
         }
     }
 
     public writeDiagnostic(message: string, ...additionalMessages: string[]): void {
-        this.writeAtLevel(LogLevel.Diagnostic, message, ...additionalMessages);
+        this.writeAtLevel(LogLevel.Trace, message, ...additionalMessages);
     }
 
     public writeVerbose(message: string, ...additionalMessages: string[]): void {
-        this.writeAtLevel(LogLevel.Verbose, message, ...additionalMessages);
+        this.writeAtLevel(LogLevel.Debug, message, ...additionalMessages);
     }
 
     public writeWarning(message: string, ...additionalMessages: string[]): void {
@@ -116,7 +104,7 @@ export class Logger implements ILogger {
     public async writeAndShowWarning(message: string, ...additionalMessages: string[]): Promise<void> {
         this.writeWarning(message, ...additionalMessages);
 
-        const selection = await vscode.window.showWarningMessage(message, "Show Logs");
+        const selection = await window.showWarningMessage(message, "Show Logs");
         if (selection !== undefined) {
             this.showLogPanel();
         }
@@ -129,7 +117,7 @@ export class Logger implements ILogger {
     public async writeAndShowError(message: string, ...additionalMessages: string[]): Promise<void> {
         this.writeError(message, ...additionalMessages);
 
-        const choice = await vscode.window.showErrorMessage(message, "Show Logs");
+        const choice = await window.showErrorMessage(message, "Show Logs");
         if (choice !== undefined) {
             this.showLogPanel();
         }
@@ -147,7 +135,7 @@ export class Logger implements ILogger {
 
         const actionKeys: string[] = fullActions.map((action) => action.prompt);
 
-        const choice = await vscode.window.showErrorMessage(message, ...actionKeys);
+        const choice = await window.showErrorMessage(message, ...actionKeys);
         if (choice) {
             for (const action of fullActions) {
                 if (choice === action.prompt && action.action !== undefined ) {
@@ -158,23 +146,6 @@ export class Logger implements ILogger {
         }
     }
 
-    // TODO: Make the enum smarter about strings so this goes away.
-    private static logLevelNameToValue(logLevelName: string): LogLevel {
-        switch (logLevelName.trim().toLowerCase()) {
-        case "diagnostic": return LogLevel.Diagnostic;
-        case "verbose": return LogLevel.Verbose;
-        case "normal": return LogLevel.Normal;
-        case "warning": return LogLevel.Warning;
-        case "error": return LogLevel.Error;
-        case "none": return LogLevel.None;
-        default: return LogLevel.Normal;
-        }
-    }
-
-    public updateLogLevel(logLevelName: string): void {
-        this.logLevel = Logger.logLevelNameToValue(logLevelName);
-    }
-
     private showLogPanel(): void {
         this.logChannel.show();
     }
@@ -183,7 +154,7 @@ export class Logger implements ILogger {
         if (this.logDirectoryCreated) {
             // Open the folder in VS Code since there isn't an easy way to
             // open the folder in the platform's file browser
-            await vscode.commands.executeCommand("vscode.openFolder", this.logDirectoryPath, true);
+            await commands.executeCommand("openFolder", this.logDirectoryPath, true);
         } else {
             void this.writeAndShowError("Cannot open PowerShell log directory as it does not exist!");
         }
@@ -195,26 +166,35 @@ export class Logger implements ILogger {
     }
 
     // TODO: Should we await this function above?
-    private async writeLine(message: string, level: LogLevel = LogLevel.Normal): Promise<void> {
-        const timestampedMessage = Logger.timestampMessage(message, level);
-        this.logChannel.appendLine(timestampedMessage);
-        if (this.logLevel !== LogLevel.None) {
+    private async writeLine(message: string, level: LogLevel = LogLevel.Info): Promise<void> {
+        switch (level) {
+        case LogLevel.Trace: this.logChannel.trace(message); break;
+        case LogLevel.Debug: this.logChannel.debug(message); break;
+        case LogLevel.Info: this.logChannel.info(message); break;
+        case LogLevel.Warning: this.logChannel.warn(message); break;
+        case LogLevel.Error: this.logChannel.error(message); break;
+        default: this.logChannel.appendLine(message); break;
+        }
+
+        if (this.logLevel !== LogLevel.Off) {
             // A simple lock because this function isn't re-entrant.
             while (this.writingLog) {
-                await utils.sleep(300);
+                await sleep(300);
             }
             try {
                 this.writingLog = true;
                 if (!this.logDirectoryCreated) {
                     this.writeVerbose(`Creating log directory at: '${this.logDirectoryPath}'`);
-                    await vscode.workspace.fs.createDirectory(this.logDirectoryPath);
+                    await workspace.fs.createDirectory(this.logDirectoryPath);
                     this.logDirectoryCreated = true;
                 }
                 let log = new Uint8Array();
-                if (await utils.checkIfFileExists(this.logFilePath)) {
-                    log = await vscode.workspace.fs.readFile(this.logFilePath);
+                if (await checkIfFileExists(this.logFilePath)) {
+                    log = await workspace.fs.readFile(this.logFilePath);
                 }
-                await vscode.workspace.fs.writeFile(
+
+                const timestampedMessage = Logger.timestampMessage(message, level);
+                await workspace.fs.writeFile(
                     this.logFilePath,
                     Buffer.concat([log, Buffer.from(timestampedMessage)]));
             } catch (err) {
diff --git a/src/session.ts b/src/session.ts
@@ -14,7 +14,7 @@ import utils = require("./utils");
 import {
     CloseAction, CloseHandlerResult, DocumentSelector, ErrorAction, ErrorHandlerResult,
     LanguageClientOptions, Middleware, NotificationType,
-    RequestType0, ResolveCodeLensSignature, RevealOutputChannelOn
+    RequestType0, ResolveCodeLensSignature
 } from "vscode-languageclient";
 import { LanguageClient, StreamInfo } from "vscode-languageclient/node";
 
@@ -454,7 +454,6 @@ export class SessionManager implements Middleware {
     private async onConfigurationUpdated(): Promise<void> {
         const settings = getSettings();
         const shellIntegrationEnabled = vscode.workspace.getConfiguration("terminal.integrated.shellIntegration").get<boolean>("enabled");
-        this.logger.updateLogLevel(settings.developer.editorServicesLogLevel);
 
         // Detect any setting changes that would affect the session.
         if (!this.suppressRestartPrompt
@@ -656,9 +655,9 @@ export class SessionManager implements Middleware {
                     };
                 },
             },
-            revealOutputChannelOn: RevealOutputChannelOn.Never,
             middleware: this,
             traceOutputChannel: vscode.window.createOutputChannel("PowerShell Trace - LSP", {log: true}),
+            outputChannel: vscode.window.createOutputChannel("PowerShell Editor Services", {log: true}),
         };
 
         const languageClient = new LanguageClient("powershell", "PowerShell Editor Services Client", connectFunc, clientOptions);
diff --git a/src/utils.ts b/src/utils.ts
@@ -86,6 +86,32 @@ export function sleep(ms: number): Promise<void> {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Invokes the specified action when a PowerShell setting changes
+ * @param setting a string representation of the setting you wish to evaluate
+ * @param action the action to take when the setting changes
+ * @param scope the scope in which the vscode setting should be evaluated. Defaults to
+ * @param workspace
+ * @param onDidChangeConfiguration
+ * @example onPowerShellSettingChange("settingName", (newValue) => console.log(newValue));
+ * @returns a Disposable object that can be used to stop listening for changes
+ */
+
+// Because we actually do use the constraint in the callback
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+export function onPowerShellSettingChange<T>(
+    setting: string,
+    listener: (newValue: T | undefined) => void,
+    section: "powershell",
+    scope?: vscode.ConfigurationScope,
+): vscode.Disposable {
+    return vscode.workspace.onDidChangeConfiguration(e => {
+        if (!e.affectsConfiguration(section, scope)) { return; }
+        const value = vscode.workspace.getConfiguration(section, scope).get<T>(setting);
+        listener(value);
+    });
+}
+
 export const isMacOS: boolean = process.platform === "darwin";
 export const isWindows: boolean = process.platform === "win32";
 export const isLinux: boolean = !isMacOS && !isWindows;
