Merge pull request #62 from DeepCodeAI/tracking

Tracking

Author: Arvi3d

src/deepcode/DeepCodeExtension.ts

@@ -9,17 +9,17 @@ import {
   DEEPCODE_SETMODE_COMMAND,
   DEEPCODE_SETTINGS_COMMAND,
   DEEPCODE_DCIGNORE_COMMAND,
-  DEEPCODE_LOGIN,
-  DEEPCODE_APPROVE,
-  DEEPCODE_OPEN_BROWSER,
-  DEEPCODE_OPEN_LOCAL,
+  DEEPCODE_LOGIN_COMMAND,
+  DEEPCODE_APPROVE_COMMAND,
+  DEEPCODE_OPEN_BROWSER_COMMAND,
+  DEEPCODE_OPEN_LOCAL_COMMAND,
+  DEEPCODE_OPEN_ISSUE_COMMAND,
 } from "./constants/commands";
 import {
   openDeepcodeSettingsCommand,
   createDCIgnoreCommand,
 } from "./utils/vscodeCommandsUtils";
 import { errorsLogs } from "./messages/errorsServerLogMessages";
-
 import {
   DEEPCODE_VIEW_SUPPORT,
   DEEPCODE_VIEW_ANALYSIS,
@@ -47,23 +47,23 @@ class DeepCodeExtension extends DeepCodeLib implements DeepCode.ExtensionInterfa
 
     context.subscriptions.push(
       vscode.commands.registerCommand(
-        DEEPCODE_OPEN_BROWSER,
+        DEEPCODE_OPEN_BROWSER_COMMAND,
         this.executeCommand.bind(
           this,
-          DEEPCODE_OPEN_BROWSER,
+          DEEPCODE_OPEN_BROWSER_COMMAND,
           (url: string) => open(url)
         )
       )
     );
 
     context.subscriptions.push(
       vscode.commands.registerCommand(
-        DEEPCODE_OPEN_LOCAL,
+        DEEPCODE_OPEN_LOCAL_COMMAND,
         (path: vscode.Uri, range?: vscode.Range) => {
           vscode.window.showTextDocument(path, { selection: range }).then(
             // no need to wait for processError since then is called asynchronously as well
             () => {}, (err) => this.processError(err, {
-              message: errorsLogs.command(DEEPCODE_OPEN_LOCAL),
+              message: errorsLogs.command(DEEPCODE_OPEN_LOCAL_COMMAND),
             })
           );
         }
@@ -72,21 +72,21 @@ class DeepCodeExtension extends DeepCodeLib implements DeepCode.ExtensionInterfa
 
     context.subscriptions.push(
       vscode.commands.registerCommand(
-        DEEPCODE_LOGIN,
+        DEEPCODE_LOGIN_COMMAND,
         this.executeCommand.bind(
           this,
-          DEEPCODE_LOGIN,
+          DEEPCODE_LOGIN_COMMAND,
           this.initiateLogin.bind(this)
         )
       )
     );
 
     context.subscriptions.push(
       vscode.commands.registerCommand(
-        DEEPCODE_APPROVE,
+        DEEPCODE_APPROVE_COMMAND,
         this.executeCommand.bind(
           this,
-          DEEPCODE_APPROVE,
+          DEEPCODE_APPROVE_COMMAND,
           this.approveUpload.bind(this)
         )
       )
@@ -125,6 +125,27 @@ class DeepCodeExtension extends DeepCodeLib implements DeepCode.ExtensionInterfa
       )
     );
 
+    context.subscriptions.push(
+      vscode.commands.registerCommand(
+        DEEPCODE_OPEN_ISSUE_COMMAND,
+        this.executeCommand.bind(
+          this,
+          DEEPCODE_OPEN_ISSUE_COMMAND,
+          async (
+            issueId: string,
+            severity: number,
+            uri: vscode.Uri,
+            range: vscode.Range,
+          ) => {
+            await vscode.commands.executeCommand(
+              DEEPCODE_OPEN_LOCAL_COMMAND, uri, range
+            );
+            await this.trackViewSuggestion(issueId, severity);
+          }
+        )
+      )
+    );
+
     context.subscriptions.push(
       vscode.commands.registerCommand(
         DEEPCODE_DCIGNORE_COMMAND,
@@ -153,6 +174,9 @@ class DeepCodeExtension extends DeepCodeLib implements DeepCode.ExtensionInterfa
     this.checkWelcomeNotification().catch((err) => this.processError(err, {
       message: errorsLogs.welcomeNotification,
     }));
+    this.checkAdvancedMode().catch((err) => this.processError(err, {
+      message: errorsLogs.checkAdvancedMode,
+    }));
   }
 
 }

src/deepcode/constants/commands.ts

@@ -5,14 +5,15 @@ export const VSCODE_ADD_COMMENT_COMMAND = "editor.action.addCommentLine";
 
 // custom depcode commands
 export const DEEPCODE_START_COMMAND = "deepcode.start";
-export const DEEPCODE_LOGIN = "deepcode.login";
-export const DEEPCODE_APPROVE = "deepcode.approve";
+export const DEEPCODE_LOGIN_COMMAND = "deepcode.login";
+export const DEEPCODE_APPROVE_COMMAND = "deepcode.approve";
 export const DEEPCODE_SETMODE_COMMAND = "deepcode.setmode";
 export const DEEPCODE_SETTINGS_COMMAND = "deepcode.settings";
-export const DEEPCODE_IGNORE_ISSUES_COMMAND = "deepcode.ignoreissues";
 export const DEEPCODE_DCIGNORE_COMMAND = "deepcode.dcignore";
-export const DEEPCODE_OPEN_BROWSER = "deepcode.open";
-export const DEEPCODE_OPEN_LOCAL = "deepcode.show";
+export const DEEPCODE_OPEN_BROWSER_COMMAND = "deepcode.open";
+export const DEEPCODE_OPEN_LOCAL_COMMAND = "deepcode.show";
+export const DEEPCODE_OPEN_ISSUE_COMMAND = "deepcode.showissue"
+export const DEEPCODE_IGNORE_ISSUE_COMMAND = "deepcode.ignoreissue";
 
 // custom depcode constants used in commands
 export const DEEPCODE_CONTEXT_PREFIX = "deepcode:";

src/deepcode/constants/telemetry.ts

@@ -1,4 +1,10 @@
 export const TELEMETRY_EVENTS = {
-  ignoreSuggestion: 'ignoreSuggestion',
+  viewWelcomeNotification: 'viewWelcomeNotification',
+  viewLoginView: 'viewLogin',
+  viewConsentView: 'viewConsent',
+  viewSuggestionView: 'viewSuggestionView',
   viewSuggestion: 'viewSuggestion',
+  ignoreSuggestion: 'ignoreSuggestion',
+  toggleAdvancedMode: 'toggleAdvancedMode',
+  changeExecutionMode: 'changeExecutionMode',
 };

src/deepcode/lib/analyzer/DeepCodeAnalyzer.ts

@@ -38,9 +38,7 @@ class DeepCodeAnalyzer implements DeepCode.AnalyzerInterface {
     this.ignoreActionsProvider = new DisposableCodeActionsProvider(
       this.deepcodeReview,
       {
-        findSuggestionId: extractSuggestionIdFromSuggestionsMap(
-          this.analysisResultsCollection
-        ),
+        findSuggestionId: this.findSuggestionId.bind(this),
         trackIgnoreSuggestion: this.trackIgnoreSuggestion.bind(this)
       }
     );
@@ -51,13 +49,21 @@ class DeepCodeAnalyzer implements DeepCode.AnalyzerInterface {
     this.extension = extension;
   }
 
+  public findSuggestionId(suggestionName: string, fileSystemPath: string): string {
+    return extractSuggestionIdFromSuggestionsMap(
+      this.analysisResultsCollection,
+      suggestionName,
+      fileSystemPath
+    );
+  }
+
   public trackIgnoreSuggestion(vscodeSeverity: number, options: {[key: string]: any}): void {
     if (!this.extension) return;
     options.data = {
       severity: getDeepCodeSeverity(vscodeSeverity),
       ...options.data
     };
-    this.extension.sendEvent(
+    this.extension.processEvent(
       TELEMETRY_EVENTS.ignoreSuggestion,
       options
     );

src/deepcode/lib/deepCodeProviders/codeActionsProvider/DeepCodeIssuesActionsProvider.ts

@@ -10,7 +10,7 @@ import {
   IGNORE_ISSUE_BASE_COMMENT_TEXT
 } from "../../../constants/analysis";
 import {
-  DEEPCODE_IGNORE_ISSUES_COMMAND,
+  DEEPCODE_IGNORE_ISSUE_COMMAND,
   VSCODE_ADD_COMMENT_COMMAND
 } from "../../../constants/commands";
 
@@ -35,7 +35,7 @@ export class DeepCodeIssuesActionProvider implements vscode.CodeActionProvider {
 
   private registerIgnoreIssuesCommand() {
     vscode.commands.registerCommand(
-      DEEPCODE_IGNORE_ISSUES_COMMAND,
+      DEEPCODE_IGNORE_ISSUE_COMMAND,
       ({
         currentEditor,
         issueText,
@@ -149,8 +149,8 @@ export class DeepCodeIssuesActionProvider implements vscode.CodeActionProvider {
       isFileIgnore
     );
     ignoreIssueAction.command = {
-      command: DEEPCODE_IGNORE_ISSUES_COMMAND,
-      title: DEEPCODE_IGNORE_ISSUES_COMMAND,
+      command: DEEPCODE_IGNORE_ISSUE_COMMAND,
+      title: DEEPCODE_IGNORE_ISSUE_COMMAND,
       arguments: [{ issueText, matchedIssue, issueId: issueFullId, isFileIgnore }]
     };
 

src/deepcode/lib/modules/BaseDeepCodeModule.ts

@@ -10,9 +10,9 @@ import DeepCodeSettingsWatcher from "../watchers/DeepCodeSettingsWatcher";
 import { PendingTask, PendingTaskInterface } from "../../utils/pendingTask";
 import { IDE_NAME, REFRESH_VIEW_DEBOUNCE_INTERVAL } from "../../constants/general";
 import { setContext } from "../../utils/vscodeCommandsUtils";
-import { DEEPCODE_VIEW_ANALYSIS } from "../../constants/views";
+import { DEEPCODE_CONTEXT, DEEPCODE_VIEW_ANALYSIS } from "../../constants/views";
+import { TELEMETRY_EVENTS } from "../../constants/telemetry";
 import { errorsLogs } from '../../messages/errorsServerLogMessages';
-import { pendingMocks } from 'nock/types';
 
 export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCodeModuleInterface {
   currentWorkspacePath: string;
@@ -33,6 +33,7 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
   analysisProgress = 0;
   private initializedView: PendingTaskInterface;
   private progressBadge: PendingTaskInterface | undefined;
+  private shouldShowProgressBadge = false;
   private viewContext: {[key: string]: unknown};
 
   // These attributes are used in tests
@@ -113,19 +114,73 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
 
   async setContext(key: string, value: unknown): Promise<void> {
     console.log("DeepCode context", key, value);
+    const oldValue = this.viewContext[key];
     this.viewContext[key] = value;
     await setContext(key, value);
     this.refreshViews();
+    this.trackContextChange(key, value, oldValue);
+  }
+
+  private trackContextChange(key: string, value: unknown, oldValue: unknown) {
+    let event = "";
+    let shouldWaitForView = true;
+    let options: Record<string,any> | undefined;
+    switch(key) {
+      case DEEPCODE_CONTEXT.LOGGEDIN: {
+        if (oldValue !== undefined) {
+          if (!value && oldValue) event = TELEMETRY_EVENTS.viewLoginView;
+          if (value && !oldValue) event = TELEMETRY_EVENTS.viewConsentView;
+        } else {
+          // If key was un-initialized (i.e. at start), we still report it if new value is false
+          if (!value) event = TELEMETRY_EVENTS.viewLoginView;
+        }
+        break;
+      }
+      case DEEPCODE_CONTEXT.APPROVED: {
+        if (oldValue !== undefined) {
+          if (!value && oldValue) event = TELEMETRY_EVENTS.viewConsentView;
+          if (value && !oldValue) event = TELEMETRY_EVENTS.viewSuggestionView;
+        }
+        break;
+      }
+      case DEEPCODE_CONTEXT.ADVANCED: {
+        if (oldValue !== undefined) {
+          event = TELEMETRY_EVENTS.toggleAdvancedMode;
+          options = { data: { value } };
+          shouldWaitForView = false;
+        }
+        break;
+      }
+      case DEEPCODE_CONTEXT.MODE: {
+        event = TELEMETRY_EVENTS.changeExecutionMode;
+        options = { data: { value } };
+        shouldWaitForView = false;
+        break;
+      }
+    }
+    // We want to fire the event only when the user actually sees the View
+    if (event) {
+      if (shouldWaitForView) this.initializedView.waiter.then(
+        () => this.processEvent(event, options)
+      );
+      else this.processEvent(event, options);
+    }
   }
 
   get shouldShowAnalysis(): boolean {
-    return !this.viewContext['error'] && 
-      ['loggedIn', 'uploadApproved', 'workspaceFound'].every(
-        (c) => !!this.viewContext[c]
-      );
+    return !this.viewContext[
+      DEEPCODE_CONTEXT.ERROR
+    ] && [
+      DEEPCODE_CONTEXT.LOGGEDIN,
+      DEEPCODE_CONTEXT.APPROVED,
+      DEEPCODE_CONTEXT.ANALYZING,
+    ].every(
+      (c) => !!this.viewContext[c]
+    );
   }
 
   private getProgressBadgePromise(): Promise<void> {
+    if (!this.shouldShowProgressBadge) return Promise.resolve();
     if (!this.progressBadge || this.progressBadge.isCompleted) {
       this.progressBadge = new PendingTask();
     }
@@ -134,6 +189,7 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
 
   // Leave viewId undefined to remove the badge from all views
   async setLoadingBadge(value: boolean): Promise<void> {
+    this.shouldShowProgressBadge = value;
     if (value) {
       // Using closure on this to allow partial binding in arbitrary positions
       const self = this;
@@ -172,5 +228,10 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
     options?: { [key: string]: any }
   ): Promise<void>;
 
+  abstract processEvent(
+    event: string,
+    options?: { [key: string]: any }
+  ): Promise<void>;
+
   abstract startExtension(): Promise<void>;
 }

src/deepcode/lib/modules/DeepCodeLib.ts

@@ -43,15 +43,13 @@ export default class DeepCodeLib extends BundlesModule implements DeepCode.DeepC
   private async executeExtensionPipeline(): Promise<void> {
     console.log("DeepCode: starting execution pipeline");
     await this.setContext(DEEPCODE_CONTEXT.ERROR, false);
+    this.resetTransientErrors();
     await this.setLoadingBadge(false);
 
     const loggedIn = await this.checkSession();
-    if (!loggedIn) return;
     const approved = await this.checkApproval();
-    if (!approved) return;
+    if (!loggedIn || !approved) return;
     await this.startAnalysis();
-    
-    this.resetTransientErrors();
   }
 
   // This function is called by commands, error handlers, etc.

src/deepcode/lib/modules/LoginModule.ts

@@ -7,6 +7,7 @@ import { DEEPCODE_CONTEXT } from "../../constants/views";
 import { openDeepcodeViewContainer } from "../../utils/vscodeCommandsUtils";
 import { errorsLogs } from "../../messages/errorsServerLogMessages";
 import { deepCodeMessages } from "../../messages/deepCodeMessages";
+import { TELEMETRY_EVENTS } from "../../constants/telemetry";
 
 const sleep = (duration: number) => new Promise(resolve => setTimeout(resolve, duration));
 
@@ -83,6 +84,7 @@ abstract class LoginModule extends ReportModule implements DeepCode.LoginModuleI
 
   async checkWelcomeNotification(): Promise<void> {
     if (this.shouldShowWelcomeNotification) {
+      this.processEvent(TELEMETRY_EVENTS.viewWelcomeNotification);
       let pressedButton = await vscode.window.showInformationMessage(
         deepCodeMessages.welcome.msg,
         deepCodeMessages.welcome.button