feat(analytics): write analytics data to passed file

Write analytics data to a file passed as `--analyticsLogFile`. The file will contain timestamp when the action is executed and what is the data passed to analytics.
Also add some additional logging to the file, so when something fails, it will be easier for diagnostics.
In case `--analyticsLogFile` is not passed, information will not be tracked.

Author: rosen-vladimirov

lib/declarations.d.ts

@@ -557,6 +557,7 @@ interface IOptions extends IRelease, IDeviceIdentifier, IJustLaunch, IAvd, IAvai
 	background: string;
 	hmr: boolean;
 	link: boolean;
+	analyticsLogFile: string;
 }
 
 interface IEnvOptions {

lib/options.ts

@@ -114,6 +114,7 @@ export class Options {
 			var: { type: OptionType.Object },
 			default: { type: OptionType.Boolean },
 			count: { type: OptionType.Number },
+			analyticsLogFile: { type: OptionType.String },
 			hooks: { type: OptionType.Boolean, default: true },
 			link: { type: OptionType.Boolean, default: false },
 			aab: { type: OptionType.Boolean }

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

@@ -2,16 +2,22 @@
 // The instances here are not shared with the ones in main CLI process.
 import * as fs from "fs";
 import { AnalyticsBroker } from "./analytics-broker";
+import { AnalyticsLoggingService } from "./analytics-logging-service";
 
 const pathToBootstrap = process.argv[2];
 if (!pathToBootstrap || !fs.existsSync(pathToBootstrap)) {
 	throw new Error("Invalid path to bootstrap.");
 }
 
+const logFile = process.argv[3];
 // After requiring the bootstrap we can use $injector
 require(pathToBootstrap);
 
-const analyticsBroker = $injector.resolve<IAnalyticsBroker>(AnalyticsBroker, { pathToBootstrap });
+const analyticsLoggingService = $injector.resolve<IAnalyticsLoggingService>(AnalyticsLoggingService, { logFile });
+analyticsLoggingService.logData({ message: "Initializing AnalyticsBroker." });
+
+const analyticsBroker = $injector.resolve<IAnalyticsBroker>(AnalyticsBroker, { pathToBootstrap, analyticsLoggingService });
+
 let trackingQueue: Promise<void> = Promise.resolve();
 
 let sentFinishMsg = false;
@@ -23,12 +29,15 @@ const sendDataForTracking = async (data: ITrackingInformation) => {
 };
 
 const finishTracking = async (data?: ITrackingInformation) => {
+	analyticsLoggingService.logData({ message: `analytics-broker-process finish tracking started, sentFinishMsg: ${sentFinishMsg}, receivedFinishMsg: ${receivedFinishMsg}` });
+
 	if (!sentFinishMsg) {
 		sentFinishMsg = true;
 
 		data = data || { type: TrackingTypes.Finish };
 		const action = async () => {
-			await sendDataForTracking(data);
+			await trackingQueue;
+			analyticsLoggingService.logData({ message: `analytics-broker-process tracking finished` });
 			process.disconnect();
 		};
 
@@ -46,6 +55,8 @@ const finishTracking = async (data?: ITrackingInformation) => {
 };
 
 process.on("message", async (data: ITrackingInformation) => {
+	analyticsLoggingService.logData({ message: `analytics-broker-process received message of type: ${data.type}` });
+
 	if (data.type === TrackingTypes.Finish) {
 		receivedFinishMsg = true;
 		await finishTracking(data);
@@ -56,7 +67,10 @@ process.on("message", async (data: ITrackingInformation) => {
 });
 
 process.on("disconnect", async () => {
+	analyticsLoggingService.logData({ message: "analytics-broker-process received process.disconnect event" });
 	await finishTracking();
 });
 
+analyticsLoggingService.logData({ message: `analytics-broker-process will send ${AnalyticsMessages.BrokerReadyToReceive} message` });
+
 process.send(AnalyticsMessages.BrokerReadyToReceive);

lib/services/analytics/analytics-logging-service.ts

@@ -0,0 +1,41 @@
+import { EOL } from "os";
+
+export class AnalyticsLoggingService implements IAnalyticsLoggingService {
+	constructor(private $fs: IFileSystem,
+		private logFile: string) { }
+
+	public logData(analyticsLoggingMessage: IAnalyticsLoggingMessage): void {
+		if (this.logFile && analyticsLoggingMessage && analyticsLoggingMessage.message) {
+			analyticsLoggingMessage.type = analyticsLoggingMessage.type || AnalyticsLoggingMessageType.Info;
+			const formattedDate = this.getFormattedDate();
+			this.$fs.appendFile(this.logFile, `[${formattedDate}] [${analyticsLoggingMessage.type}] ${analyticsLoggingMessage.message}${EOL}`);
+		}
+	}
+
+	private getFormattedDate(): string {
+		const currentDate = new Date();
+		const year = currentDate.getFullYear();
+		const month = this.getFormattedDateComponent((currentDate.getMonth() + 1));
+		const day = this.getFormattedDateComponent(currentDate.getDate());
+		const hour = this.getFormattedDateComponent(currentDate.getHours());
+		const minutes = this.getFormattedDateComponent(currentDate.getMinutes());
+		const seconds = this.getFormattedDateComponent(currentDate.getSeconds());
+		const milliseconds = this.getFormattedMilliseconds(currentDate);
+
+		return `${[year, month, day].join('-')} ${[hour, minutes, seconds].join(":")}.${milliseconds}`;
+	}
+
+	private getFormattedDateComponent(component: number): string {
+		const stringComponent = component.toString();
+		return stringComponent.length === 1 ? `0${stringComponent}` : stringComponent;
+	}
+
+	private getFormattedMilliseconds(date: Date): string {
+		let milliseconds = date.getMilliseconds().toString();
+		while (milliseconds.length < 3) {
+			milliseconds = `0${milliseconds}`;
+		}
+
+		return milliseconds;
+	}
+}

lib/services/analytics/analytics-service.ts

@@ -147,10 +147,11 @@ export class AnalyticsService implements IAnalyticsService, IDisposable {
 	@cache()
 	private getAnalyticsBroker(): Promise<ChildProcess> {
 		return new Promise<ChildProcess>((resolve, reject) => {
-			const broker = this.$childProcess.spawn("node",
+			const broker = this.$childProcess.spawn(process.execPath,
 				[
 					path.join(__dirname, "analytics-broker-process.js"),
-					this.$staticConfig.PATH_TO_BOOTSTRAP
+					this.$staticConfig.PATH_TO_BOOTSTRAP,
+					this.$options.analyticsLogFile // TODO: Check if passing path with space or quotes will work
 				],
 				{
 					stdio: ["ignore", "ignore", "ignore", "ipc"],

lib/services/analytics/analytics.d.ts

@@ -58,3 +58,23 @@ interface IGoogleAnalyticsProvider {
 	 */
 	trackHit(data: IGoogleAnalyticsData): Promise<void>;
 }
+
+/**
+ * Describes message that needs to be logged in the analytics logging file.
+ */
+interface IAnalyticsLoggingMessage {
+	message: string;
+	type?: AnalyticsLoggingMessageType
+}
+
+/**
+ * Describes methods to get local logs from analytics tracking.
+ */
+interface IAnalyticsLoggingService {
+	/**
+	 * Logs specified message to the file specified with `--analyticsLogFile`.
+	 * @param {IAnalyticsLoggingMessage} analyticsLoggingMessage The message that has to be written to the logs file.
+	 * @returns {void}
+	 */
+	logData(analyticsLoggingMessage: IAnalyticsLoggingMessage): void;
+}

lib/services/analytics/google-analytics-provider.ts

@@ -1,6 +1,7 @@
 import * as uuid from "uuid";
 import * as ua from "universal-analytics";
 import { AnalyticsClients } from "../../common/constants";
+import { cache } from "../../common/decorators";
 
 export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 	private currentPage: string;
@@ -10,7 +11,8 @@ export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 		private $analyticsSettingsService: IAnalyticsSettingsService,
 		private $logger: ILogger,
 		private $proxyService: IProxyService,
-		private $config: IConfiguration) {
+		private $config: IConfiguration,
+		private analyticsLoggingService: IAnalyticsLoggingService) {
 	}
 
 	public async trackHit(trackInfo: IGoogleAnalyticsData): Promise<void> {
@@ -19,13 +21,14 @@ export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 		try {
 			await this.track(this.$config.GA_TRACKING_ID, trackInfo, sessionId);
 		} catch (e) {
+			this.analyticsLoggingService.logData({ type: AnalyticsLoggingMessageType.Error, message: `Unable to track information ${JSON.stringify(trackInfo)}. Error is: ${e}` });
 			this.$logger.trace("Analytics exception: ", e);
 		}
 	}
 
-	private async track(gaTrackingId: string, trackInfo: IGoogleAnalyticsData, sessionId: string): Promise<void> {
-		const proxySettings = await this.$proxyService.getCache();
-		const proxy = proxySettings && proxySettings.proxy;
+	@cache()
+	private getVisitor(gaTrackingId: string, proxy: string): ua.Visitor {
+		this.analyticsLoggingService.logData({ message: `Initializing Google Analytics visitor for id: ${gaTrackingId} with clientId: ${this.clientId}.` });
 		const visitor = ua({
 			tid: gaTrackingId,
 			cid: this.clientId,
@@ -34,9 +37,20 @@ export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 			},
 			requestOptions: {
 				proxy
-			}
+			},
+			https: true
 		});
 
+		this.analyticsLoggingService.logData({ message: `Successfully initialized Google Analytics visitor for id: ${gaTrackingId} with clientId: ${this.clientId}.` });
+		return visitor;
+	}
+
+	private async track(gaTrackingId: string, trackInfo: IGoogleAnalyticsData, sessionId: string): Promise<void> {
+		const proxySettings = await this.$proxyService.getCache();
+		const proxy = proxySettings && proxySettings.proxy;
+
+		const visitor = this.getVisitor(gaTrackingId, proxy);
+
 		await this.setCustomDimensions(visitor, trackInfo.customDimensions, sessionId);
 
 		switch (trackInfo.googleAnalyticsDataType) {
@@ -68,6 +82,7 @@ export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 		customDimensions = _.merge(defaultValues, customDimensions);
 
 		_.each(customDimensions, (value, key) => {
+			this.analyticsLoggingService.logData({ message: `Setting custom dimension ${key} to value ${value}` });
 			visitor.set(key, value);
 		});
 	}
@@ -76,10 +91,17 @@ export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 		return new Promise<void>((resolve, reject) => {
 			visitor.event(trackInfo.category, trackInfo.action, trackInfo.label, trackInfo.value, { p: this.currentPage }, (err: Error) => {
 				if (err) {
+					this.analyticsLoggingService.logData({
+						message: `Unable to track event with category: '${trackInfo.category}', action: '${trackInfo.action}', label: '${trackInfo.label}', ` +
+							`value: '${trackInfo.value}' attached page: ${this.currentPage}. Error is: ${err}.`,
+						type: AnalyticsLoggingMessageType.Error
+					});
+
 					reject(err);
 					return;
 				}
 
+				this.analyticsLoggingService.logData({ message: `Tracked event with category: '${trackInfo.category}', action: '${trackInfo.action}', label: '${trackInfo.label}', value: '${trackInfo.value}' attached page: ${this.currentPage}.` });
 				resolve();
 			});
 		});
@@ -96,10 +118,16 @@ export class GoogleAnalyticsProvider implements IGoogleAnalyticsProvider {
 
 			visitor.pageview(pageViewData, (err) => {
 				if (err) {
+					this.analyticsLoggingService.logData({
+						message: `Unable to track pageview with path '${trackInfo.path}' and title: '${trackInfo.title}' Error is: ${err}.`,
+						type: AnalyticsLoggingMessageType.Error
+					});
+
 					reject(err);
 					return;
 				}
 
+				this.analyticsLoggingService.logData({ message: `Tracked pageview with path '${trackInfo.path}' and title: '${trackInfo.title}'.` });
 				resolve();
 			});
 		});