Improve analytics

We have a requirement to track information in several different providers. However, this may slow down CLI's operations as each track (at least for some of the providers) may last around 100-300ms.
In order to track in multiple analytics provider without slowing down CLI commands, move the tracking to a new process. The process is detached from CLI, so when CLI finishes its work it will exit, while the child process will remain alive until it sends all required information. The new process is called `analytics-broker-process`, it is detached from CLI, but it there's IPC channel between them, so CLI can send information to be tracked. Just before CLI dies, it will send "finish" message to the `broker` process and the IPC channel will be closed.

In CLI implement a new `analytics-service`, so when the methods `track`, `trackFeature` and `trackException` are called, instead of tracking directly in CLI's process (i.e. the old implementation), to send information to the broker process.
The only exception is tracking of the answer if user allows us to send anonymous statistics. As this action requires user interaction, it is executed in CLI's process, a new eqatec analytics monitor is started and the answer is sent to it. After that the analytics is stopped. In case the answer is "yes" and there is more information that we want to track in the current process, it will be send to broker and tracked in all providers. In case the answer is "no", no other data will be tracked.

The broker process is started from analytics process once per process, i.e. on each CLI process (which have something to track) there's a corresponding `analytics-broker-process`. Once it is initialized, it sends BrokerReadyToReceive message to CLI and CLI knows that it can start sending tracking information. Initialization phase is creating a new instance of AnalyticsBroker and attaching handlers for `message` and `disconnect` events. The AnalyitcsBroker itself has a single purpose - sends tracking data to all available prociders. Currently the only provider is `eqatecAnalyticsProvider`. Once CLI sends "finish" message (or `analytics-broker-process` receives `disconnect` event), the process sends information to all providers that there's nothing more to be tracked. When all providers finish their work, they should disocnnect themselves from the broker process and it will exit gracefully.

`EqatecAnalyticsProvider` is used to track features and exceptions in Progress Telerik Analytics. Our requirement is to track features in two projects (same data should be send to both of them) and exceptions in another project. Each of them should be in a separate child process, so failure in one of them will not reflect the others. So the provider starts all required processes. When broker sends information to the provider, it sends it to all required child processes, for example if a feature should be tracked, the provider will send information for it to the two processes used for feature tracking.

Each eqatec child process is a new Node.js  process runnign `eqatec-analytics-process`. Again - this is a detached process. Once it is initialized, it sends "EqatecAnalyticsReadyToReceive" message to the `EqatecAnalyitcsProvider` and it knows it can send information to the new child process. The initialization phase is creation of new instance of `EqatectAnalyticsService`, attaching to "message" and "disconnect" events. Once `EqatecAnalyitcsProvider` receives `EqatecAnalyticsReadyToReceive` message, it sends initialization data for the eqatec monitor. It includes the analytics project API key, user id, current sessions count, etc. The information is persisted in a file on user's machine, so this file should be updated from a single process. As we might have 3 eqatec analytics processes, the provider is the only place where the file should be read and updated.

When `eqatec-analytics-process` receives initialization data, it creates a new instance of the `EqatectAnalyticsService` class with it. However a monitor is not started yet. It will be started when there's something to be tracked, i.e. once `eqatec-analytics-process` receives feature or exception to be tracked.

When `eqatec-analytics-process` receives "finish" message, it awaits all pending requests and after that disconnets itself from the parent. In case this operation fails, the process just exits, which will allow the parent to exit gracefully.

Remove the public `startEqatecMonitor` method from API - it has not been used.

Author: rosen-vladimirov

.vscode/launch.json

@@ -67,8 +67,19 @@
 		{
 			"type": "node",
 			"request": "attach",
-			"name": "Attach to Process",
-			"port": 5858,
+			"name": "Attach to Broker Process",
+			// In case you want to debug Analytics Broker process, add `--debug-brk=9897` (or --inspect-brk=9897) when spawning analytics-broker-process.
+			"port": 9897,
+			"sourceMaps": true
+		},
+
+		{
+			"type": "node",
+			"request": "attach",
+			"name": "Attach to Eqatec Process",
+			// In case you want to debug Eqatec Analytics process, add `--debug-brk=9855` (or --inspect-brk=9855) when spawning eqatec-analytics-process.
+			// NOTE: Ensure you set it only for one of the analytics processes.
+			"port": 9855,
 			"sourceMaps": true
 		}
 

