More fixes collected from various extensions built using this template. (#100)

* Report error in logs when Python < 3.7

* Do not add debugger script when packaging VSIX

* Improve logging support

Author: karthiknadig

.vscodeignore

@@ -20,4 +20,5 @@ noxfile.py
 .pytest_cache/**
 .pylintrc
 **/requirements.txt
-**/requirements.in
+**/requirements.in
+**/tool/_debug_server.py

README.md

@@ -48,7 +48,8 @@ After finishing the getting started part, this template would have added the fol
 1. Following triggers for extension activation:
     - On Language `python`.
     - On File with `.py` extension found in the opened workspace.
-    - On Command `mytool.restart`.
+1. Following commands are registered:
+    - `mytool.restart`: Restarts the language server.
 1. Output Channel for logging `Output` > `My Tool`
 
 ## Adding features from your tool
@@ -82,6 +83,12 @@ To debug only TypeScript code, use `Debug Extension` debug config.
 
 To debug a already running server or in production server, use `Python Attach`, and select the process that is running `lsp_server.py`.
 
+## Logging and Logs
+
+The template creates a logging Output channel that can be found under `Output` > `mytool` panel. You can control the log level running the `Developer: Set Log Level...` command from the Command Pallet, and selecting your extension from the list. It should be listed using the display name for your tool. You can also set the global log level, and that will apply to all extensions and the editor.
+
+If you need logs that involve messages between the Language Client and Language Server, you can set `"mytool.server.trace": "verbose"`, to get the messaging logs. These logs are also available `Output` > `mytool` panel.
+
 ## Adding new Settings or Commands
 
 You can add new settings by adding details for the settings in `package.json` file. To pass this configuration to your python tool server (i.e, `lsp_server.py`) update the `settings.ts` as need. There are examples of different types of settings in that file that you can base your new settings on.

src/common/log/logging.ts

@@ -9,7 +9,7 @@ class OutputChannelLogger {
     constructor(private readonly channel: LogOutputChannel) {}
 
     public traceLog(...data: Arguments): void {
-        this.channel.trace(util.format(...data));
+        this.channel.appendLine(util.format(...data));
     }
 
     public traceError(...data: Arguments): void {

src/common/python.ts

@@ -253,12 +253,17 @@ export async function initializePython(disposables: Disposable[]): Promise<void>
     }
 }
 
+export async function resolveInterpreter(interpreter: string[]): Promise<ResolvedEnvironment | undefined> {
+    const api = await getPythonExtensionAPI();
+    return api?.environments.resolveEnvironment(interpreter[0]);
+}
+
 export async function getInterpreterDetails(resource?: Uri): Promise<IInterpreterDetails> {
     const api = await getPythonExtensionAPI();
     const environment = await api?.environments.resolveEnvironment(
         api?.environments.getActiveEnvironmentPath(resource),
     );
-    if (environment?.executable.uri) {
+    if (environment?.executable.uri && checkVersion(environment)) {
         return { path: [environment?.executable.uri.fsPath], resource };
     }
     return { path: undefined, resource };
@@ -273,3 +278,14 @@ export async function runPythonExtensionCommand(command: string, ...rest: any[])
     await activateExtension();
     return await commands.executeCommand(command, ...rest);
 }
+
+export function checkVersion(resolved: ResolvedEnvironment | undefined): boolean {
+    const version = resolved?.version;
+    if (version?.major === 3 && version?.minor >= 7) {
+        return true;
+    }
+    traceError(`Python version ${version?.major}.${version?.minor} is not supported.`);
+    traceError(`Selected python path: ${resolved?.executable.uri?.fsPath}`);
+    traceError('Supported versions are 3.7 and above.');
+    return false;
+}

src/common/server.ts

@@ -1,7 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { Disposable, LogOutputChannel, WorkspaceFolder } from 'vscode';
+import * as fsapi from 'fs-extra';
+import { Disposable, env, LogOutputChannel } from 'vscode';
 import { State } from 'vscode-languageclient';
 import {
     LanguageClient,
@@ -31,6 +32,7 @@ async function createServer(
     // Set debugger path needed for debugging python code.
     const newEnv = { ...process.env };
     const debuggerPath = await getDebuggerPath();
+    const isDebugScript = await fsapi.pathExists(DEBUG_SERVER_SCRIPT_PATH);
     if (newEnv.USE_DEBUGPY && debuggerPath) {
         newEnv.DEBUGPY_PATH = debuggerPath;
     } else {
@@ -44,7 +46,7 @@ async function createServer(
     newEnv.LS_SHOW_NOTIFICATION = settings.showNotifications;
 
     const args =
-        newEnv.USE_DEBUGPY === 'False'
+        newEnv.USE_DEBUGPY === 'False' || !isDebugScript
             ? settings.interpreter.slice(1).concat([SERVER_SCRIPT_PATH])
             : settings.interpreter.slice(1).concat([DEBUG_SERVER_SCRIPT_PATH]);
     traceInfo(`Server run command: ${[command, ...args].join(' ')}`);
@@ -90,14 +92,6 @@ export async function restartServer(
     }
     const projectRoot = await getProjectRoot();
     const workspaceSetting = await getWorkspaceSettings(serverId, projectRoot, true);
-    if (workspaceSetting.interpreter.length === 0) {
-        traceError(
-            'Python interpreter missing:\r\n' +
-                '[Option 1] Select python interpreter using the ms-python.python.\r\n' +
-                `[Option 2] Set an interpreter using "${serverId}.interpreter" setting.\r\n`,
-        );
-        return undefined;
-    }
 
     const newLSClient = await createServer(workspaceSetting, serverId, serverName, outputChannel, {
         settings: await getExtensionSettings(serverId, true),
@@ -118,16 +112,15 @@ export async function restartServer(
                     break;
             }
         }),
-        outputChannel.onDidChangeLogLevel((e) => {
-            newLSClient.setTrace(getLSClientTraceLevel(e));
-        }),
     );
     try {
         await newLSClient.start();
     } catch (ex) {
         traceError(`Server: Start failed: ${ex}`);
         return undefined;
     }
-    newLSClient.setTrace(getLSClientTraceLevel(outputChannel.logLevel));
+
+    const level = getLSClientTraceLevel(outputChannel.logLevel, env.logLevel);
+    await newLSClient.setTrace(level);
     return newLSClient;
 }

src/common/settings.ts

@@ -89,7 +89,6 @@ export async function getGlobalSettings(namespace: string, includeInterpreter?:
 
 export function checkIfConfigurationChanged(e: ConfigurationChangeEvent, namespace: string): boolean {
     const settings = [
-        `${namespace}.trace`,
         `${namespace}.args`,
         `${namespace}.path`,
         `${namespace}.interpreter`,

src/common/utilities.ts

@@ -3,24 +3,38 @@
 
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import { env, LogLevel, Uri, WorkspaceFolder } from 'vscode';
-import { Trace, TraceValues } from 'vscode-jsonrpc/node';
+import { LogLevel, Uri, WorkspaceFolder } from 'vscode';
+import { Trace } from 'vscode-jsonrpc/node';
 import { getWorkspaceFolders } from './vscodeapi';
 
-export function getLSClientTraceLevel(logLevel: LogLevel): Trace {
+function logLevelToTrace(logLevel: LogLevel): Trace {
     switch (logLevel) {
         case LogLevel.Error:
         case LogLevel.Warning:
         case LogLevel.Info:
             return Trace.Messages;
+
         case LogLevel.Debug:
+        case LogLevel.Trace:
             return Trace.Verbose;
+
         case LogLevel.Off:
         default:
             return Trace.Off;
     }
 }
 
+export function getLSClientTraceLevel(channelLogLevel: LogLevel, globalLogLevel: LogLevel): Trace {
+    if (channelLogLevel === LogLevel.Off) {
+        return logLevelToTrace(globalLogLevel);
+    }
+    if (globalLogLevel === LogLevel.Off) {
+        return logLevelToTrace(channelLogLevel);
+    }
+    const level = logLevelToTrace(channelLogLevel <= globalLogLevel ? channelLogLevel : globalLogLevel);
+    return level;
+}
+
 export async function getProjectRoot(): Promise<WorkspaceFolder> {
     const workspaces: readonly WorkspaceFolder[] = getWorkspaceFolders();
     if (workspaces.length === 0) {

src/extension.ts

@@ -3,17 +3,18 @@
 
 import * as vscode from 'vscode';
 import { LanguageClient } from 'vscode-languageclient/node';
-import { registerLogger, traceLog, traceVerbose } from './common/log/logging';
+import { registerLogger, traceError, traceLog, traceVerbose } from './common/log/logging';
 import {
+    checkVersion,
     getInterpreterDetails,
     initializePython,
     onDidChangePythonInterpreter,
-    runPythonExtensionCommand,
+    resolveInterpreter,
 } from './common/python';
 import { restartServer } from './common/server';
 import { checkIfConfigurationChanged, getInterpreterFromSetting } from './common/settings';
 import { loadServerDefaults } from './common/setup';
-import { getProjectRoot } from './common/utilities';
+import { getLSClientTraceLevel } from './common/utilities';
 import { createOutputChannel, onDidChangeConfiguration, registerCommand } from './common/vscodeapi';
 
 let lsClient: LanguageClient | undefined;
@@ -28,39 +29,60 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     const outputChannel = createOutputChannel(serverName);
     context.subscriptions.push(outputChannel, registerLogger(outputChannel));
 
-    traceLog(`Name: ${serverName}`);
+    const changeLogLevel = async (c: vscode.LogLevel, g: vscode.LogLevel) => {
+        const level = getLSClientTraceLevel(c, g);
+        await lsClient?.setTrace(level);
+    };
+
+    context.subscriptions.push(
+        outputChannel.onDidChangeLogLevel(async (e) => {
+            await changeLogLevel(e, vscode.env.logLevel);
+        }),
+        vscode.env.onDidChangeLogLevel(async (e) => {
+            await changeLogLevel(outputChannel.logLevel, e);
+        }),
+    );
+
+    // Log Server information
+    traceLog(`Name: ${serverInfo.name}`);
     traceLog(`Module: ${serverInfo.module}`);
-    traceVerbose(`Configuration: ${JSON.stringify(serverInfo)}`);
+    traceVerbose(`Full Server Info: ${JSON.stringify(serverInfo)}`);
 
     const runServer = async () => {
-        lsClient = await restartServer(serverId, serverName, outputChannel, lsClient);
+        const interpreter = getInterpreterFromSetting(serverId);
+        if (interpreter && interpreter.length > 0 && checkVersion(await resolveInterpreter(interpreter))) {
+            traceVerbose(`Using interpreter from ${serverInfo.module}.interpreter: ${interpreter.join(' ')}`);
+            lsClient = await restartServer(serverId, serverName, outputChannel, lsClient);
+            return;
+        }
+
+        const interpreterDetails = await getInterpreterDetails();
+        if (interpreterDetails.path) {
+            traceVerbose(`Using interpreter from Python extension: ${interpreterDetails.path.join(' ')}`);
+            lsClient = await restartServer(serverId, serverName, outputChannel, lsClient);
+            return;
+        }
+
+        traceError(
+            'Python interpreter missing:\r\n' +
+                '[Option 1] Select python interpreter using the ms-python.python.\r\n' +
+                `[Option 2] Set an interpreter using "${serverId}.interpreter" setting.\r\n` +
+                'Please use Python 3.7 or greater.',
+        );
     };
 
     context.subscriptions.push(
         onDidChangePythonInterpreter(async () => {
             await runServer();
         }),
-    );
-
-    context.subscriptions.push(
-        registerCommand(`${serverId}.restart`, async () => {
-            const interpreter = getInterpreterFromSetting(serverId);
-            const interpreterDetails = await getInterpreterDetails();
-            if (interpreter?.length || interpreterDetails.path) {
-                await runServer();
-            } else {
-                const projectRoot = await getProjectRoot();
-                runPythonExtensionCommand('python.triggerEnvSelection', projectRoot.uri);
-            }
-        }),
-    );
-
-    context.subscriptions.push(
         onDidChangeConfiguration(async (e: vscode.ConfigurationChangeEvent) => {
             if (checkIfConfigurationChanged(e, serverId)) {
                 await runServer();
             }
         }),
+        registerCommand(`${serverId}.restart`, async () => {
+            await runServer();
+        }),
     );
 
     setImmediate(async () => {

tsconfig.json

@@ -5,10 +5,9 @@
         "lib": ["ES2020"],
         "sourceMap": true,
         "rootDir": "src",
-        "strict": true /* enable all strict type-checking options */
-        /* Additional Checks */
-        // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
-        // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
-        // "noUnusedParameters": true,  /* Report errors on unused parameters. */
+        "strict": true,
+        "noImplicitReturns": true,
+        "noFallthroughCasesInSwitch": true,
+        "noUnusedParameters": true
     }
 }