@react-native-windows/telemetry 0.75.3 → 0.75.5

package/lib-commonjs/telemetry.d.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  * @format
  */
-import * as appInsights from 'applicationinsights';
+import * as coreOneDS from '@microsoft/1ds-core-js';
 import * as errorUtils from './utils/errorUtils';
 import * as projectUtils from './utils/projectUtils';
 export interface TelemetryOptions {
@@ -35,38 +35,26 @@ export declare const NuGetPackagesWeTrack: string[];
  * The Telemetry class is responsible for reporting telemetry for RNW CLI.
  */
 export declare class Telemetry {
-    protected static client?: appInsights.TelemetryClient;
+    protected static appInsightsCore?: coreOneDS.AppInsightsCore;
     protected static options: TelemetryOptions;
-    protected static isTest: boolean;
+    protected static isTestEnvironment: boolean;
     protected static commandInfo: CommandInfo;
     protected static versionsProp: Record<string, string>;
     protected static projectProp?: projectUtils.AppProjectInfo | projectUtils.DependencyProjectInfo;
+    protected static commonProperties: {
+        [key: string]: string;
+    };
     protected static getDefaultSetupString(): string;
     protected static reset(): void;
     static isEnabled(): boolean;
     static getSessionId(): string;
     /** Sets up the Telemetry static to be used elsewhere. */
     static setup(options?: Partial<TelemetryOptions>): Promise<void>;
-    /** Sets up Telemetry.client. */
+    private static basicTelemetryInitializer;
+    /** Sets up Telemetry.appInsightsCore. */
     private static setupClient;
     /** Sets up any base properties that all telemetry events require. */
     private static setupBaseProperties;
-    /** Sets up any telemetry processors. */
-    private static setupTelemetryProcessors;
-    /**
-     * Performs the processing necessary (mostly PII sanitization) for all events.
-     * @param envelope The ApplicationInsights event envelope.
-     * @param _contextObjects An optional context object.
-     * @returns Whether to kee
-     */
-    private static basicTelemetryProcessor;
-    /**
-     * Performs the processing necessary (mostly PII sanitization) for error events.
-     * @param envelope
-     * @param _contextObjects
-     * @returns
-     */
-    private static errorTelemetryProcessor;
     /** Tries to update the version of the named package/tool by calling getValue(). */
     static tryUpdateVersionsProp(name: string, getValue: () => Promise<string | null>, forceRefresh?: boolean): Promise<boolean>;
     /** Populates the versions property of tools we care to track. */
@@ -78,7 +66,10 @@ export declare class Telemetry {
     static setProjectInfo(info: projectUtils.AppProjectInfo | projectUtils.DependencyProjectInfo): void;
     static startCommand(info: CommandStartInfo): void;
     static endCommand(info: CommandEndInfo, extraProps?: Record<string, any>): void;
+    private static trackEvent;
     private static trackCommandEvent;
     static trackException(error: Error, extraProps?: Record<string, any>): void;
+    static convertErrorIntoExceptionData(error: Error): Record<string, any>;
+    static sanitizeAny(data: any): any;
 }
 export {};

package/lib-commonjs/telemetry.js

@@ -29,12 +29,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Telemetry = exports.NuGetPackagesWeTrack = exports.NpmPackagesWeTrack = exports.EventNamesWeTrack = exports.CodedErrorEventName = exports.CommandEventName = void 0;
-const appInsights = __importStar(require("applicationinsights"));
+const coreOneDS = __importStar(require("@microsoft/1ds-core-js"));
+const _1ds_post_js_1 = require("@microsoft/1ds-post-js");
 const basePropUtils = __importStar(require("./utils/basePropUtils"));
 const versionUtils = __importStar(require("./utils/versionUtils"));
 const errorUtils = __importStar(require("./utils/errorUtils"));
-// This is our key with the AI backend
-const RNWSetupString = '795006ca-cf54-40ee-8bc6-03deb91401c3';
+const nameUtils = __importStar(require("./utils/nameUtils"));
+// 1DS instrumentation key
+const RNW_1DS_INSTRUMENTATION_KEY = '49ff6d3ef12f4578a7b75a2573d9dba8-026332b2-2d50-452f-ad0d-50f921c97a9d-7145';
 // Environment variable to override the default setup string
 const ENV_SETUP_OVERRIDE = 'RNW_TELEMETRY_SETUP';
 // Environment variable to override the http proxy (such as http://localhost:8888 for Fiddler debugging)
@@ -70,13 +72,13 @@ class Telemetry {
     static getDefaultSetupString() {
         var _a;
         // Enable overriding the default setup string via an environment variable
-        return (_a = process.env[ENV_SETUP_OVERRIDE]) !== null && _a !== void 0 ? _a : RNWSetupString;
+        return (_a = process.env[ENV_SETUP_OVERRIDE]) !== null && _a !== void 0 ? _a : RNW_1DS_INSTRUMENTATION_KEY;
     }
     static reset() {
         // Reset client
-        if (Telemetry.client) {
-            Telemetry.client.flush();
-            Telemetry.client = undefined;
+        if (Telemetry.appInsightsCore) {
+            Telemetry.appInsightsCore.flush();
+            Telemetry.appInsightsCore = undefined;
         }
         // Reset local members
         Telemetry.options = {
@@ -89,146 +91,104 @@ class Telemetry {
         Telemetry.projectProp = undefined;
     }
     static isEnabled() {
-        return Telemetry.client !== undefined;
+        return Telemetry.appInsightsCore !== undefined;
     }
     static getSessionId() {
         return basePropUtils.getSessionId();
     }
     /** Sets up the Telemetry static to be used elsewhere. */
     static async setup(options) {
-        if (Telemetry.client) {
+        if (Telemetry.appInsightsCore) {
             // Bail since we've already setup
             return;
         }
         // Bail if we're in CI and not capturing CI
-        if (!this.isTest && basePropUtils.isCI() && !basePropUtils.captureCI()) {
+        if (!Telemetry.isTestEnvironment &&
+            basePropUtils.isCI() &&
+            !basePropUtils.captureCI()) {
             return;
         }
         // Save off options for later
         Object.assign(Telemetry.options, options);
         Telemetry.setupClient();
         await Telemetry.setupBaseProperties();
-        Telemetry.setupTelemetryProcessors();
     }
-    /** Sets up Telemetry.client. */
+    static basicTelemetryInitializer(envelope) {
+        // Filter out "legacy" events from older stable branches
+        if (envelope.name && exports.EventNamesWeTrack.includes(envelope.name)) {
+            return true;
+        }
+        return false;
+    }
+    /** Sets up Telemetry.appInsightsCore. */
     static setupClient() {
-        var _a;
-        appInsights.Configuration.setInternalLogging(false, false);
-        Telemetry.client = new appInsights.TelemetryClient(Telemetry.options.setupString);
-        // Allow overriding the proxy server via an environment variable
-        const proxyServer = process.env[ENV_PROXY_OVERRIDE];
-        if (proxyServer) {
-            Telemetry.client.config.proxyHttpUrl = proxyServer;
-            Telemetry.client.config.proxyHttpsUrl = proxyServer;
+        const postChannel = new _1ds_post_js_1.PostChannel();
+        const coreConfiguration = {
+            instrumentationKey: Telemetry.getDefaultSetupString(),
+        };
+        const postChannelConfig = {
+            eventsLimitInMem: 5000,
+        };
+        coreConfiguration.extensionConfig = {};
+        coreConfiguration.extensionConfig[postChannel.identifier] =
+            postChannelConfig;
+        // Allow overriding the endpoint URL via an environment variable.
+        if (process.env[ENV_PROXY_OVERRIDE] !== undefined) {
+            coreConfiguration.endpointUrl = process.env[ENV_PROXY_OVERRIDE];
         }
-        Telemetry.client.config.disableAppInsights = Telemetry.isTest;
-        Telemetry.client.config.disableStatsbeat = true;
-        // Despite trying to disable the statsbeat, it might still be running: https://github.com/microsoft/ApplicationInsights-node.js/issues/943
-        // So we want to disable it, and despite the method's typing, getStatsbeat() _can_ return undefined
-        (_a = Telemetry.client.getStatsbeat()) === null || _a === void 0 ? void 0 : _a.enable(false);
-        Telemetry.client.channel.setUseDiskRetryCaching(!Telemetry.isTest);
+        Telemetry.appInsightsCore = new coreOneDS.AppInsightsCore();
+        Telemetry.appInsightsCore.initialize(coreConfiguration, [postChannel] /* extensions */);
+        Telemetry.appInsightsCore.addTelemetryInitializer(Telemetry.basicTelemetryInitializer);
     }
     /** Sets up any base properties that all telemetry events require. */
     static async setupBaseProperties() {
-        Telemetry.client.commonProperties.deviceId =
-            await basePropUtils.deviceId();
-        Telemetry.client.commonProperties.deviceArchitecture =
+        Telemetry.commonProperties.deviceId = await basePropUtils.deviceId();
+        Telemetry.commonProperties.fullBuildInfo =
+            await basePropUtils.fullBuildInfo();
+        Telemetry.commonProperties.deviceArchitecture =
             basePropUtils.deviceArchitecture();
-        Telemetry.client.commonProperties.nodeArchitecture =
+        Telemetry.commonProperties.nodeArchitecture =
             basePropUtils.nodeArchitecture();
-        Telemetry.client.commonProperties.devicePlatform =
-            basePropUtils.devicePlatform();
-        Telemetry.client.commonProperties.deviceLocale =
+        Telemetry.commonProperties.nodePlatform = basePropUtils.nodePlatform();
+        Telemetry.commonProperties.deviceClass = basePropUtils.deviceClass();
+        Telemetry.commonProperties.deviceLocale =
             await basePropUtils.deviceLocale();
-        Telemetry.client.commonProperties.deviceNumCPUs = basePropUtils
+        Telemetry.commonProperties.deviceNumCPUs = basePropUtils
             .deviceNumCPUs()
             .toString();
-        Telemetry.client.commonProperties.deviceTotalMemory = basePropUtils
+        Telemetry.commonProperties.deviceTotalMemory = basePropUtils
             .deviceTotalMemory()
             .toString();
-        Telemetry.client.commonProperties.deviceDiskFreeSpace = basePropUtils
+        Telemetry.commonProperties.deviceDiskFreeSpace = basePropUtils
             .deviceDiskFreeSpace()
             .toString();
-        Telemetry.client.commonProperties.ciCaptured = basePropUtils
+        Telemetry.commonProperties.ciCaptured = basePropUtils
             .captureCI()
             .toString();
-        Telemetry.client.commonProperties.ciType = basePropUtils.ciType();
-        Telemetry.client.commonProperties.isMsftInternal = basePropUtils
+        Telemetry.commonProperties.ciType = basePropUtils.ciType();
+        Telemetry.commonProperties.isMsftInternal = basePropUtils
             .isMsftInternal()
             .toString();
-        Telemetry.client.commonProperties.sampleRate = basePropUtils
-            .sampleRate()
-            .toString();
-        Telemetry.client.commonProperties.isTest = Telemetry.isTest.toString();
-        Telemetry.client.commonProperties.sessionId = Telemetry.getSessionId();
-        Telemetry.client.config.samplingPercentage = basePropUtils.sampleRate();
+        Telemetry.commonProperties.isTest = Telemetry.isTestEnvironment.toString();
+        Telemetry.commonProperties.sessionId = Telemetry.getSessionId();
         await Telemetry.populateToolsVersions();
         if (Telemetry.options.populateNpmPackageVersions) {
             await Telemetry.populateNpmPackageVersions();
         }
     }
-    /** Sets up any telemetry processors. */
-    static setupTelemetryProcessors() {
-        Telemetry.client.addTelemetryProcessor(Telemetry.basicTelemetryProcessor);
-        Telemetry.client.addTelemetryProcessor(Telemetry.errorTelemetryProcessor);
-    }
-    /**
-     * Performs the processing necessary (mostly PII sanitization) for all events.
-     * @param envelope The ApplicationInsights event envelope.
-     * @param _contextObjects An optional context object.
-     * @returns Whether to kee
-     */
-    static basicTelemetryProcessor(envelope, _contextObjects) {
-        var _a;
-        delete envelope.tags['ai.cloud.roleInstance'];
-        // Filter out "legacy" events from older stable branches
-        const properties = (_a = envelope.data.baseData) === null || _a === void 0 ? void 0 : _a.properties;
-        if ((properties === null || properties === void 0 ? void 0 : properties.eventName) &&
-            exports.EventNamesWeTrack.includes(properties.eventName)) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Performs the processing necessary (mostly PII sanitization) for error events.
-     * @param envelope
-     * @param _contextObjects
-     * @returns
-     */
-    static errorTelemetryProcessor(envelope, _contextObjects) {
-        if (envelope.data.baseType === 'ExceptionData') {
-            const data = envelope.data.baseData;
-            if (data === null || data === void 0 ? void 0 : data.exceptions) {
-                for (const exception of data.exceptions) {
-                    for (const frame of exception.parsedStack) {
-                        errorUtils.sanitizeErrorStackFrame(frame);
-                    }
-                    // Exception message must never be blank, or AI will reject it
-                    exception.message = exception.message || '[None]';
-                    // CodedError has non-PII information in its 'type' member, plus optionally some more info in its 'data'.
-                    // The message may contain PII information. This can be sanitized, but for now delete it.
-                    // Note that the type of data.exceptions[0] is always going to be ExceptionDetails. It is not the original thrown exception.
-                    // https://github.com/microsoft/ApplicationInsights-node.js/issues/707
-                    if (Telemetry.options.preserveErrorMessages) {
-                        exception.message = errorUtils.sanitizeErrorMessage(exception.message);
-                    }
-                    else {
-                        exception.message = '[Removed]';
-                    }
-                }
-            }
-        }
-        return true;
-    }
     /** Tries to update the version of the named package/tool by calling getValue(). */
     static async tryUpdateVersionsProp(name, getValue, forceRefresh) {
-        if (!Telemetry.client) {
+        if (!Telemetry.appInsightsCore) {
             return true;
         }
-        if (forceRefresh === true || !Telemetry.versionsProp[name]) {
+        // Process the package name to comply with the backend requirements
+        const packageName = nameUtils.isValidTelemetryPackageName(name)
+            ? name
+            : nameUtils.cleanTelemetryPackageName(name);
+        if (forceRefresh === true || !Telemetry.versionsProp[packageName]) {
             const value = await getValue();
             if (value) {
-                Telemetry.versionsProp[name] = value;
+                Telemetry.versionsProp[packageName] = value;
                 return true;
             }
         }
@@ -255,27 +215,29 @@ class Telemetry {
         }
     }
     static setProjectInfo(info) {
-        if (!Telemetry.client) {
+        if (!Telemetry.appInsightsCore) {
             return;
         }
         Telemetry.projectProp = info;
     }
     static startCommand(info) {
-        if (!Telemetry.client) {
+        if (!Telemetry.appInsightsCore) {
             return;
         }
+        // startCommand() was called before invoking endCommand(), bail out.
         if (Telemetry.commandInfo.startInfo) {
             return;
         }
         Telemetry.commandInfo.startTime = Date.now();
         Telemetry.commandInfo.startInfo = info;
         // Set common command props
-        Telemetry.client.commonProperties.commandName = info.commandName;
+        Telemetry.commonProperties.commandName = info.commandName;
     }
     static endCommand(info, extraProps) {
-        if (!Telemetry.client) {
+        if (!Telemetry.appInsightsCore) {
             return;
         }
+        // startCommand() wasn't called, bail out.
         if (!Telemetry.commandInfo.startInfo) {
             return;
         }
@@ -283,13 +245,52 @@ class Telemetry {
         Telemetry.commandInfo.endInfo = info;
         Telemetry.trackCommandEvent(extraProps);
     }
+    static trackEvent(telemetryItem) {
+        // Populate Part A
+        telemetryItem.ver = '4.0'; // Current Common Schema version
+        telemetryItem.time = new Date().toISOString();
+        telemetryItem.iKey = RNW_1DS_INSTRUMENTATION_KEY;
+        // Populate Part A extensions
+        telemetryItem.ext = {};
+        telemetryItem.ext.device = {
+            id: Telemetry.commonProperties.deviceId,
+            deviceClass: Telemetry.commonProperties.deviceClass,
+        };
+        telemetryItem.ext.os = {
+            locale: Telemetry.commonProperties.deviceLocale,
+            ver: Telemetry.commonProperties.fullBuildInfo,
+        };
+        // Populate most of "common" properties into Part B.
+        telemetryItem.baseData = {
+            common: {
+                device: {
+                    architecture: Telemetry.commonProperties.deviceArchitecture,
+                    numCPUs: Telemetry.commonProperties.numCPUs,
+                    totalMemory: Telemetry.commonProperties.totalMemory,
+                    diskFreeSpace: Telemetry.commonProperties.deviceDiskFreeSpace,
+                },
+                nodePlatform: Telemetry.commonProperties.nodePlatform,
+                nodeArchitecture: Telemetry.commonProperties.nodeArchitecture,
+                ciCaptured: Telemetry.commonProperties.ciCaptured,
+                ciType: Telemetry.commonProperties.ciType,
+                isMsftInternal: Telemetry.commonProperties.isMsftInternal,
+                isCliTest: Telemetry.commonProperties.isTest,
+                sessionId: Telemetry.commonProperties.sessionId,
+                commandName: Telemetry.commonProperties.commandName,
+            },
+            // Set project and versions props, belonging to Part B.
+            project: Telemetry.projectProp,
+            versions: Telemetry.versionsProp,
+        };
+        // Send and post the telemetry event!
+        Telemetry.appInsightsCore.track(telemetryItem);
+        Telemetry.appInsightsCore.flush();
+    }
     static trackCommandEvent(extraProps) {
         var _a, _b, _c, _d;
-        const props = {
-            eventName: exports.CommandEventName,
-        };
-        // Set command props
-        props.command = {
+        const telemetryItem = { name: exports.CommandEventName };
+        // This is logged in Part C.
+        const command = {
             options: (_a = Telemetry.commandInfo.startInfo) === null || _a === void 0 ? void 0 : _a.options,
             defaultOptions: (_b = Telemetry.commandInfo.startInfo) === null || _b === void 0 ? void 0 : _b.defaultOptions,
             args: (_c = Telemetry.commandInfo.startInfo) === null || _c === void 0 ? void 0 : _c.args,
@@ -297,41 +298,38 @@ class Telemetry {
                 1000,
             resultCode: (_d = Telemetry.commandInfo.endInfo) === null || _d === void 0 ? void 0 : _d.resultCode,
         };
-        // Set remaining common props
-        props.project = Telemetry.projectProp;
-        props.versions = Telemetry.versionsProp;
-        // Set extra props
-        props.extraProps = {};
-        Object.assign(props.extraProps, extraProps);
-        // Fire event
-        Telemetry.client.trackEvent({ name: props.eventName, properties: props });
-        Telemetry.client.flush();
+        telemetryItem.data = {
+            command: command,
+        };
+        if (extraProps) {
+            telemetryItem.data.additionalData = extraProps;
+        }
+        // Populate common properties and fire event
+        Telemetry.trackEvent(telemetryItem);
     }
     static trackException(error, extraProps) {
         var _a, _b;
-        if (!Telemetry.client) {
+        if (!Telemetry.appInsightsCore) {
             return;
         }
-        const props = {
-            eventName: exports.CodedErrorEventName,
-        };
-        // Save off CodedError info
+        const telemetryItem = { name: exports.CodedErrorEventName };
+        // Save off CodedError info in Part C.
         const codedError = error instanceof errorUtils.CodedError
             ? error
             : null;
-        props.codedError = {
+        const codedErrorStruct = {
             type: (_a = codedError === null || codedError === void 0 ? void 0 : codedError.type) !== null && _a !== void 0 ? _a : 'Unknown',
             data: (_b = codedError === null || codedError === void 0 ? void 0 : codedError.data) !== null && _b !== void 0 ? _b : {},
         };
         // Copy msBuildErrorMessages into the codedError.data object
         if (error.msBuildErrorMessages) {
             // Always grab MSBuild error codes if possible
-            props.codedError.data.msBuildErrors = error.msBuildErrorMessages
+            codedErrorStruct.data.msBuildErrors = error.msBuildErrorMessages
                 .map(errorUtils.tryGetErrorCode)
                 .filter((msg) => msg);
             // Grab sanitized MSBuild error messages if we're preserving them
             if (Telemetry.options.preserveErrorMessages) {
-                props.codedError.data.msBuildErrorMessages = error.msBuildErrorMessages
+                codedErrorStruct.data.msBuildErrorMessages = error.msBuildErrorMessages
                     .map(errorUtils.sanitizeErrorMessage)
                     .filter((msg) => msg);
             }
@@ -340,32 +338,97 @@ class Telemetry {
         const syscallExceptionFieldsToCopy = ['errno', 'syscall', 'code'];
         for (const f of syscallExceptionFieldsToCopy) {
             if (error[f]) {
-                props.codedError.data[f] = error[f];
+                codedErrorStruct.data[f] = error[f];
             }
         }
-        // Set remaining common props
-        props.project = Telemetry.projectProp;
-        props.versions = Telemetry.versionsProp;
-        // Set extra props
-        props.extraProps = {};
-        Object.assign(props.extraProps, extraProps);
-        // Fire event
-        Telemetry.client.trackException({
-            exception: error,
-            properties: props,
+        // Scrub any potential PII present in codedError.data array, as long as the data is a string.
+        codedErrorStruct.data = Telemetry.sanitizeAny(codedErrorStruct.data);
+        // Break down TS Error object into Exception Data
+        const exceptionData = Telemetry.convertErrorIntoExceptionData(error);
+        telemetryItem.data = {
+            codedError: codedErrorStruct,
+            exceptionData: exceptionData,
+        };
+        Telemetry.trackEvent(telemetryItem);
+    }
+    static convertErrorIntoExceptionData(error) {
+        var _a;
+        const exceptionData = {
+            hasFullStack: false,
+            message: error.message,
+            parsedStack: {},
+        };
+        exceptionData.message = exceptionData.message || '[None]';
+        // CodedError has non-PII information in its 'type' member, plus optionally some more info in its 'data'.
+        // The message may contain PII information. This can be sanitized, but for now delete it.
+        if (Telemetry.options.preserveErrorMessages) {
+            exceptionData.message = errorUtils.sanitizeErrorMessage(exceptionData.message);
+        }
+        else {
+            exceptionData.message = '[Removed]';
+        }
+        const lines = (_a = error.stack) === null || _a === void 0 ? void 0 : _a.split('\n');
+        const parsedStack = lines === null || lines === void 0 ? void 0 : lines.slice(1).map(line => {
+            const errorStackFrame = {};
+            const match = line
+                .trim()
+                .match(/^\s*at\s+(?:(.*?)\s+\((.*):(\d+):(\d+)\)|(.*):(\d+):(\d+))$/);
+            if (match) {
+                errorStackFrame.functionName = match[1] || 'N/A'; // Use a default value if no function name
+                errorStackFrame.filePath = match[2] || match[5];
+                errorStackFrame.lineNumber =
+                    parseInt(match[3], 10) || parseInt(match[6], 10);
+                errorStackFrame.columnNumber =
+                    parseInt(match[4], 10) || parseInt(match[7], 10);
+            }
+            return errorStackFrame;
         });
-        Telemetry.client.flush();
+        if (parsedStack) {
+            parsedStack.filter(Boolean);
+            // Sanitize parsed error stack frames
+            for (const frame of parsedStack) {
+                errorUtils.sanitizeErrorStackFrame(frame);
+            }
+            exceptionData.hasFullStack = true;
+            exceptionData.parsedStack = parsedStack;
+        }
+        return exceptionData;
+    }
+    static sanitizeAny(data) {
+        if (Array.isArray(data)) {
+            // This is an array, sanitize each element recursively.
+            return data.map(item => Telemetry.sanitizeAny(item));
+        }
+        else if (typeof data === 'object' && data !== null) {
+            // This is an object, sanitize each field recursively.
+            const sanitizedObject = {};
+            for (const key in data) {
+                if (Object.prototype.hasOwnProperty.call(data, key)) {
+                    sanitizedObject[key] = Telemetry.sanitizeAny(data[key]);
+                }
+            }
+            return sanitizedObject;
+        }
+        else if (typeof data === 'string') {
+            // The base case: this is a string, sanitize it.
+            return errorUtils.sanitizeErrorMessage(data);
+        }
+        // Not a string, return the data unchanged.
+        return data;
     }
 }
-Telemetry.client = undefined;
+Telemetry.appInsightsCore = undefined;
 Telemetry.options = {
     setupString: Telemetry.getDefaultSetupString(),
     preserveErrorMessages: false,
     populateNpmPackageVersions: true,
 };
-Telemetry.isTest = basePropUtils.isCliTest();
+Telemetry.isTestEnvironment = basePropUtils.isCliTest();
 Telemetry.commandInfo = {};
+// Stores the version of a list of packages used by the RNW app project.
 Telemetry.versionsProp = {};
 Telemetry.projectProp = undefined;
+// Store "Common Properties" in a single object. This will be logged in all telemetry events.
+Telemetry.commonProperties = {};
 exports.Telemetry = Telemetry;
 //# sourceMappingURL=telemetry.js.map