Fix how we get the python interpreter

Author: patrick91

package-lock.json

@@ -2,7 +2,7 @@
     "name": "python-dependencies-vscode",
     "displayName": "Python Dependencies",
     "description": "Utilities for managing Python dependencies",
-    "version": "0.0.17",
+    "version": "0.0.18",
     "publisher": "patrick91",
     "engines": {
         "vscode": "^1.53.0"
@@ -48,6 +48,7 @@
     "dependencies": {
         "execa": "^5.0.0",
         "node-fetch": "^2.6.1",
-        "vscode-cache": "^0.3.0"
+        "vscode-cache": "^0.3.0",
+        "vscode-jsonrpc": "^8.0.2"
     }
 }

package.json

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { WriteStream } from 'fs-extra';
+import * as util from 'util';
+import { Disposable } from 'vscode-jsonrpc';
+import { Arguments, ILogging } from './types';
+import { getTimeForLogging } from '../utilities';
+
+function formatMessage(level: string, ...data: Arguments): string {
+    return `[${level.toUpperCase()} ${getTimeForLogging()}]: ${util.format(...data)}\r\n`;
+}
+
+export class FileLogger implements ILogging, Disposable {
+    constructor(private readonly stream: WriteStream) {}
+
+    public traceLog(...data: Arguments): void {
+        this.stream.write(`${util.format(...data)}\r\n`);
+    }
+
+    public traceError(...data: Arguments): void {
+        this.stream.write(formatMessage('error', ...data));
+    }
+
+    public traceWarn(...data: Arguments): void {
+        this.stream.write(formatMessage('warn', ...data));
+    }
+
+    public traceInfo(...data: Arguments): void {
+        this.stream.write(formatMessage('info', ...data));
+    }
+
+    public traceVerbose(...data: Arguments): void {
+        this.stream.write(formatMessage('debug', ...data));
+    }
+
+    public dispose(): void {
+        try {
+            this.stream.close();
+        } catch (ex) {
+            /** do nothing */
+        }
+    }
+}

src/common/log/fileLogger.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { createWriteStream } from 'fs-extra';
+import { Disposable } from 'vscode';
+import { FileLogger } from './fileLogger';
+import { Arguments, ILogging, LoggingLevelSettingType, LogLevel } from './types';
+
+let loggers: ILogging[] = [];
+export function registerLogger(logger: ILogging): Disposable {
+    loggers.push(logger);
+    return {
+        dispose: () => {
+            loggers = loggers.filter((l) => l !== logger);
+        },
+    };
+}
+
+const logLevelMap: Map<string | undefined, LogLevel> = new Map([
+    ['error', LogLevel.error],
+    ['warn', LogLevel.warn],
+    ['info', LogLevel.info],
+    ['debug', LogLevel.debug],
+    ['none', LogLevel.off],
+    ['off', LogLevel.off],
+    [undefined, LogLevel.error],
+]);
+
+let globalLoggingLevel: LogLevel;
+export function setLoggingLevel(level?: LoggingLevelSettingType): void {
+    globalLoggingLevel = logLevelMap.get(level) ?? LogLevel.error;
+}
+
+export function initializeFileLogging(filePath: string, disposables: Disposable[]): unknown {
+    try {
+        const fileLogger = new FileLogger(createWriteStream(filePath));
+        disposables.push(fileLogger);
+        disposables.push(registerLogger(fileLogger));
+        return undefined;
+    } catch (ex) {
+        return ex;
+    }
+}
+
+export function traceLog(...args: Arguments): void {
+    loggers.forEach((l) => l.traceLog(...args));
+}
+
+export function traceError(...args: Arguments): void {
+    if (globalLoggingLevel >= LogLevel.error) {
+        loggers.forEach((l) => l.traceError(...args));
+    }
+}
+
+export function traceWarn(...args: Arguments): void {
+    if (globalLoggingLevel >= LogLevel.warn) {
+        loggers.forEach((l) => l.traceWarn(...args));
+    }
+}
+
+export function traceInfo(...args: Arguments): void {
+    if (globalLoggingLevel >= LogLevel.info) {
+        loggers.forEach((l) => l.traceInfo(...args));
+    }
+}
+
+export function traceVerbose(...args: Arguments): void {
+    if (globalLoggingLevel >= LogLevel.debug) {
+        loggers.forEach((l) => l.traceVerbose(...args));
+    }
+}

src/common/log/logging.ts

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as util from 'util';
+import { OutputChannel } from 'vscode';
+import { Arguments, ILogging } from './types';
+import { getTimeForLogging } from '../utilities';
+
+function formatMessage(level: string, ...data: Arguments): string {
+    return `[${level.toUpperCase()} ${getTimeForLogging()}]: ${util.format(...data)}`;
+}
+
+export class OutputChannelLogger implements ILogging {
+    constructor(private readonly channel: OutputChannel) {}
+
+    public traceLog(...data: Arguments): void {
+        this.channel.appendLine(util.format(...data));
+    }
+
+    public traceError(...data: Arguments): void {
+        this.channel.appendLine(formatMessage('error', ...data));
+    }
+
+    public traceWarn(...data: Arguments): void {
+        this.channel.appendLine(formatMessage('warn', ...data));
+    }
+
+    public traceInfo(...data: Arguments): void {
+        this.channel.appendLine(formatMessage('info', ...data));
+    }
+
+    public traceVerbose(...data: Arguments): void {
+        this.channel.appendLine(formatMessage('debug', ...data));
+    }
+}

src/common/log/outputChannelLogger.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export type Arguments = unknown[];
+
+export interface ILogging {
+    traceLog(...data: Arguments): void;
+    traceError(...data: Arguments): void;
+    traceWarn(...data: Arguments): void;
+    traceInfo(...data: Arguments): void;
+    traceVerbose(...data: Arguments): void;
+}
+
+export type LoggingLevelSettingType = 'off' | 'error' | 'warn' | 'info' | 'debug';
+export enum LogLevel {
+    off = 0,
+    error = 10,
+    warn = 20,
+    info = 30,
+    debug = 40,
+}