cleanups

Author: fearthecowboy

Extension/src/LanguageServer/client.ts

@@ -2737,7 +2737,7 @@ export class DefaultClient implements Client {
             const status: IntelliSenseStatus = { status: Status.IntelliSenseCompiling };
             testHook.updateStatus(status);
         } else if (message.endsWith("IntelliSense done")) {
-            getOutputChannelLogger().appendLine(6, localize("update.intellisense.time", "Update IntelliSense time (sec): {0}", (Date.now() - timeStamp) / 1000));
+            getOutputChannelLogger().appendLineAtLevel(6, localize("update.intellisense.time", "Update IntelliSense time (sec): {0}", (Date.now() - timeStamp) / 1000));
             this.model.isUpdatingIntelliSense.Value = false;
             const status: IntelliSenseStatus = { status: Status.IntelliSenseReady };
             testHook.updateStatus(status);
@@ -3164,7 +3164,7 @@ export class DefaultClient implements Client {
         }
 
         const out: Logger = getOutputChannelLogger();
-        out.appendLine(6, localize("configurations.received", "Custom configurations received:"));
+        out.appendLineAtLevel(6, localize("configurations.received", "Custom configurations received:"));
         const sanitized: SourceFileConfigurationItemAdapter[] = [];
         configs.forEach(item => {
             if (this.isSourceFileConfigurationItem(item, providerVersion)) {
@@ -3176,8 +3176,8 @@ export class DefaultClient implements Client {
                     uri = item.uri.toString();
                 }
                 this.configurationLogging.set(uri, JSON.stringify(item.configuration, null, 4));
-                out.appendLine(6, `  uri: ${uri}`);
-                out.appendLine(6, `  config: ${JSON.stringify(item.configuration, null, 2)}`);
+                out.appendLineAtLevel(6, `  uri: ${uri}`);
+                out.appendLineAtLevel(6, `  config: ${JSON.stringify(item.configuration, null, 2)}`);
                 if (item.configuration.includePath.some(path => path.endsWith('**'))) {
                     console.warn("custom include paths should not use recursive includes ('**')");
                 }
@@ -3281,7 +3281,7 @@ export class DefaultClient implements Client {
                 return;
             }
 
-            getOutputChannelLogger().appendLine(6, localize("browse.configuration.received", "Custom browse configuration received: {0}", JSON.stringify(sanitized, null, 2)));
+            getOutputChannelLogger().appendLineAtLevel(6, localize("browse.configuration.received", "Custom browse configuration received: {0}", JSON.stringify(sanitized, null, 2)));
 
             // Separate compiler path and args before sending to language client
             if (util.isString(sanitized.compilerPath)) {

Extension/src/common.ts

@@ -759,7 +759,7 @@ export interface ProcessReturnType {
 export async function spawnChildProcess(program: string, args: string[] = [], continueOn?: string, skipLogging?: boolean, cancellationToken?: vscode.CancellationToken): Promise<ProcessReturnType> {
     // Do not use CppSettings to avoid circular require()
     if (skipLogging === undefined || !skipLogging) {
-        getOutputChannelLogger().appendLine(5, `$ ${program} ${args.join(' ')}`);
+        getOutputChannelLogger().appendLineAtLevel(5, `$ ${program} ${args.join(' ')}`);
     }
     const programOutput: ProcessOutput = await spawnChildProcessImpl(program, args, continueOn, skipLogging, cancellationToken);
     const exitCode: number | NodeJS.Signals | undefined = programOutput.exitCode;
@@ -811,7 +811,7 @@ async function spawnChildProcessImpl(program: string, args: string[], continueOn
         proc.stdout.on('data', data => {
             const str: string = data.toString();
             if (skipLogging === undefined || !skipLogging) {
-                getOutputChannelLogger().append(1, str);
+                getOutputChannelLogger().appendAtLevel(1, str);
             }
             stdout += str;
             if (continueOn) {

Extension/src/cppTools.ts

@@ -59,7 +59,7 @@ export class CppTools implements CppToolsTestApi {
         if (providers.add(provider, this.version)) {
             const added: CustomConfigurationProvider1 | undefined = providers.get(provider);
             if (added) {
-                getOutputChannelLogger().appendLine(5, localize("provider.registered", "Custom configuration provider '{0}' registered", added.name));
+                getOutputChannelLogger().appendLineAtLevel(5, localize("provider.registered", "Custom configuration provider '{0}' registered", added.name));
                 this.providers.push(added);
                 LanguageServer.getClients().forEach(client => void client.onRegisterCustomConfigurationProvider(added));
                 this.addNotifyReadyTimer(added);

Extension/src/instrumentation.ts

@@ -30,6 +30,7 @@ const services = {
     launchSettings: undefined as Record<string, any> | undefined
 };
 
+/** Adds instrumentation to all the members of an object when instrumentation is enabled  */
 export function instrument<T extends Record<string, any>>(instance: T, options?: { ignore?: string[]; name?: string }): T {
     return services.instrument(instance, options);
 }
@@ -44,22 +45,25 @@ export function isInstrumentationEnabled(): boolean {
     return !!(global as any).instrumentation;
 }
 
-// if the instrumentation code is not globally loaded yet, then load it now
+// if the instrumentation code is not globally loaded *yet*, then load it now.
 if (!isInstrumentationEnabled()) {
     // pull the launch settings from the environment if the variable has been set.
     if (services.launchSettings === undefined) {
         services.launchSettings = process.env.PERFECTO_LAUNCH_SETTINGS ? JSON.parse(process.env.PERFECTO_LAUNCH_SETTINGS) as Record<string, any> : { tests: [], collector: undefined };
     }
 
-    // this loads the bootstrap module (global-instrumentation-support) which adds some global functions
+    // this loads the bootstrap module (global-instrumentation-support) which adds some global functions.
     if (services.launchSettings?.bootstrapModule) {
-        // work around for webpack to load the bootstrap module
+        // work around for webpack to load the bootstrap module.
         eval(`require`)(services.launchSettings.bootstrapModule);
     }
 }
 
-// If the instrumentation object was loaded then we can set the services from the global object
-if ((global as any).instrumentation) {
+// If the instrumentation object was *actually* loaded then we can set the services from the global object.
+// Having this separate ensures that this module is wired up to the global object. 
+// It's not included in the previous block because if something else loads the instrumentation code first
+// this is still needed so that *this* module is properly connected to the global object.
+if (isInstrumentationEnabled()) {
     // instrumentation services provided by the tool
     services.instrument = (global as any).instrumentation.instrument;
     services.message = (global as any).instrumentation.message;

Extension/src/logger.ts

@@ -28,25 +28,26 @@ export class Logger {
         this.writer = writer;
     }
 
-    public append(level: number, message: string): void;
-    public append(message: string): void;
-    public append(levelOrMessage: string | number, message?: string): void {
-        message = message || levelOrMessage as string;
-        const hasLevel = typeof levelOrMessage === 'number';
-
-        if (!hasLevel || getLoggingLevel() >= levelOrMessage) {
+    public appendAtLevel(level: number, message: string): void {
+        if (getLoggingLevel() >= level) {
             this.writer(message);
             if (Subscriber) {
                 Subscriber(message);
             }
         }
-        sendInstrumentation({ name: 'log', text: message, context: { channel: 'log', source: 'extension' }, level: hasLevel ? levelOrMessage : undefined });
+        sendInstrumentation({ name: 'log', text: message, context: { channel: 'log', source: 'extension' }, level });
+    }
+
+    public append(message: string): void {
+        this.appendAtLevel(0, message);
+    }
+
+    public appendLineAtLevel(level: number, message: string): void {
+        this.appendAtLevel(level, message + os.EOL);
     }
 
-    public appendLine(level: number, message: string): void;
-    public appendLine(message: string): void;
-    public appendLine(levelOrMessage: string | number, message?: string): void {
-        this.append(levelOrMessage as number, message + os.EOL);
+    public appendLine(message: string): void {
+        this.appendAtLevel(0, message + os.EOL);
     }
 
     // We should not await on this function.