PublicAPI.md

@@ -390,21 +390,6 @@ tns.npm.view(["nativescript"], {}).then(result => {
 });
 ```
 
-## analyticsService
-Provides a way to configure analytics.
-
-### startEqatecMonitor
-* Definition:
-```TypeScript
-/**
- * Starts analytics monitor with provided key.
- * @param {string} projectApiKey API key with which to start analytics monitor.
- * @returns {Promise<void>}.
- */
-startEqatecMonitor(projectApiKey: string): Promise<void>;
-```
-
-
 ## debugService
 Provides methods for debugging applications on devices. The service is also event emitter, that raises the following events:
 * `connectionError` event - this event is raised when the debug operation cannot start on iOS device. The causes can be:

lib/bootstrap.ts

@@ -30,7 +30,8 @@ $injector.require("androidDebugService", "./services/android-debug-service");
 
 $injector.require("userSettingsService", "./services/user-settings-service");
 $injector.require("analyticsSettingsService", "./services/analytics-settings-service");
-$injector.requirePublic("analyticsService", "./services/analytics-service");
+$injector.requirePublic("analyticsService", "./services/analytics/analytics-service");
+$injector.require("eqatecAnalyticsProvider", "./services/analytics/eqatec-analytics-provider");
 
 $injector.require("emulatorSettingsService", "./services/emulator-settings-service");
 

lib/common

@@ -73,7 +73,7 @@ export class StaticConfig extends StaticConfigBase implements IStaticConfig {
 	}
 
 	public get PATH_TO_BOOTSTRAP(): string {
-		return path.join(__dirname, "bootstrap");
+		return path.join(__dirname, "bootstrap.js");
 	}
 
 	public async getAdbFilePath(): Promise<string> {

lib/config.ts

@@ -1,7 +1,6 @@
 import { createGUID } from "../common/helpers";
 
 class AnalyticsSettingsService implements IAnalyticsSettingsService {
-	private static SESSIONS_STARTED_OBSOLETE_KEY = "SESSIONS_STARTED";
 	private static SESSIONS_STARTED_KEY_PREFIX = "SESSIONS_STARTED_";
 
 	constructor(private $userSettingsService: UserSettings.IUserSettingsService,
@@ -33,14 +32,8 @@ class AnalyticsSettingsService implements IAnalyticsSettingsService {
 	}
 
 	public async getUserSessionsCount(projectName: string): Promise<number> {
-		const oldSessionCount = await this.$userSettingsService.getSettingValue<number>(AnalyticsSettingsService.SESSIONS_STARTED_OBSOLETE_KEY);
-
-		if (oldSessionCount) {
-			// remove the old property for sessions count
-			await this.$userSettingsService.removeSetting(AnalyticsSettingsService.SESSIONS_STARTED_OBSOLETE_KEY);
-		}
-
-		return await this.$userSettingsService.getSettingValue<number>(this.getSessionsProjectKey(projectName)) || oldSessionCount || 0;
+		const sessionsCountForProject = await this.$userSettingsService.getSettingValue<number>(this.getSessionsProjectKey(projectName));
+		return sessionsCountForProject || 0;
 	}
 
 	public async setUserSessionsCount(count: number, projectName: string): Promise<void> {

lib/services/analytics-service.ts

@@ -0,0 +1,56 @@
+import * as fs from "fs";
+import { AnalyticsBroker } from "./analytics-broker";
+
+const pathToBootstrap = process.argv[2];
+if (!pathToBootstrap || !fs.existsSync(pathToBootstrap)) {
+	throw new Error("Invalid path to bootstrap.");
+}
+
+// After requiring the bootstrap we can use $injector
+require(pathToBootstrap);
+
+const analyticsBroker = $injector.resolve<IAnalyticsBroker>(AnalyticsBroker, { pathToBootstrap });
+let trackingQueue: Promise<void> = Promise.resolve();
+
+let sentFinishMsg = false;
+let receivedFinishMsg = false;
+
+const sendDataForTracking = async (data: ITrackingInformation) => {
+	trackingQueue = trackingQueue.then(() => analyticsBroker.sendDataForTracking(data));
+	await trackingQueue;
+};
+
+const finishTracking = async (data?: ITrackingInformation) => {
+	if (!sentFinishMsg) {
+		sentFinishMsg = true;
+
+		data = data || { type: TrackingTypes.Finish };
+
+		if (receivedFinishMsg) {
+			await sendDataForTracking(data);
+		} else {
+			// In case we've got here without receiving "finish" message from parent (receivedFinishMsg is false)
+			// there might be various reasons, but most probably the parent is dead.
+			// However, there's no guarantee that we've received all messages. So wait some time before sending finish message to children.
+			setTimeout(async () => {
+				await sendDataForTracking(data);
+			}, 1000);
+		}
+	}
+};
+
+process.on("message", async (data: ITrackingInformation) => {
+	if (data.type === TrackingTypes.Finish) {
+		receivedFinishMsg = true;
+		await finishTracking(data);
+		return;
+	}
+
+	await sendDataForTracking(data);
+});
+
+process.on("disconnect", async () => {
+	await finishTracking();
+});
+
+process.send(AnalyticsMessages.BrokerReadyToReceive);

lib/services/analytics-settings-service.ts

@@ -0,0 +1,39 @@
+import { cache } from "../../common/decorators";
+
+export class AnalyticsBroker implements IAnalyticsBroker {
+
+	@cache()
+	private get $eqatecAnalyticsProvider(): IAnalyticsProvider {
+		return this.$injector.resolve("eqatecAnalyticsProvider", { pathToBootstrap: this.pathToBootstrap });
+	}
+
+	constructor(private pathToBootstrap: string,
+		private $injector: IInjector) { }
+
+	private get analyticsProviders(): IAnalyticsProvider[] {
+		return [
+			this.$eqatecAnalyticsProvider
+		];
+	}
+
+	public async sendDataForTracking(trackInfo: ITrackingInformation): Promise<void> {
+		for (const provider of this.analyticsProviders) {
+			switch (trackInfo.type) {
+				case TrackingTypes.Exception:
+					await provider.trackException(<IExceptionsTrackingInformation>trackInfo);
+					break;
+				case TrackingTypes.Feature:
+					await provider.trackFeature(<IFeatureTrackingInformation>trackInfo);
+					break;
+				case TrackingTypes.Finish:
+					await provider.finishTracking();
+					break;
+				default:
+					throw new Error(`Invalid tracking type: ${trackInfo.type}`);
+			}
+
+		}
+
+	}
+
+}

lib/services/analytics/analytics-broker-process.ts

@@ -0,0 +1,14 @@
+/**
+ * Defines messages used in communication between CLI's process and analytics subprocesses.
+ */
+const enum AnalyticsMessages {
+	/**
+	 * Analytics Broker is initialized and is ready to receive information for tracking.
+	 */
+	BrokerReadyToReceive = "BrokerReadyToReceive",
+
+	/**
+	 * Eqatec Analytics process is initialized and is ready to receive information for tracking.
+	 */
+	EqatecAnalyticsReadyToReceive = "EqatecAnalyticsReadyToReceive"
+}

lib/services/analytics/analytics-broker.ts

@@ -0,0 +1,148 @@
+import { AnalyticsServiceBase } from "../../common/services/analytics-service-base";
+import { ChildProcess } from "child_process";
+import * as path from "path";
+import * as helpers from "../../common/helpers";
+import { cache } from "../../common/decorators";
+
+export class AnalyticsService extends AnalyticsServiceBase implements IAnalyticsService {
+	private static ANALYTICS_FEATURE_USAGE_TRACKING_API_KEY = "9912cff308334c6d9ad9c33f76a983e3";
+	private static ANALYTICS_BROKER_START_TIMEOUT = 30 * 1000;
+
+	constructor(protected $logger: ILogger,
+		protected $options: IOptions,
+		$staticConfig: Config.IStaticConfig,
+		$prompter: IPrompter,
+		$userSettingsService: UserSettings.IUserSettingsService,
+		$analyticsSettingsService: IAnalyticsSettingsService,
+		$progressIndicator: IProgressIndicator,
+		$osInfo: IOsInfo,
+		private $childProcess: IChildProcess,
+		private $processService: IProcessService) {
+		super($logger, $options, $staticConfig, $prompter, $userSettingsService, $analyticsSettingsService, $progressIndicator, $osInfo);
+	}
+
+	public async track(featureName: string, featureValue: string): Promise<void> {
+		await this.sendDataForTracking(featureName, featureValue);
+	}
+
+	public async trackException(exception: any, message: string): Promise<void> {
+		await this.sendExceptionForTracking(exception, message);
+	}
+
+	public async trackFeature(featureValue: string): Promise<void> {
+		const featureName = this.$options.analyticsClient ||
+			(helpers.isInteractive() ? "CLI" : "Non-interactive");
+
+		await this.sendDataForTracking(featureName, featureValue);
+	}
+
+	protected async checkConsentCore(trackFeatureUsage: boolean): Promise<void> {
+		await this.restartEqatecMonitor(AnalyticsService.ANALYTICS_FEATURE_USAGE_TRACKING_API_KEY);
+		await super.checkConsentCore(trackFeatureUsage);
+
+		// Stop the monitor, so correct API_KEY will be used when features are tracked.
+		this.tryStopEqatecMonitor();
+	}
+
+	@cache()
+	private getAnalyticsBroker(): Promise<ChildProcess> {
+		return new Promise<ChildProcess>((resolve, reject) => {
+			const broker = this.$childProcess.spawn("node",
+				[
+					path.join(__dirname, "analytics-broker-process.js"),
+					this.$staticConfig.PATH_TO_BOOTSTRAP
+				],
+				{
+					stdio: ["ignore", "ignore", "ignore", "ipc"],
+					detached: true
+				}
+			);
+
+			broker.unref();
+
+			let isSettled = false;
+
+			const timeoutId = setTimeout(() => {
+				if (!isSettled) {
+					reject(new Error("Unable to start Analytics Broker process."));
+				}
+			}, AnalyticsService.ANALYTICS_BROKER_START_TIMEOUT);
+
+			broker.on("error", (err: Error) => {
+				clearTimeout(timeoutId);
+
+				if (!isSettled) {
+					isSettled = true;
+					reject(err);
+				}
+			});
+
+			broker.on("message", (data: any) => {
+				if (data === AnalyticsMessages.BrokerReadyToReceive) {
+					clearTimeout(timeoutId);
+
+					if (!isSettled) {
+						isSettled = true;
+						resolve(broker);
+					}
+				}
+			});
+
+			this.$processService.attachToProcessExitSignals(this, () => {
+				broker.send({
+					type: TrackingTypes.Finish
+				});
+			});
+
+		});
+
+	}
+
+	private async sendDataForTracking(featureName: string, featureValue: string): Promise<void> {
+		await this.initAnalyticsStatuses();
+
+		if (this.analyticsStatuses[this.$staticConfig.TRACK_FEATURE_USAGE_SETTING_NAME] === AnalyticsStatus.enabled) {
+			const broker = await this.getAnalyticsBroker();
+
+			return new Promise<void>((resolve, reject) => {
+				broker.send(
+					{
+						type: TrackingTypes.Feature,
+						featureName: featureName,
+						featureValue: featureValue
+					},
+					() => {
+						resolve();
+					});
+			});
+
+		}
+
+	}
+
+	private async sendExceptionForTracking(exception: Error, message: string): Promise<void> {
+		await this.initAnalyticsStatuses();
+
+		if (this.analyticsStatuses[this.$staticConfig.ERROR_REPORT_SETTING_NAME] === AnalyticsStatus.enabled) {
+			const broker = await this.getAnalyticsBroker();
+
+			return new Promise<void>((resolve, reject) => {
+				broker.send(
+					{
+						type: TrackingTypes.Exception,
+						exception,
+						message
+					},
+					() => {
+						resolve();
+					});
+
+			});
+
+		}
+
+	}
+
+}
+
+$injector.register("analyticsService", AnalyticsService);