Better telemetry

.vscode/launch.json

@@ -20,7 +20,8 @@
             "stopOnEntry": false,
             "sourceMaps": true,
             "outFiles": [ "${workspaceRoot}/dist/**/*.js" ],
-            "preLaunchTask": "compile"
+            "preLaunchTask": "compile",
+            "env": { "NODE_ENV": "development" },
         },
         {
             "name": "Launch Extension - No compiling",
@@ -30,6 +31,7 @@
             "args": ["${workspaceRoot}/.test-database/.", "--extensionDevelopmentPath=${workspaceRoot}"],
             "stopOnEntry": false,
             "sourceMaps": true,
+            "env": { "NODE_ENV": "development" },
             "outFiles": [ "${workspaceRoot}/dist/**/*.js" ],
         },
 
@@ -40,6 +42,7 @@
             "program": "${workspaceRoot}/node_modules/jest/bin/jest.js",
             "cwd": "${workspaceRoot}/.test-database/.",
             "preLaunchTask": "compile",
+            "env": { "NODE_ENV": "development" },
             "args": [
                 "--i",
                 "--coverage",

package.json

@@ -1,5 +1,5 @@
 {
-    "name": "sqltools-client",
+    "name": "sqltools",
     "displayName": "SQLTools",
     "description": "Your swiss knife SQL for VScode. Execute queries, auto complete, bookmarks etc.",
     "version": "0.11.2",
@@ -237,7 +237,7 @@
                         "WARN",
                         "ERROR"
                     ],
-                    "default": "DEBUG",
+                    "default": "INFO",
                     "description": "Show debugging messages on console."
                 },
                 "sqltools.queryTimeout": {
@@ -411,7 +411,7 @@
         }
     },
     "scripts": {
-        "vscode:prepublish": "npm run compile",
+        "vscode:prepublish": "npm run compile && npm test",
         "gulp": "./node_modules/.bin/gulp",
         "compile": "npm run gulp -- compile",
         "watch": "npm run gulp -- watch",
@@ -424,6 +424,7 @@
     "devDependencies": {
         "@types/jest": "^20.0.0",
         "@types/node": "^8.0.13",
+        "@types/universal-analytics": "^0.4.2",
         "babel-preset-es2015": "^6.24.1",
         "babel-preset-react": "^6.24.1",
         "babelify": "^8.0.0",
@@ -446,12 +447,12 @@
         "vscode": "^1.1.0"
     },
     "dependencies": {
-        "electron-google-analytics": "0.0.24",
         "mssql": "^4.0.4",
         "mysql2": "^1.5.1",
         "opn": "^5.1.0",
         "pg": "^7.4.0",
         "sql-formatter": "^2.1.0",
+        "universal-analytics": "^0.4.16",
         "uuid": "^3.1.0",
         "vscode-languageclient": "^3.5.0",
         "vscode-languageserver": "^3.5.0"

src/connection.ts

@@ -3,6 +3,7 @@ import Dialects from './api/dialect';
 import { ConnectionCredentials } from './api/interface/connection-credentials';
 import { ConnectionDialect } from './api/interface/connection-dialect';
 import DatabaseInterface from './api/interface/database-interface';
+import Telemetry from './telemetry';
 
 export default class Connection {
   private tables: DatabaseInterface.Table[] = [];
@@ -74,6 +75,7 @@ export default class Connection {
       .catch((e) => {
         if (!handleError) throw e;
         this.logger.error('Query error:', e);
+        Telemetry.registerException(e);
         let message = '';
         if (typeof e === 'string') {
           message = e;

src/constants.ts

@@ -7,8 +7,8 @@ import { Utils } from './api';
 const  pkg = require('./../package.json');
 
 export default class Constants {
-  public static gaCode = 'UA-110380775-2';
-  public static version      = `v${pkg.version}`;
+  public static gaCode = process.env.NODE_ENV !== 'development' ? 'UA-110380775-2' : 'UA-110380775-1';
+  public static version  = `v${pkg.version}`;
   public static extName = pkg.displayName;
   public static extNamespace = Constants.extName;
   public static outputChannelName = Constants.extName;

src/error-handler.ts

@@ -5,7 +5,7 @@ import { Logger } from './api';
 import Telemetry from './telemetry';
 
 function errorHandler(logger: Logger, message: string, error ?: Error, yesCallback?: Function): null {
-  Telemetry.errorMessage(message, error);
+  Telemetry.registerErrorMessage(message, error);
   if (error) {
     logger.error(`${message}: `, error.stack);
     message = `${message} ${error.toString().substr(0, 60)}${error.toString().length > 60 ? '...' : '.'}`;

src/languageserver/fomatter.ts

@@ -1,5 +1,9 @@
-import { DocumentFormattingParams, DocumentRangeFormattingParams, TextEdit } from 'vscode-languageclient';
-import { TextDocuments } from 'vscode-languageserver';
+import {
+  DocumentFormattingParams,
+  DocumentRangeFormattingParams,
+  TextDocuments,
+  TextEdit,
+} from 'vscode-languageserver';
 import { SelectionFormatter } from './../formatting-provider';
 import Logger from './logger';
 

src/languageserver/server.ts

@@ -37,7 +37,7 @@ connection.onDidChangeConfiguration((change) => {
   ConfigManager.setSettings(change.settings.sqltools);
   if (!formatterRegistration) {
     formatterRegistration = connection.client.register(DocumentRangeFormattingRequest.type, {
-      documentSelector: [ 'sql' ],
+      documentSelector: ConfigManager.get('completionLanguages', [ 'sql' ]),
     });
   }
 });

src/sqltools.ts

@@ -96,7 +96,6 @@ export default class SQLTools {
   private constructor(private context: ExtensionContext) {
     this.events = new EventEmitter();
     this.loadConfigs();
-    this.setupLogger();
     this.registerProviders();
     this.registerEvents();
     this.registerCommands();
@@ -392,7 +391,7 @@ export default class SQLTools {
 
   private autoConnectIfActive(currConn?: string) {
     const defaultConnection: string = currConn || ConfigManager.get('autoConnectTo', null) as string;
-    this.logger.debug(`Configuration set to auto connect to: ${defaultConnection}`);
+    this.logger.info(`Configuration set to auto connect to: ${defaultConnection}`);
     if (!defaultConnection) {
       return this.setConnection();
     }
@@ -412,6 +411,7 @@ export default class SQLTools {
     }
     this.setupLogger();
     this.registerTelemetry();
+    this.logger.debug(`Env: ${process.env.NODE_ENV}`);
   }
   private setupLogger() {
     this.outputLogs = new LogWriter();
@@ -448,12 +448,11 @@ export default class SQLTools {
   private registerCommand(command: string, registerFunction: Function) {
     this.logger.debug(`Registering command ${Constants.extNamespace}.${command}`);
     this.events.on(command, (...event) => {
-      this.logger.debug(`Event received: ${command}`);
       this[command](...event);
     });
     this.context.subscriptions.push(registerFunction(`${Constants.extNamespace}.${command}`, (...args) => {
-      this.logger.debug(`Triggering command: ${command}`);
-      Telemetry.registerCommandUsage(command);
+      this.logger.debug(`Command triggered: ${command}`, args);
+      Telemetry.registerCommand(command);
       this.events.emit(command, ...args);
     }));
   }
@@ -518,7 +517,7 @@ export default class SQLTools {
   private reloadConfig() {
     const currentConnection = this.activeConnection ? this.activeConnection.getName() : null;
     ConfigManager.setSettings(Workspace.getConfiguration(Constants.extNamespace.toLocaleLowerCase()) as Settings);
-    this.logger.debug('Config reloaded!');
+    this.logger.info('Config reloaded!');
     this.loadConfigs();
     this.autoConnectIfActive(currentConnection);
     this.updateStatusBar();
@@ -599,7 +598,7 @@ export default class SQLTools {
     );
 
     languageClient.onReady().then(() => {
-      this.logger.debug('Language server started!');
+      this.logger.info('Language server started!');
       this.languageClient = languageClient;
     }, (error) => errorHandler(this.logger, 'Ops, we\'ve got an error!', error, this.showOutputChannel));
     this.context.subscriptions.push(languageClient.start());
@@ -630,7 +629,7 @@ export default class SQLTools {
     }
     Window.showInformationMessage(message, ...options)
       .then((value) => {
-        Telemetry.infoMessage(message, value);
+        Telemetry.registerInfoMessage(message, value);
         switch (value) {
           case moreInfo:
             openurl('https://github.com/mtxr/vscode-sqltools#donate');

src/suggestions-provider.ts

@@ -12,6 +12,7 @@ import { Logger } from './api';
 import { ConnectionCredentials } from './api/interface/connection-credentials';
 import DatabaseInterface from './api/interface/database-interface';
 import Connection from './connection';
+import Telemetry from './telemetry';
 
 class TableCompletionItem extends CompletionItem {
   constructor(table: DatabaseInterface.Table) {
@@ -105,6 +106,7 @@ export class SuggestionsProvider implements CompletionItemProvider {
         this.completionItems.push(...columns.map((col) => new TableColumnCompletionItem(col)));
       }).catch((e) => {
         this.logger.error('Error while preparing columns completions', e);
+        Telemetry.registerException(e);
       });
   }
 }

src/telemetry.ts

@@ -1,6 +1,6 @@
-/// <reference path="./../node_modules/@types/node/index.d.ts" />
+/// <reference path="../node_modules/@types/universal-analytics/index.d.ts" />
 
-import Analytics from 'electron-google-analytics';
+import Analytics = require('universal-analytics');
 import {
   workspace as Workspace,
   WorkspaceConfiguration,
@@ -20,37 +20,37 @@ export default class Telemetry {
     } else {
       Telemetry.disable();
     }
-    Telemetry.analytics = new Analytics(Telemetry.uaCode);
     Telemetry.extensionUUID = Telemetry.extensionUUID || ConfigManager.get('telemetryUUID', null) as string;
-    Telemetry.logger.info(`Telemetry UUID: ${Telemetry.extensionUUID}`);
+    Telemetry.logger.debug(`Telemetry UUID: ${Telemetry.extensionUUID}`);
     if (Telemetry.extensionUUID === null) {
       Telemetry.extensionUUID = uuidv4();
+      Telemetry.start();
       Workspace.getConfiguration(Constants.extNamespace.toLocaleLowerCase())
         .update('telemetryUUID', Telemetry.extensionUUID, true)
         .then(
           (ok) => {
             Telemetry.registerEvent('evt:install', Constants.version, 'installed');
-            Telemetry.logger.info('New install registerd', ok);
-          },
-          (err) => Telemetry.logger.error('Register pageview error', err),
+            Telemetry.logger.debug('New install registerd', ok);
+          }, Telemetry.errorHandler('save UUID'),
         );
-      Telemetry.logger.info(`Telemetry random UUID generated: ${Telemetry.extensionUUID}`);
+      Telemetry.logger.debug(`Telemetry random UUID generated: ${Telemetry.extensionUUID}`);
+    } else {
+      Telemetry.start();
     }
-    Telemetry.analytics.pageview('vscode', '/session-started', 'Started', Telemetry.extensionUUID)
-      .catch((err) => Telemetry.logger.error('Register pageview error', err));
+    Telemetry.registerSession('started');
   }
 
-  public static registerCommandUsage(command: string) {
+  public static registerCommand(command: string) {
     Telemetry.registerEvent(`cmd:${command}`, Constants.version);
   }
-  public static infoMessage(message, value = 'Dismissed') {
-    Telemetry.registerEvent('msg:info', message, value);
+  public static registerInfoMessage(message, value = 'Dismissed') {
+    Telemetry.registerMessage('info', message, value);
   }
 
-  public static errorMessage(message, error?: Error) {
-    Telemetry.registerEvent('msg:error', message, 'Dismissed');
+  public static registerErrorMessage(message, error?: Error) {
+    Telemetry.registerMessage('error', message, 'Dismissed');
     if (error) {
-      Telemetry.analytics.exception(error.message ? error.message : error, 0);
+      Telemetry.registerException(error);
     }
   }
 
@@ -65,22 +65,43 @@ export default class Telemetry {
   public static setLogger(logger: any = Logger) {
     Telemetry.logger = logger;
   }
+  public static registerSession(evt: string) {
+    if (!Telemetry.isEnabled) return;
+    Telemetry.analytics.screenview(evt, `vscode-sqltools`, Constants.version, Telemetry.errorHandler('screenview'));
+  }
+  public static registerMessage(type: string, message: string, value: string = 'Dismissed'): void {
+    Telemetry.registerEvent(`msg:${type}`, message, value);
+  }
+  public static registerEvent(category: string, event: string, label?: string): void {
+    if (!Telemetry.isEnabled) return;
+    Telemetry.analytics.event(category, event, label || event, Telemetry.errorHandler('event'));
+  }
+
+  public static registerException(error: Error | string) {
+    if (!Telemetry.isEnabled) return;
+    Telemetry.analytics.exception(
+      ((error as Error).message || error) as string,
+      false,
+      Telemetry.errorHandler('exception'),
+    );
+  }
 
   private static isEnabled: Boolean = true;
   private static logger: any = console;
   private static config: WorkspaceConfiguration;
   private static extensionUUID: string;
-  private static analytics: Analytics;
+  private static analytics: Analytics.Visitor;
   private static uaCode: string = Constants.gaCode;
 
-  private static registerEvent(category: string, event: string, label?: string): void {
-    if (!Telemetry.isEnabled) return;
-    const params = {
-      ea: event,
-      ec: category,
-      el: label || event,
+  private static start() {
+    Telemetry.analytics = Analytics(Telemetry.uaCode, Telemetry.extensionUUID, { strictCidFormat: false });
+    Telemetry.analytics.set('uid', Telemetry.extensionUUID);
+  }
+
+  private static errorHandler(type: string) {
+    return (error?: Error) => {
+      if (!error) return;
+      Telemetry.logger.error(`Telemetry:${type} error`, error);
     };
-    Telemetry.analytics.send('event', params, Telemetry.extensionUUID)
-      .catch((err) => Telemetry.logger.error('Register event error', err));
   }
 }