VsCode plugin: review adjustments

An item in status bar now shows tracing status and can be clicked to
adjust consent.

Tracing and workspace dump now take into account that consent can be
given/revoked - workspace dump is only initialized after consent is
given, tracing socket is only created lazily as necessary.

Author: Aleksander Boruch-Gruszecki

vscode-dotty/src/extension.ts

@@ -21,7 +21,7 @@ import * as rpc from 'vscode-jsonrpc'
 import * as sbtserver from './sbt-server'
 import { Tracer } from './tracer';
 
-const extensionName = 'dotty';
+export const extensionName = 'dotty';
 const extensionConfig = vscode.workspace.getConfiguration(extensionName);
 
 let extensionContext: ExtensionContext
@@ -308,8 +308,7 @@ function bootstrapSbtProject(buildSbtFileSource: string,
 
 function run(serverOptions: ServerOptions, isOldServer: boolean) {
 
-  tracer.initializeAsyncWorkspaceDump();
-  const tracingOutputChannel = tracer.createLspOutputChannel();
+  const { lspOutputChannel } = tracer.run();
 
   const clientOptions: LanguageClientOptions = {
     documentSelector: [
@@ -321,7 +320,7 @@ function run(serverOptions: ServerOptions, isOldServer: boolean) {
     synchronize: {
       configurationSection: 'dotty'
     },
-    outputChannel: tracingOutputChannel,
+    outputChannel: lspOutputChannel,
     revealOutputChannelOn: RevealOutputChannelOn.Never
   }
 
@@ -334,5 +333,4 @@ function run(serverOptions: ServerOptions, isOldServer: boolean) {
   // Push the disposable to the context's subscriptions so that the
   // client can be deactivated on extension deactivation
   extensionContext.subscriptions.push(client.start())
-  if (tracingOutputChannel) extensionContext.subscriptions.push(tracingOutputChannel);
 }

vscode-dotty/src/tracer.ts

@@ -7,8 +7,11 @@ import * as archiver from 'archiver';
 import * as WebSocket from 'ws';
 import * as request from 'request';
 
+import { extensionName } from './extension';
 import { TracingConsentCache } from './tracing-consent';
 
+const consentCommandName = `${extensionName}.adjust-consent`;
+
 export interface Ctx {
   readonly extensionContext: vscode.ExtensionContext,
   readonly extensionConfig: vscode.WorkspaceConfiguration,
@@ -24,13 +27,20 @@ export class Tracer {
 
     private tracingConsent: TracingConsentCache
 
-    private remoteTracingUrl?: string
+    private readonly remoteTracingUrl: string | undefined
+    private readonly remoteWorkspaceDumpUrl: string | undefined
+    private get isTracingEnabled(): boolean {
+        return Boolean(this.remoteWorkspaceDumpUrl || this.remoteTracingUrl);
+    }
 
     constructor(ctx: Ctx) {
         this.ctx = ctx;
 
         this.tracingConsent = new TracingConsentCache(ctx.extensionContext.workspaceState);
 
+        this.remoteWorkspaceDumpUrl = this.ctx.extensionConfig.get<string>('remoteWorkspaceDumpUrl');
+        this.remoteTracingUrl = this.ctx.extensionConfig.get<string>('remoteTracingUrl');
+
         this.machineId = (() => {
             const machineIdKey = 'tracing.machineId';
             function persisted(value: string): string {
@@ -60,35 +70,82 @@ export class Tracer {
         this.sessionId = new Date().toISOString();
     }
 
-    initializeAsyncWorkspaceDump() {
-        const remoteWorkspaceDumpUrl = this.ctx.extensionConfig.get<string>('remoteWorkspaceDumpUrl');
-        if (remoteWorkspaceDumpUrl === undefined) return;
+    run(): { lspOutputChannel?: vscode.OutputChannel } {
+        const consentCommandDisposable = vscode.commands.registerCommand(consentCommandName, () => this.askForTracingConsent());
+        if (this.isTracingEnabled && this.tracingConsent.get() === 'no-answer') this.askForTracingConsent();
+        this.initializeAsyncWorkspaceDump();
+        const lspOutputChannel = this.createLspOutputChannel();
+        const statusBarItem = this.createStatusBarItem();
+        for (const disposable of [consentCommandDisposable, lspOutputChannel, statusBarItem]) {
+            if (disposable) this.ctx.extensionContext.subscriptions.push(disposable);
+        }
+        return { lspOutputChannel };
+    }
+
+    private askForTracingConsent(): void {
+        vscode.window.showInformationMessage(
+            'Do you want to help EPFL develop Dotty LSP plugin by uploading your LSP communication? ' +
+            'PLEASE BE AWARE that the data sent contains your entire codebase and ALL the IDE actions, ' +
+            'including every single keystroke.',
+            'yes', 'no'
+        ).then((value: string | undefined) => {
+            if (value === 'yes' || value === 'no') this.tracingConsent.set(value);
+        });
+    }
 
-        try {
-            this.asyncUploadWorkspaceDump(remoteWorkspaceDumpUrl);
-        } catch (err) {
-            this.logError('error during workspace dump', safeError(err));
+    private initializeAsyncWorkspaceDump() {
+        if (this.remoteWorkspaceDumpUrl === undefined) return;
+        // convince TS that this is a string
+        const definedUrl: string = this.remoteWorkspaceDumpUrl;
+
+        const doInitialize = () => {
+            try {
+                this.asyncUploadWorkspaceDump(definedUrl);
+            } catch (err) {
+                this.logError('error during workspace dump', safeError(err));
+            }
+        };
+
+        if (this.tracingConsent.get() === 'yes') {
+            doInitialize()
+        } else {
+            let didInitialize = false;
+            this.tracingConsent.subscribe(() => {
+                if (didInitialize) return;
+                didInitialize = true;
+                doInitialize();
+            })
         }
     }
 
-    createLspOutputChannel(): vscode.OutputChannel | undefined {
-        const remoteTracingUrl = this.ctx.extensionConfig.get<string>('remoteTracingUrl');
-        if (!remoteTracingUrl) return undefined;
-
-        if (this.tracingConsent.get() === 'no-answer') {
-            vscode.window.showInformationMessage(
-                'Do you want to help EPFL develop this plugin by uploading your usage data? ' +
-                'PLEASE BE AWARE that this will upload all of your keystrokes and all of your code, ' +
-                'among other things.',
-                'yes', 'no'
-            ).then((value: string | undefined) => {
-                if (value === 'yes' || value === 'no') this.tracingConsent.set(value);
-            });
+    private createStatusBarItem(): vscode.StatusBarItem | undefined {
+        if (!this.isTracingEnabled) return undefined;
+        const item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 0)
+        item.command = consentCommandName;
+        const renderStatusBarItem = () => {
+            item.text = (() => {
+                const desc = this.tracingConsent.get() === 'yes' ? 'ON' : 'OFF';
+                return `$(radio-tower) Dotty trace: ${desc}`;
+            })();
+
+            item.tooltip = (() => {
+                const desc = this.tracingConsent.get() === 'yes' ? 'consented' : 'not consented';
+                return `This workspace is configured for remote tracing of Dotty LSP and you have ${desc} to it. ` +
+                    'Click to adjust your consent.';
+            })();
         }
+        renderStatusBarItem();
+        this.tracingConsent.subscribe(renderStatusBarItem);
+        item.show();
+        return item;
+    }
+
+    private createLspOutputChannel(): vscode.OutputChannel | undefined {
+        if (!this.remoteTracingUrl) return undefined;
 
         const localLspOutputChannel = vscode.window.createOutputChannel('Dotty LSP Communication')
         try {
-            return this.createRemoteLspOutputChannel(remoteTracingUrl, localLspOutputChannel);
+            return this.createRemoteLspOutputChannel(this.remoteTracingUrl, localLspOutputChannel);
         } catch (err) {
             this.logError('error during remote output channel creation', safeError(err));
             return localLspOutputChannel;
@@ -97,6 +154,7 @@ export class Tracer {
 
     private asyncUploadWorkspaceDump(url: string) {
         const storagePath = this.ctx.extensionContext.storagePath;
+        // TODO: handle multi-root workspaces
         const rootPath = vscode.workspace.rootPath;
         if (storagePath === undefined || rootPath === undefined) {
             this.logError('Cannot start workspace dump b/c of workspace state:', { storagePath, rootPath });
@@ -106,7 +164,7 @@ export class Tracer {
         if (!fs.existsSync(storagePath)) fs.mkdirSync(storagePath);
         const outputPath = path.join(storagePath, 'workspace-dump.zip');
         if (fs.existsSync(outputPath)) fs.unlinkSync(outputPath);
-        let output = fs.createWriteStream(outputPath);
+        const output = fs.createWriteStream(outputPath);
         output.on('end', () => {
             this.ctx.extensionOut.appendLine('zip - data has been drained');
         });
@@ -138,57 +196,81 @@ export class Tracer {
             );
         });
         zip.pipe(output);
-        zip.glob('./**/*.{scala,sbt}', { cwd: rootPath });
+        zip.glob('./**/*.{scala,sc,sbt,java}', { cwd: rootPath });
+        zip.glob('./**/.dotty-ide{.json,-artifact}', { cwd: rootPath });
         zip.finalize();
     }
 
     private createRemoteLspOutputChannel(
         remoteTracingUrl: string,
         localOutputChannel: vscode.OutputChannel
     ): vscode.OutputChannel {
-        const socketHeaders = {
-            'X-DLS-Project-ID': this.projectId,
-            'X-DLS-Client-ID': this.machineId,
-            'X-DLS-Session-ID': this.sessionId,
-        };
+        const createSocket = () => {
+            const socket = new WebSocket(remoteTracingUrl, {
+                headers: {
+                    'X-DLS-Project-ID': this.projectId,
+                    'X-DLS-Client-ID': this.machineId,
+                    'X-DLS-Session-ID': this.sessionId,
+                },
+            });
+
+            const timer = setInterval(
+                () => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send('');
+                    } else if (socket.readyState === WebSocket.CLOSED) {
+                        clearInterval(timer);
+                    }
+                },
+                10 * 1000 /*ms*/,
+            )
+
+            socket.onerror = (event) => {
+                this.logErrorWithoutNotifying(
+                    'socket error',
+                    remoteTracingUrl,
+                    new SafeJsonifier(event, (event) => ({
+                        error: safeError(event.error),
+                        message: event.message,
+                        type: event.type
+                    }))
+                );
+                vscode.window.showWarningMessage('An error occured in Dotty LSP remote tracing connection.');
+            }
 
-        const socket = new WebSocket(remoteTracingUrl, { headers: socketHeaders });
+            socket.onclose = (event) => {
+                this.logErrorWithoutNotifying(
+                    'socket closed',
+                    remoteTracingUrl,
+                    new SafeJsonifier(event, (event) => ({
+                        wasClean: event.wasClean,
+                        code: event.code,
+                        reason: event.reason
+                    }))
+                );
+                vscode.window.showWarningMessage('Dotty LSP remote tracing connection was dropped.');
+            }
 
-        const timer = setInterval(
-            () => {
-                if (socket.readyState === WebSocket.OPEN) {
-                    socket.send('');
-                } else if (socket.readyState === WebSocket.CLOSED) {
-                    clearInterval(timer);
+            return socket;
+        };
+
+        let alreadyCreated = false;
+        let socket: WebSocket;
+        // note: creating socket lazily is important for correctness
+        // if the user did not initially give his consent on IDE start, but gives it afterwards
+        // we only want to start a connection and upload data *after* being given consent
+        const withSocket: (thunk: (socket: WebSocket) => any) => void = (thunk) => {
+            // only try to create the socket _once_ to avoid endlessly looping
+            if (!alreadyCreated) {
+                alreadyCreated = true;
+                try {
+                    socket = createSocket();
+                } catch (err) {
+                    this.logError('socket create error', safeError(err));
                 }
-            },
-            10 * 1000 /*ms*/,
-        )
-
-        socket.onerror = (event) => {
-            this.logErrorWithoutNotifying(
-                'socket error',
-                remoteTracingUrl,
-                new SafeJsonifier(event, (event) => ({
-                    error: safeError(event.error),
-                    message: event.message,
-                    type: event.type
-                }))
-            );
-            vscode.window.showWarningMessage('An error occured in Dotty LSP remote tracing connection.');
-        }
+            }
 
-        socket.onclose = (event) => {
-            this.logErrorWithoutNotifying(
-                'socket closed',
-                remoteTracingUrl,
-                new SafeJsonifier(event, (event) => ({
-                    wasClean: event.wasClean,
-                    code: event.code,
-                    reason: event.reason
-                }))
-            );
-            vscode.window.showWarningMessage('Dotty LSP remote tracing connection was dropped.');
+            if (socket) thunk(socket);
         }
 
         let log: string = '';
@@ -210,21 +292,23 @@ export class Tracer {
 
                 log += value;
                 log += '\n';
-                if (this.tracingConsent.get() === 'yes' && socket.readyState === WebSocket.OPEN) {
-                    socket.send(log, (err) => {
-                        if (err) {
-                            this.logError('socket send error', err)
-                        }
-                    });
-                    log = '';
-                }
+                if (this.tracingConsent.get() === 'yes') withSocket((socket) => {
+                    if (socket.readyState === WebSocket.OPEN) {
+                        socket.send(log, (err) => {
+                            if (err) {
+                                this.logError('socket send error', err)
+                            }
+                        });
+                        log = '';
+                    }
+                });
             },
 
             clear() { },
             show() { },
             hide() { },
             dispose() {
-                socket.close();
+                if (socket) socket.close();
                 localOutputChannel.dispose();
             }
         };

vscode-dotty/src/tracing-consent.ts

@@ -5,7 +5,9 @@ export type TracingConsent = 'yes' | 'no' | 'no-answer';
 export class TracingConsentCache {
     private readonly workspaceState: Memento
 
+    // since updating Memento is async, caching prevents nonsense edge-cases
     private cache?: TracingConsent
+    private subscribers: Array<() => void> = [];
 
     constructor(workspaceState: Memento) {
         this.workspaceState = workspaceState;
@@ -23,5 +25,10 @@ export class TracingConsentCache {
     set(value: 'yes' | 'no'): void {
       this.workspaceState.update('remote-tracing-consent', value === 'yes');
       this.cache = value;
+      this.subscribers.forEach(f => f());
+    }
+
+    subscribe(callback: () => void): void {
+      this.subscribers.push(callback);
     }
 }