Merge pull request #1069 from DustinCampbell/project-telemetry

Add telemetry for the sorts of projects OmniSharp is started on

Author: DustinCampbell

src/common.ts

@@ -29,6 +29,15 @@ export function isBoolean(obj: any): obj is boolean {
     return obj === true || obj === false;
 }
 
+export function sum<T>(arr: T[], selector: (item: T) => number): number {
+    return arr.reduce((prev, curr) => prev + selector(curr), 0);
+}
+
+/** Retrieve the length of an array. Returns 0 if the array is `undefined`. */
+export function safeLength<T>(arr: T[] | undefined) {
+    return arr ? arr.length : 0;
+}
+
 export function buildPromiseChain<T, TResult>(array: T[], builder: (item: T) => Promise<TResult>): Promise<TResult> {
     return array.reduce(
         (promise, n) => promise.then(() => builder(n)),

src/omnisharp/extension.ts

@@ -18,14 +18,16 @@ import RenameProvider from '../features/renameProvider';
 import FormatProvider from '../features/formattingEditProvider';
 import CompletionItemProvider from '../features/completionItemProvider';
 import WorkspaceSymbolProvider from '../features/workspaceSymbolProvider';
-import reportDiagnostics, {Advisor} from '../features/diagnosticsProvider';
+import reportDiagnostics, { Advisor } from '../features/diagnosticsProvider';
 import SignatureHelpProvider from '../features/signatureHelpProvider';
 import registerCommands from '../features/commands';
 import forwardChanges from '../features/changeForwarding';
 import reportStatus from '../features/status';
-import {OmniSharpServer} from './server';
-import {Options} from './options';
-import {addAssetsIfNecessary, AddAssetResult} from '../assets';
+import { OmniSharpServer } from './server';
+import { Options } from './options';
+import { addAssetsIfNecessary, AddAssetResult } from '../assets';
+import { sum, safeLength } from '../common';
+import * as utils from './utils';
 
 export function activate(context: vscode.ExtensionContext, reporter: TelemetryReporter) {
     const documentSelector: vscode.DocumentSelector = {
@@ -82,6 +84,30 @@ export function activate(context: vscode.ExtensionContext, reporter: TelemetryRe
         }));
     }
 
+    // Send telemetry about the sorts of projects the server was started on.
+    disposables.push(server.onServerStart(() => {
+        let measures: { [key: string]: number } = {};
+
+         utils.requestWorkspaceInformation(server)
+            .then(workspaceInfo => {
+                if (workspaceInfo.DotNet && workspaceInfo.DotNet.Projects.length > 0) {
+                    measures['projectjson.projectcount'] = workspaceInfo.DotNet.Projects.length;
+                    measures['projectjson.filecount'] = sum(workspaceInfo.DotNet.Projects, p => safeLength(p.SourceFiles));
+                }
+
+                if (workspaceInfo.MsBuild && workspaceInfo.MsBuild.Projects.length > 0) {
+                    measures['msbuild.projectcount'] = workspaceInfo.MsBuild.Projects.length;
+                    measures['msbuild.filecount'] = sum(workspaceInfo.MsBuild.Projects, p => safeLength(p.SourceFiles));
+                    measures['msbuild.unityprojectcount'] = sum(workspaceInfo.MsBuild.Projects, p => p.IsUnityProject ? 1 : 0);
+                    measures['msbuild.netcoreprojectcount'] = sum(workspaceInfo.MsBuild.Projects, p => utils.isNetCoreProject(p) ? 1 : 0);
+                }
+
+                // TODO: Add measurements for script.
+
+                reporter.sendTelemetryEvent('OmniSharp.Start', null, measures);
+            });
+    }));
+
     // read and store last solution or folder path
     disposables.push(server.onBeforeServerStart(path => context.workspaceState.update('lastSolutionPathOrFolder', path)));
 

src/omnisharp/utils.ts

@@ -83,4 +83,8 @@ export function getTestStartInfo(server: OmniSharpServer, request: protocol.V2.G
 
 export function runDotNetTest(server: OmniSharpServer, request: protocol.V2.RunDotNetTestRequest) {
     return server.makeRequest<protocol.V2.RunDotNetTestResponse>(protocol.V2.Requests.RunDotNetTest, request);
+}
+
+export function isNetCoreProject(project: protocol.MSBuildProject) {
+    return project.TargetFrameworks.find(tf => tf.ShortName.startsWith('netcoreapp') || tf.ShortName.startsWith('netstandard')) !== undefined;
 }

test/common.test.ts

@@ -4,22 +4,64 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { should } from 'chai';
-import { buildPromiseChain } from '../src/common';
+import { buildPromiseChain, safeLength, sum } from '../src/common';
 
 suite("Common", () => {
     suiteSetup(() => should());
 
-    test("buildPromiseChain produces a sequence of promises", () => {
-        let array: number[] = [];
-        let items = [1, 2, 3, 4, 5];
+    suite("buildPromiseChain", () => {
+        test("produce a sequence of promises", () => {
+            let array: number[] = [];
+            let items = [1, 2, 3, 4, 5];
 
-        let promise = buildPromiseChain(items, n => new Promise((resolve, reject) => {
-            array.push(n);
-            resolve();
-        }));
+            let promise = buildPromiseChain(items, n => new Promise((resolve, reject) => {
+                array.push(n);
+                resolve();
+            }));
 
-        return promise.then(() => {
-            array.should.deep.equal([1, 2, 3, 4, 5]);
+            return promise.then(() => {
+                array.should.deep.equal([1, 2, 3, 4, 5]);
+            });
+        });
+    });
+
+    suite("safeLength", () => {
+        test("return 0 for empty array", () => {
+            let array = [];
+            let result = safeLength(array);
+            result.should.equal(0);
+        });
+
+        test("returns 5 for array of 5 elements", () => {
+            let array = [1, 2, 3, 4, 5];
+            let result = safeLength(array);
+            result.should.equal(5);
+        });
+
+        test("returns 0 for undefined", () => {
+            let array = undefined;
+            let result = safeLength(array);
+            result.should.equal(0);
+        });
+    });
+
+    suite("sum", () => {
+        test("produce total from numbers", () => {
+            let array = [1, 2, 3, 4, 5];
+            let result = sum(array, i => i);
+            result.should.equal(15);
+        });
+
+        test("produce total from lengths of arrays", () => {
+            let array = [[1, 2], [3], [], [4, 5, 6]];
+            let result = sum(array, i => i.length);
+            result.should.equal(6);
+        });
+
+        test("produce total of true values from array of booleans", () => {
+            let array = [true, false, false, true, true, true, false, true];
+            let result = sum(array, b => b ? 1 : 0);
+            result.should.equal(5);
         });
     });
 });